updated tests for running distributed to working order and adding simple emane case

daemon/core/api/tlv/corehandlers.py

@@ -628,7 +628,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
         """
         Node Message handler
 
-        :param core.api.coreapi.CoreNodeMessage message: node message
+        :param core.api.tlv.coreapi.CoreNodeMessage message: node message
         :return: replies to node message
         """
         replies = []

daemon/tests/conftest.py

@@ -9,134 +9,22 @@ import time
 import pytest
 from mock.mock import MagicMock
 
-from core.api.tlv.coreapi import CoreConfMessage
+from core.api.grpc.client import InterfaceHelper
-from core.api.tlv.coreapi import CoreEventMessage
+from core.api.grpc.server import CoreGrpcServer
-from core.api.tlv.coreapi import CoreExecMessage
+from core.api.tlv.coreapi import CoreConfMessage, CoreEventMessage
-from core.api.tlv.coreapi import CoreLinkMessage
-from core.api.tlv.coreapi import CoreNodeMessage
 from core.api.tlv.corehandlers import CoreHandler
 from core.api.tlv.coreserver import CoreServer
 from core.emulator.coreemu import CoreEmu
 from core.emulator.emudata import IpPrefixes
-from core.emulator.enumerations import CORE_API_PORT
+from core.emulator.enumerations import CORE_API_PORT, EventTlvs
 from core.emulator.enumerations import ConfigTlvs
-from core.emulator.enumerations import EventTlvs
 from core.emulator.enumerations import EventTypes
-from core.emulator.enumerations import ExecuteTlvs
-from core.emulator.enumerations import LinkTlvs
-from core.emulator.enumerations import LinkTypes
-from core.emulator.enumerations import MessageFlags
-from core.emulator.enumerations import NodeTlvs
-from core.emulator.enumerations import NodeTypes
-from core.api.grpc.client import InterfaceHelper
-from core.api.grpc.server import CoreGrpcServer
 from core.nodes import ipaddress
-from core.nodes.ipaddress import MacAddress
 from core.services.coreservices import ServiceManager
 
 EMANE_SERVICES = "zebra|OSPFv3MDR|IPForward"
 
 
-def node_message(_id, name, emulation_server=None, node_type=NodeTypes.DEFAULT, model=None):
-    """
-    Convenience method for creating a node TLV messages.
-
-    :param int _id: node id
-    :param str name: node name
-    :param str emulation_server: distributed server name, if desired
-    :param core.enumerations.NodeTypes node_type: node type
-    :param str model: model for node
-    :return: tlv message
-    :rtype: core.api.coreapi.CoreNodeMessage
-    """
-    values = [
-        (NodeTlvs.NUMBER, _id),
-        (NodeTlvs.TYPE, node_type.value),
-        (NodeTlvs.NAME, name),
-        (NodeTlvs.EMULATION_SERVER, emulation_server),
-    ]
-
-    if model:
-        values.append((NodeTlvs.MODEL, model))
-
-    return CoreNodeMessage.create(MessageFlags.ADD.value, values)
-
-
-def link_message(n1, n2, intf_one=None, address_one=None, intf_two=None, address_two=None, key=None):
-    """
-    Convenience method for creating link TLV messages.
-
-    :param int n1: node one id
-    :param int n2: node two id
-    :param int intf_one: node one interface id
-    :param core.misc.ipaddress.IpAddress address_one: node one ip4 address
-    :param int intf_two: node two interface id
-    :param core.misc.ipaddress.IpAddress address_two: node two ip4 address
-    :param int key: tunnel key for link if needed
-    :return: tlv mesage
-    :rtype: core.api.coreapi.CoreLinkMessage
-    """
-    mac_one, mac_two = None, None
-    if address_one:
-        mac_one = MacAddress.random()
-    if address_two:
-        mac_two = MacAddress.random()
-
-    values = [
-        (LinkTlvs.N1_NUMBER, n1),
-        (LinkTlvs.N2_NUMBER, n2),
-        (LinkTlvs.DELAY, 0),
-        (LinkTlvs.BANDWIDTH, 0),
-        (LinkTlvs.PER, "0"),
-        (LinkTlvs.DUP, "0"),
-        (LinkTlvs.JITTER, 0),
-        (LinkTlvs.TYPE, LinkTypes.WIRED.value),
-        (LinkTlvs.INTERFACE1_NUMBER, intf_one),
-        (LinkTlvs.INTERFACE1_IP4, address_one),
-        (LinkTlvs.INTERFACE1_IP4_MASK, 24),
-        (LinkTlvs.INTERFACE1_MAC, mac_one),
-        (LinkTlvs.INTERFACE2_NUMBER, intf_two),
-        (LinkTlvs.INTERFACE2_IP4, address_two),
-        (LinkTlvs.INTERFACE2_IP4_MASK, 24),
-        (LinkTlvs.INTERFACE2_MAC, mac_two),
-    ]
-
-    if key:
-        values.append((LinkTlvs.KEY, key))
-
-    return CoreLinkMessage.create(MessageFlags.ADD.value, values)
-
-
-def command_message(node, command):
-    """
-    Create an execute command TLV message.
-
-    :param node: node to execute command for
-    :param command: command to execute
-    :return: tlv message
-    :rtype: core.api.coreapi.CoreExecMessage
-    """
-    flags = MessageFlags.STRING.value | MessageFlags.TEXT.value
-    return CoreExecMessage.create(flags, [
-        (ExecuteTlvs.NODE, node.id),
-        (ExecuteTlvs.NUMBER, 1),
-        (ExecuteTlvs.COMMAND, command)
-    ])
-
-
-def state_message(state):
-    """
-    Create a event TLV message for a new state.
-
-    :param core.enumerations.EventTypes state: state to create message for
-    :return: tlv message
-    :rtype: core.api.coreapi.CoreEventMessage
-    """
-    return CoreEventMessage.create(0, [
-        (EventTlvs.TYPE, state.value)
-    ])
-
-
 class CoreServerTest(object):
     def __init__(self, port=CORE_API_PORT):
         self.host = "localhost"
