set default logging to INFO, cleaned up logging to help isolate debug type messages to DEBUG level, fixed issue with shutdown

Author: bharnden

daemon/core/api/coreapi.py

@@ -10,7 +10,6 @@
 
 from enum import Enum
 
-from core import logger
 from core.enumerations import ConfigTlvs
 from core.enumerations import EventTlvs
 from core.enumerations import EventTypes
@@ -275,7 +274,6 @@ def new_obj(value):
         :return: Ipv4 address
         :rtype: core.misc.ipaddress.IpAddress
         """
-        logger.info("getting new ipv4 address for: %s", value)
         return IpAddress(af=socket.AF_INET, address=value)
 
 

daemon/core/broker.py

@@ -158,7 +158,7 @@ def reset(self):
         """
         Reset to initial state.
         """
-        logger.info("broker reset")
+        logger.info("clearing state")
         self.nodemap_lock.acquire()
         self.nodemap.clear()
         for server, count in self.nodecounts.iteritems():
@@ -302,7 +302,7 @@ def addserver(self, name, host, port):
                 server.close()
                 del self.servers[name]
 
-            logger.info("adding server: %s @ %s:%s" % (name, host, port))
+            logger.info("adding broker server(%s): %s:%s" % (name, host, port))
             server = CoreDistributedServer(name, host, port)
             if host is not None and port is not None:
                 try:
@@ -432,7 +432,7 @@ def addnettunnels(self):
         Add GreTaps between network devices on different machines.
         The GreTapBridge is not used since that would add an extra bridge.
         """
-        logger.info("adding network tunnels for nodes: %s", self.network_nodes)
+        logger.debug("adding network tunnels for nodes: %s", self.network_nodes)
         for n in self.network_nodes:
             self.addnettunnel(n)
 
@@ -531,7 +531,7 @@ def gettunnel(self, n1num, n2num):
         :return: gre tap between nodes or none
         """
         key = self.tunnelkey(n1num, n2num)
-        logger.info("checking for tunnel(%s) in: %s", key, self.tunnels.keys())
+        logger.debug("checking for tunnel(%s) in: %s", key, self.tunnels.keys())
         if key in self.tunnels.keys():
             return self.tunnels[key]
         else:
@@ -709,8 +709,6 @@ def handle_message(self, message):
         if message.message_type == MessageTypes.LINK.value:
             # prepare a server list from two node numbers in link message
             handle_locally, servers, message = self.handlelinkmsg(message)
-            logger.info("broker handle link message: %s - %s", handle_locally,
-                        map(lambda x: "%s:%s" % (x.host, x.port), servers))
         elif len(servers) == 0:
             # check for servers based on node numbers in all messages but link
             nn = message.node_numbers()
@@ -868,7 +866,7 @@ def handlelinkmsg(self, message):
 
         # determine link message destination using non-network nodes
         nn = message.node_numbers()
-        logger.info("checking link nodes (%s) with network nodes (%s)", nn, self.network_nodes)
+        logger.debug("checking link nodes (%s) with network nodes (%s)", nn, self.network_nodes)
         if nn[0] in self.network_nodes:
             if nn[1] in self.network_nodes:
                 # two network nodes linked together - prevent loops caused by
@@ -879,11 +877,11 @@ def handlelinkmsg(self, message):
         elif nn[1] in self.network_nodes:
             servers = self.getserversbynode(nn[0])
         else:
-            logger.info("link nodes are not network nodes")
+            logger.debug("link nodes are not network nodes")
             servers1 = self.getserversbynode(nn[0])
-            logger.info("servers for node(%s): %s", nn[0], servers1)
+            logger.debug("servers for node(%s): %s", nn[0], servers1)
             servers2 = self.getserversbynode(nn[1])
-            logger.info("servers for node(%s): %s", nn[1], servers2)
+            logger.debug("servers for node(%s): %s", nn[1], servers2)
             # nodes are on two different servers, build tunnels as needed
             if servers1 != servers2:
                 localn = None
@@ -912,7 +910,7 @@ def handlelinkmsg(self, message):
                 if host is None:
                     host = self.getlinkendpoint(message, localn == nn[0])
 
-                logger.info("handle locally(%s) and local node(%s)", handle_locally, localn)
+                logger.debug("handle locally(%s) and local node(%s)", handle_locally, localn)
                 if localn is None:
                     message = self.addlinkendpoints(message, servers1, servers2)
                 elif message.flags & MessageFlags.ADD.value:

daemon/core/conf.py

@@ -212,16 +212,15 @@ def setconfig_keyvalues(self, nodenum, conftype, keyvalues):
         :return: nothing
         """
         if conftype not in self._modelclsmap:
