removed node map file and utilities, added formal class methods to session objects and added checks for specific classes where needed

daemon/core/nodes/base.py

@@ -17,7 +17,7 @@ from socket import AF_INET, AF_INET6
 from core import CoreCommandError, constants, utils
 from core.emulator.data import LinkData, NodeData
 from core.emulator.enumerations import LinkTypes, NodeTypes
-from core.nodes import client, ipaddress, nodeutils
+from core.nodes import client, ipaddress
 from core.nodes.interface import CoreInterface, TunTap, Veth
 
 _DEFAULT_MTU = 1500
@@ -886,8 +886,8 @@ class CoreNode(CoreNodeBase):
             addrlist = []
 
         with self.lock:
-            # TODO: see if you can move this to emane specific code
-            if nodeutils.is_node(net, NodeTypes.EMANE):
+            # TODO: emane specific code
+            if net.is_emane is True:
                 ifindex = self.newtuntap(ifindex=ifindex, ifname=ifname, net=net)
                 # TUN/TAP is not ready for addressing yet; the device may
                 #   take some time to appear, and installing it into a
@@ -1050,6 +1050,7 @@ class CoreNetworkBase(NodeBase):
     """
 
     linktype = LinkTypes.WIRED.value
+    is_emane = False
 
     def __init__(self, session, _id, name, start=True):
         """

daemon/core/nodes/interface.py

@@ -7,8 +7,6 @@ import time
 from builtins import int, range
 
 from core import CoreCommandError, constants, utils
-from core.emulator.enumerations import NodeTypes
-from core.nodes import nodeutils
 
 utils.check_executables([constants.IP_BIN])
 
@@ -387,13 +385,12 @@ class TunTap(CoreInterface):
             if result:
                 break
 
+            # TODO: emane specific code
             # check if this is an EMANE interface; if so, continue
             # waiting if EMANE is still running
-            # TODO: remove emane code
             should_retry = count < 5
-            is_emane_node = nodeutils.is_node(self.net, NodeTypes.EMANE)
             is_emane_running = self.node.session.emane.emanerunning(self.node)
-            if all([should_retry, is_emane_node, is_emane_running]):
+            if all([should_retry, self.net.is_emane, is_emane_running]):
                 count += 1
             else:
                 raise RuntimeError("node device failed to exist")

daemon/core/nodes/nodemaps.py

@@ -1,32 +0,0 @@
-"""
-Provides default node maps that can be used to run core with.
-"""
-import core.nodes.base
-import core.nodes.docker
-import core.nodes.lxd
-import core.nodes.network
-import core.nodes.physical
-from core.emane.nodes import EmaneNet, EmaneNode
-from core.emulator.enumerations import NodeTypes
-from core.nodes import physical
-from core.nodes.network import GreTapBridge
-
-# legacy core nodes, that leverage linux bridges
-NODES = {
-    NodeTypes.DEFAULT: core.nodes.base.CoreNode,
-    NodeTypes.PHYSICAL: physical.PhysicalNode,
-    NodeTypes.TBD: None,
-    NodeTypes.SWITCH: core.nodes.network.SwitchNode,
-    NodeTypes.HUB: core.nodes.network.HubNode,
-    NodeTypes.WIRELESS_LAN: core.nodes.network.WlanNode,
-    NodeTypes.RJ45: core.nodes.physical.Rj45Node,
-    NodeTypes.TUNNEL: core.nodes.network.TunnelNode,
-    NodeTypes.KTUNNEL: None,
-    NodeTypes.EMANE: EmaneNode,
-    NodeTypes.EMANE_NET: EmaneNet,
-    NodeTypes.TAP_BRIDGE: GreTapBridge,
-    NodeTypes.PEER_TO_PEER: core.nodes.network.PtpNet,
-    NodeTypes.CONTROL_NET: core.nodes.network.CtrlNet,
-    NodeTypes.DOCKER: core.nodes.docker.DockerNode,
-    NodeTypes.LXC: core.nodes.lxd.LxcNode,
-}

daemon/core/nodes/nodeutils.py

@@ -1,97 +0,0 @@
-"""
-Serves as a global point for storing and retrieving node types needed during simulation.
-"""
-
-import logging
-
-_NODE_MAP = None
-
-
-def _log_map():
-    global _NODE_MAP
-    for key in _NODE_MAP:
-        value = _NODE_MAP[key]
-        name = None
-        if value:
-            name = value.__name__
-        logging.debug("node type (%s) - class (%s)", key.name, name)
-
-
-def _convert_map(x, y):
-    """
-    Convenience method to create a human readable version of the node map to log.
-
-    :param dict x: dictionary to reduce node items into
-    :param tuple y: current node item
-    :return: human readable name mapping of the node map
-    """
-    x[y[0].name] = y[1]
-    return x
-
-
-def update_node_map(node_map):
-    """
-    Update the current node map with the provided node map values.
-
-    :param dict node_map: node map to update with
-    """
-    global _NODE_MAP
-    _NODE_MAP.update(node_map)
-    _log_map()
-
-
-def set_node_map(node_map):
-    """
-    Set the global node map that proides a consistent way to retrieve differently configured nodes.
-
-    :param dict node_map: node map to set to
-    :return: nothing
-    """
-    global _NODE_MAP
-    _NODE_MAP = node_map
-    _log_map()
-
-
-def get_node_class(node_type):
-    """
-    Retrieve the node class for a given node type.
-
-    :param int node_type: node type to retrieve class for
-    :return: node class
-    """
-    global _NODE_MAP
-    return _NODE_MAP[node_type]
-
-
-def get_node_type(node_class):
-    """
-    Retrieve the node type given a node class.
-
-    :param class node_class: node class to get type for
-    :return: node type
-    :rtype: core.emulator.enumerations.NodeTypes
-    """
-    global _NODE_MAP
-    node_type_map = {_NODE_MAP[x]: x for x in _NODE_MAP}
-    return node_type_map.get(node_class)
-
-
-def is_node(obj, node_types):
-    """
-    Validates if an object is one of the provided node types.
-
-    :param obj: object to check type for
-    :param int|tuple|list node_types: node type(s) to check against
-    :return: True if the object is one of the node types, False otherwise
-    :rtype: bool
-    """
-    type_classes = []
-    if isinstance(node_types, (tuple, list)):
-        for node_type in node_types:
-            type_class = get_node_class(node_type)
-            type_classes.append(type_class)
-    else:
-        type_class = get_node_class(node_types)
-        type_classes.append(type_class)
-
-    return isinstance(obj, tuple(type_classes))