@@ -152,13 +40,12 @@ class CoreServerTest(object):
         self.session = None
         self.request_handler = None
 
-    def setup(self, distributed_address, port):
+    def setup(self, distributed_address):
         # validate address
         assert distributed_address, "distributed server address was not provided"
 
         # create session
         self.session = self.server.coreemu.create_session(1)
-        self.session.master = True
 
         # create request handler
         request_mock = MagicMock()
@@ -170,11 +57,11 @@ class CoreServerTest(object):
 
         # have broker handle a configuration state change
         self.session.set_state(EventTypes.DEFINITION_STATE)
-        message = state_message(EventTypes.CONFIGURATION_STATE)
+        message = CoreEventMessage.create(0, [(EventTlvs.TYPE, EventTypes.CONFIGURATION_STATE.value)])
         self.request_handler.handle_message(message)
 
         # add broker server for distributed core
-        distributed = "%s:%s:%s" % (self.distributed_server, distributed_address, port)
+        distributed = "%s:%s:%s" % (self.distributed_server, distributed_address, self.port)
         message = CoreConfMessage.create(0, [
             (ConfigTlvs.OBJECT, "broker"),
             (ConfigTlvs.TYPE, 0),
@@ -204,7 +91,6 @@ class CoreServerTest(object):
 
     def shutdown(self):
         self.server.coreemu.shutdown()
-        self.server.shutdown()
         self.server.server_close()
 
 

daemon/tests/distributed/test_distributed.py

@@ -1,15 +1,125 @@
 """
 Unit tests for testing CORE with distributed networks.
 """
+from core.emane.ieee80211abg import EmaneIeee80211abgModel
 
-import conftest
+from core.api.tlv.coreapi import CoreExecMessage, CoreNodeMessage, CoreLinkMessage, CoreEventMessage, CoreConfMessage
-
+from core.emulator.enumerations import EventTypes, NodeTlvs, LinkTlvs, LinkTypes, EventTlvs, ConfigTlvs, ConfigFlags
-from core.api.tlv.coreapi import CoreExecMessage
-from core.emulator.enumerations import EventTypes
 from core.emulator.enumerations import ExecuteTlvs
 from core.emulator.enumerations import MessageFlags
 from core.emulator.enumerations import NodeTypes
-from core.nodes.ipaddress import IpAddress
+from core.nodes.ipaddress import IpAddress, MacAddress, Ipv4Prefix
+
+
+def set_emane_model(node_id, model):
+    return CoreConfMessage.create(0, [
+        (ConfigTlvs.NODE, node_id),
+        (ConfigTlvs.OBJECT, model),
+        (ConfigTlvs.TYPE, ConfigFlags.UPDATE.value),
+    ])
+
+
+def node_message(_id, name, emulation_server=None, node_type=NodeTypes.DEFAULT, model=None):
+    """
+    Convenience method for creating a node TLV messages.
+
+    :param int _id: node id
+    :param str name: node name
+    :param str emulation_server: distributed server name, if desired
+    :param core.emulator.enumerations.NodeTypes node_type: node type
+    :param str model: model for node
+    :return: tlv message
+    :rtype: core.api.tlv.coreapi.CoreNodeMessage
+    """
+    values = [
+        (NodeTlvs.NUMBER, _id),
+        (NodeTlvs.TYPE, node_type.value),
+        (NodeTlvs.NAME, name),
+        (NodeTlvs.EMULATION_SERVER, emulation_server),
+        (NodeTlvs.X_POSITION, 0),
+        (NodeTlvs.Y_POSITION, 0),
+    ]
+
+    if model:
+        values.append((NodeTlvs.MODEL, model))
+
+    return CoreNodeMessage.create(MessageFlags.ADD.value, values)
+
+
+def link_message(n1, n2, intf_one=None, address_one=None, intf_two=None, address_two=None, key=None, mask=24):
+    """
+    Convenience method for creating link TLV messages.
+
+    :param int n1: node one id
+    :param int n2: node two id
+    :param int intf_one: node one interface id
+    :param core.nodes.ipaddress.IpAddress address_one: node one ip4 address
+    :param int intf_two: node two interface id
+    :param core.nodes.ipaddress.IpAddress address_two: node two ip4 address
+    :param int key: tunnel key for link if needed
+    :param int mask: ip4 mask to use for link
+    :return: tlv mesage
+    :rtype: core.api.tlv.coreapi.CoreLinkMessage
+    """
+    mac_one, mac_two = None, None
+    if address_one:
+        mac_one = MacAddress.random()
+    if address_two:
+        mac_two = MacAddress.random()
+
+    values = [
+        (LinkTlvs.N1_NUMBER, n1),
+        (LinkTlvs.N2_NUMBER, n2),
+        (LinkTlvs.DELAY, 0),
+        (LinkTlvs.BANDWIDTH, 0),
+        (LinkTlvs.PER, "0"),
+        (LinkTlvs.DUP, "0"),
+        (LinkTlvs.JITTER, 0),
+        (LinkTlvs.TYPE, LinkTypes.WIRED.value),
+        (LinkTlvs.INTERFACE1_NUMBER, intf_one),
+        (LinkTlvs.INTERFACE1_IP4, address_one),
+        (LinkTlvs.INTERFACE1_IP4_MASK, mask),
+        (LinkTlvs.INTERFACE1_MAC, mac_one),
+        (LinkTlvs.INTERFACE2_NUMBER, intf_two),
+        (LinkTlvs.INTERFACE2_IP4, address_two),
+        (LinkTlvs.INTERFACE2_IP4_MASK, mask),
+        (LinkTlvs.INTERFACE2_MAC, mac_two),
+    ]
+
+    if key:
+        values.append((LinkTlvs.KEY, key))
+
+    return CoreLinkMessage.create(MessageFlags.ADD.value, values)
+
+
+def command_message(node, command):
+    """
+    Create an execute command TLV message.
+
+    :param node: node to execute command for
+    :param command: command to execute
+    :return: tlv message
+    :rtype: core.api.tlv.coreapi.CoreExecMessage
+    """
+    flags = MessageFlags.STRING.value | MessageFlags.TEXT.value
+    return CoreExecMessage.create(flags, [
+        (ExecuteTlvs.NODE, node.id),
+        (ExecuteTlvs.NUMBER, 1),
+        (ExecuteTlvs.COMMAND, command)
+    ])
+
+
+def state_message(state):
+    """
+    Create a event TLV message for a new state.
+
+    :param core.enumerations.EventTypes state: state to create message for
+    :return: tlv message
+    :rtype: core.api.tlv.coreapi.CoreEventMessage
+    """
+    return CoreEventMessage.create(0, [
+        (EventTlvs.TYPE, state.value)
+    ])
 
 
 def validate_response(replies, _):
@@ -28,18 +138,18 @@ def validate_response(replies, _):
 
 
 class TestDistributed:
-    def test_distributed(self, cored, distributed_address):
+    def test_switch(self, cored, distributed_address):
         """
-        Test creating a distributed network.
+        Test creating a distributed switch network.
 
-        :param core.coreserver.CoreServer conftest.Core cored: core daemon server to test with
+        :param core.api.tlv.coreserver.CoreServer conftest.Core cored: core daemon server to test with
         :param str distributed_address: distributed server to test against
         """
         # initialize server for testing
         cored.setup(distributed_address)
 
         # create local node
-        message = conftest.node_message(
+        message = node_message(
             _id=1,
             name="n1",
             model="host"
@@ -47,7 +157,7 @@ class TestDistributed:
         cored.request_handler.handle_message(message)
 
         # create distributed node and assign to distributed server
-        message = conftest.node_message(
+        message = node_message(
             _id=2,
             name="n2",
             emulation_server=cored.distributed_server,
@@ -56,17 +166,16 @@ class TestDistributed:
         cored.request_handler.handle_message(message)
 
         # create distributed switch and assign to distributed server
-        message = conftest.node_message(
+        message = node_message(
             _id=3,
             name="n3",
-            emulation_server=cored.distributed_server,
             node_type=NodeTypes.SWITCH
         )
         cored.request_handler.handle_message(message)
 
         # link message one
         ip4_address = cored.prefix.addr(1)
-        message = conftest.link_message(
+        message = link_message(
             n1=1,
             n2=3,
             intf_one=0,
@@ -76,7 +185,7 @@ class TestDistributed:
 
         # link message two
         ip4_address = cored.prefix.addr(2)
-        message = conftest.link_message(
+        message = link_message(
             n1=3,
             n2=2,
             intf_two=0,
@@ -85,12 +194,86 @@ class TestDistributed:
         cored.request_handler.handle_message(message)
 
         # change session to instantiation state
-        message = conftest.state_message(EventTypes.INSTANTIATION_STATE)
+        message = state_message(EventTypes.INSTANTIATION_STATE)
         cored.request_handler.handle_message(message)
 
         # test a ping command
         node_one = cored.session.get_node(1)
-        message = conftest.command_message(node_one, "ping -c 5 %s" % ip4_address)
+        message = command_message(node_one, "ping -c 5 %s" % ip4_address)
+        cored.request_handler.dispatch_replies = validate_response
+        cored.request_handler.handle_message(message)
+
+    def test_emane(self, cored, distributed_address):
+        """
+        Test creating a distributed emane network.
+
+        :param core.api.tlv.coreserver.CoreServer conftest.Core cored: core daemon server to test with
+        :param str distributed_address: distributed server to test against
+        """
+        # initialize server for testing
+        cored.setup(distributed_address)
+
+        # configure required controlnet
+        cored.session.options.set_config("controlnet", "core1:172.16.1.0/24 core2:172.16.2.0/24")
+
+        # create local node
+        message = node_message(
+            _id=1,
+            name="n1",
+            model="mdr"
+        )
+        cored.request_handler.handle_message(message)
+
+        # create distributed node and assign to distributed server
+        message = node_message(
+            _id=2,
+            name="n2",
+            emulation_server=cored.distributed_server,
+            model="mdr"
+        )
+        cored.request_handler.handle_message(message)
+
+        # create distributed switch and assign to distributed server
+        message = node_message(
+            _id=3,
+            name="n3",
+            node_type=NodeTypes.EMANE
+        )
+        cored.request_handler.handle_message(message)
+
+        # set emane model
+        message = set_emane_model(3, EmaneIeee80211abgModel.name)
+        cored.request_handler.handle_message(message)
+
+        # link message one
+        ip4_address = cored.prefix.addr(1)
+        message = link_message(
+            n1=1,
+            n2=3,
+            intf_one=0,
+            address_one=ip4_address,
+            mask=32
+        )
+        cored.request_handler.handle_message(message)
+
+        # link message two
+        ip4_address = cored.prefix.addr(2)
+        message = link_message(
+            n1=2,
+            n2=3,
+            intf_one=0,
+            address_one=ip4_address,
+            mask=32
+        )
+        cored.request_handler.handle_message(message)
+
+        # change session to instantiation state
+        message = state_message(EventTypes.INSTANTIATION_STATE)
+        cored.request_handler.handle_message(message)
+
+        # test a ping command
+        node_one = cored.session.get_node(1)
+        message = command_message(node_one, "ping -c 5 %s" % ip4_address)
         cored.request_handler.dispatch_replies = validate_response
         cored.request_handler.handle_message(message)
 
@@ -98,14 +281,14 @@ class TestDistributed:
         """
         Test creating a distributed prouter node.
 
-        :param core.coreserver.CoreServer conftest.Core cored: core daemon server to test with
+        :param core.coreserver.CoreServer Core cored: core daemon server to test with
         :param str distributed_address: distributed server to test against
         """
         # initialize server for testing
         cored.setup(distributed_address)
 
         # create local node
-        message = conftest.node_message(
+        message = node_message(
             _id=1,
             name="n1",
             model="host"
@@ -113,7 +296,7 @@ class TestDistributed:
         cored.request_handler.handle_message(message)
 
         # create distributed node and assign to distributed server
-        message = conftest.node_message(
+        message = node_message(
             _id=2,
             name="n2",
             emulation_server=cored.distributed_server,
@@ -123,7 +306,7 @@ class TestDistributed:
         cored.request_handler.handle_message(message)
 
         # create distributed switch and assign to distributed server
-        message = conftest.node_message(
+        message = node_message(
             _id=3,
             name="n3",
             node_type=NodeTypes.SWITCH
@@ -132,7 +315,7 @@ class TestDistributed:
 
         # link message one
         ip4_address = cored.prefix.addr(1)
-        message = conftest.link_message(
+        message = link_message(
             n1=1,
             n2=3,
             intf_one=0,
@@ -142,7 +325,7 @@ class TestDistributed:
 
         # link message two
         ip4_address = cored.prefix.addr(2)
-        message = conftest.link_message(
+        message = link_message(
             n1=3,
             n2=2,
             intf_two=0,
@@ -151,12 +334,12 @@ class TestDistributed:
         cored.request_handler.handle_message(message)
 
         # change session to instantiation state
-        message = conftest.state_message(EventTypes.INSTANTIATION_STATE)
+        message = state_message(EventTypes.INSTANTIATION_STATE)
         cored.request_handler.handle_message(message)
 
         # test a ping command
         node_one = cored.session.get_node(1)
-        message = conftest.command_message(node_one, "ping -c 5 %s" % ip4_address)
+        message = command_message(node_one, "ping -c 5 %s" % ip4_address)
         cored.request_handler.dispatch_replies = validate_response
         cored.request_handler.handle_message(message)
         cored.request_handler.handle_message(message)
@@ -165,14 +348,14 @@ class TestDistributed:
         """
         Test session broker creation.
 
-        :param core.coreserver.CoreServer conftest.Core cored: core daemon server to test with
+        :param core.coreserver.CoreServer Core cored: core daemon server to test with
         :param str distributed_address: distributed server to test against
         """
         # initialize server for testing
         cored.setup(distributed_address)
 
         # create local node
-        message = conftest.node_message(
+        message = node_message(
             _id=1,
             name="n1",
             model="host"
@@ -180,7 +363,7 @@ class TestDistributed:
         cored.request_handler.handle_message(message)
 
         # create distributed node and assign to distributed server
-        message = conftest.node_message(
+        message = node_message(
             _id=2,
             name=distributed_address,
             emulation_server=cored.distributed_server,
@@ -191,7 +374,7 @@ class TestDistributed:
         # link message one
         ip4_address = cored.prefix.addr(1)
         address_two = IpAddress.from_string(distributed_address)
-        message = conftest.link_message(
+        message = link_message(
             n1=1,
             n2=2,
             intf_one=0,
@@ -203,5 +386,5 @@ class TestDistributed:
         cored.request_handler.handle_message(message)
 
         # change session to instantiation state
-        message = conftest.state_message(EventTypes.INSTANTIATION_STATE)
+        message = state_message(EventTypes.INSTANTIATION_STATE)
         cored.request_handler.handle_message(message)