-            logger.warn("Unknown model type '%s'" % conftype)
+            logger.warn("unknown model type '%s'", conftype)
             return
         model = self._modelclsmap[conftype]
         keys = model.getnames()
         # defaults are merged with supplied values here
         values = list(model.getdefaultvalues())
         for key, value in keyvalues:
             if key not in keys:
-                logger.warn("Skipping unknown configuration key for %s: '%s'" % \
-                            (conftype, key))
+                logger.warn("Skipping unknown configuration key for %s: '%s'", conftype, key)
                 continue
             i = keys.index(key)
             values[i] = value
@@ -327,7 +326,7 @@ def configure(cls, manager, config_data):
         if interface_id is not None:
             node_id = node_id * 1000 + interface_id
 
-        logger.info("received configure message for %s nodenum:%s", cls.name, str(node_id))
+        logger.debug("received configure message for %s nodenum:%s", cls.name, str(node_id))
         if config_type == ConfigFlags.REQUEST.value:
             logger.info("replying to configure request for %s model", cls.name)
             # when object name is "all", the reply to this request may be None

daemon/core/emane/emanemanager.py

@@ -168,8 +168,7 @@ def load_models(self, emane_models):
         load EMANE models and make them available.
         """
         for emane_model in emane_models:
-            logger.info("loading emane model: (%s) %s - %s",
-                        emane_model, emane_model.name, RegisterTlvs(emane_model.config_type))
+            logger.info("loading emane model: %s", emane_model.__name__)
             self._modelclsmap[emane_model.name] = emane_model
             self.session.add_config_object(emane_model.name, emane_model.config_type, emane_model.configure_emane)
 

daemon/core/future/coreemu.py

@@ -142,7 +142,7 @@ def _link_nodes(self, node_one_id, node_two_id):
         :return: nodes, network nodes if present, and tunnel if present
         :rtype: tuple
         """
-        logger.info("link message between node1(%s) and node2(%s)", node_one_id, node_two_id)
+        logger.debug("link message between node1(%s) and node2(%s)", node_one_id, node_two_id)
 
         # values to fill
         net_one = None
@@ -154,7 +154,7 @@ def _link_nodes(self, node_one_id, node_two_id):
 
         # both node ids are provided
         tunnel = self.broker.gettunnel(node_one_id, node_two_id)
-        logger.info("tunnel between nodes: %s", tunnel)
+        logger.debug("tunnel between nodes: %s", tunnel)
         if nodeutils.is_node(tunnel, NodeTypes.TAP_BRIDGE):
             net_one = tunnel
             if tunnel.remotenum == node_one_id:
@@ -182,8 +182,8 @@ def _link_nodes(self, node_one_id, node_two_id):
                 net_two = node_two
             node_two = None
 
-        logger.info("link node types n1(%s) n2(%s) net1(%s) net2(%s) tunnel(%s)",
-                    node_one, node_two, net_one, net_two, tunnel)
+        logger.debug("link node types n1(%s) n2(%s) net1(%s) net2(%s) tunnel(%s)",
+                     node_one, node_two, net_one, net_two, tunnel)
         return node_one, node_two, net_one, net_two, tunnel
 
     # TODO: this doesn't appear to ever be used, EMANE or basic wireless range
@@ -198,7 +198,7 @@ def _link_wireless(self, objects, connect):
         objects = [x for x in objects if x]
         if len(objects) < 2:
             raise ValueError("wireless link failure: %s", objects)
-        logger.info("handling wireless linking objects(%) connect(%s)", objects, connect)
+        logger.debug("handling wireless linking objects(%) connect(%s)", objects, connect)
         common_networks = objects[0].commonnets(objects[1])
         if not common_networks:
             raise ValueError("no common network found for wireless link/unlink")
@@ -242,23 +242,27 @@ def add_link(self, node_one_id, node_two_id, interface_one=None, interface_two=N
             else:
                 # 2 nodes being linked, ptp network
                 if all([node_one, node_two]) and not net_one:
+                    logger.info("adding link for peer to peer nodes: %s - %s", node_one.name, node_two.name)
                     ptp_class = nodeutils.get_node_class(NodeTypes.PEER_TO_PEER)
                     start = self.state > EventTypes.DEFINITION_STATE.value
                     net_one = self.add_object(cls=ptp_class, start=start)
 
                 # node to network
                 if node_one and net_one:
+                    logger.info("adding link from node to network: %s - %s", node_one.name, net_one.name)
                     interface = create_interface(node_one, net_one, interface_one)
                     link_config(net_one, interface, link_options)
 
                 # network to node
                 if node_two and net_one:
+                    logger.info("adding link from network to node: %s - %s", node_two.name, net_one.name)
                     interface = create_interface(node_two, net_one, interface_two)
                     if not link_options.unidirectional:
                         link_config(net_one, interface, link_options)
 
                 # network to network
                 if net_one and net_two:
+                    logger.info("adding link from network to network: %s", net_one.name, net_two.name)
                     if nodeutils.is_node(net_two, NodeTypes.RJ45):
                         interface = net_two.linknet(net_one)
                     else:
@@ -282,21 +286,25 @@ def add_link(self, node_one_id, node_two_id, interface_one=None, interface_two=N
                 # tunnel node logic
                 key = link_options.key
                 if key and nodeutils.is_node(net_one, NodeTypes.TUNNEL):
+                    logger.info("setting tunnel key for: %s", net_one.name)
                     net_one.setkey(key)
                     if addresses:
                         net_one.addrconfig(addresses)
                 if key and nodeutils.is_node(net_two, NodeTypes.TUNNEL):
+                    logger.info("setting tunnel key for: %s", net_two.name)
                     net_two.setkey(key)
                     if addresses:
                         net_two.addrconfig(addresses)
 
                 # physical node connected with tunnel
                 if not net_one and not net_two and (node_one or node_two):
                     if node_one and nodeutils.is_node(node_one, NodeTypes.PHYSICAL):
+                        logger.info("adding link for physical node: %s", node_one.name)
                         addresses = interface_one.get_addresses()
                         node_one.adoptnetif(tunnel, interface_one.id, interface_one.mac, addresses)
                         link_config(node_one, tunnel, link_options)
                     elif node_two and nodeutils.is_node(node_two, NodeTypes.PHYSICAL):
+                        logger.info("adding link for physical node: %s", node_two.name)
                         addresses = interface_two.get_addresses()
                         node_two.adoptnetif(tunnel, interface_two.id, interface_two.mac, addresses)
                         link_config(node_two, tunnel, link_options)
@@ -351,11 +359,12 @@ def delete_link(self, node_one_id, node_two_id, interface_one_id, interface_two_
                                 interface_two = common_interface_two
                                 break
 
-                    logger.info("deleting link for interfaces interface_one(%s) interface_two(%s)",
-                                interface_one, interface_two)
                     if all([interface_one, interface_two]) and any([interface_one.net, interface_two.net]):
                         if interface_one.net != interface_two.net and all([interface_one.up, interface_two.up]):
                             raise ValueError("no common network found")
+
+                        logger.info("deleting link node(%s):interface(%s) node(%s):interface(%s)",
+                                    node_one.name, interface_one.name, node_two.name, interface_two.name)
                         net_one = interface_one.net
                         interface_one.detachnet()
                         interface_two.detachnet()
@@ -488,7 +497,7 @@ def add_node(self, _type=NodeTypes.DEFAULT, _id=None, node_options=NodeOptions()
             name = "%s%s" % (node_class.__name__, _id)
 
         # create node
-        logger.info("creating node(%s) id(%s) name(%s) start(%s)", node_class, _id, name, start)
+        logger.info("creating node(%s) id(%s) name(%s) start(%s)", node_class.__name__, _id, name, start)
         node = self.add_object(cls=node_class, objid=_id, name=name, start=start)
 
         # set node attributes
@@ -503,7 +512,6 @@ def add_node(self, _type=NodeTypes.DEFAULT, _id=None, node_options=NodeOptions()
         if _type in [NodeTypes.DEFAULT, NodeTypes.PHYSICAL]:
             node.type = node_options.model
             logger.debug("set node type: %s", node.type)
-            logger.info("setting model (%s) with services (%s)", node.type, node_options.services)
             services = "|".join(node_options.services) or None
             self.services.addservicestonode(node, node.type, services)
 
@@ -874,9 +882,10 @@ def shutdown(self):
         :return: nothing
         """
         logger.info("shutting down all session")
-        for session in self.sessions.values():
-            session.shutdown()
+        sessions = self.sessions.copy()
         self.sessions.clear()
+        for session in sessions.itervalues():
+            session.shutdown()
 
     def create_session(self, _id=None, master=True):
         """