initial code to leverage lxml to create xml for saving and loading core sessions

daemon/core/conf.py

@@ -269,7 +269,6 @@ class ConfigurableOptions(object):
     name = None
     bitmap = None
     options = []
-    _default_node = -1
 
     @classmethod
     def configurations(cls):
@@ -380,9 +379,11 @@ class ModelManager(ConfigurableManager):
             all_configs = self.get_all_configs(node_id=node.objid)
 
         for model_name in all_configs.iterkeys():
+            if model_name == ModelManager._default_node:
+                continue
             model_class = self.models[model_name]
             config = self.get_configs(node_id=node.objid, config_type=model_name)
             models.append((model_class, config))
 
-        logger.debug("mobility models for node(%s): %s", node.objid, models)
+        logger.debug("models for node(%s): %s", node.objid, models)
         return models

daemon/core/corehandlers.py

@@ -1284,7 +1284,7 @@ class CoreHandler(SocketServer.BaseRequestHandler):
 
             if values_str:
                 config = ConfigShim.str_to_dict(values_str)
-                self.session.emane.set_configs(config)
+                self.session.emane.set_configs(config, node_id=node_id)
 
         # extra logic to start slave Emane object after nemid has been configured from the master
         if message_type == ConfigFlags.UPDATE and self.session.master is False:

daemon/core/emane/emanemanager.py

@@ -11,6 +11,7 @@ from core import constants
 from core import logger
 from core.api import coreapi
 from core.api import dataconversion
+from core.conf import ConfigGroup
 from core.conf import ConfigShim
 from core.conf import Configuration
 from core.conf import ModelManager
@@ -1016,8 +1017,12 @@ class EmaneGlobalModel(EmaneModel):
 
     @classmethod
     def config_groups(cls):
-        return "Platform Attributes:1-%d|NEM Parameters:%d-%d" % (
+        emulator_len = len(cls.emulator_config)
-            len(cls.emulator_config), len(cls.emulator_config) + 1, len(cls.configurations()))
+        config_len = len(cls.configurations())
+        return [
+            ConfigGroup("Platform Attributes", 1, emulator_len),
+            ConfigGroup("NEM Parameters", emulator_len + 1, config_len)
+        ]
 
     def __init__(self, session, object_id=None):
         super(EmaneGlobalModel, self).__init__(session, object_id)

daemon/core/emane/emanemanifest.py

@@ -34,7 +34,7 @@ def _get_possible(config_type, config_regex):
     :param str config_type: emane configuration type
     :param str config_regex: emane configuration regex
     :return: a string listing comma delimited values, if needed, empty string otherwise
-    :rtype: str
+    :rtype: list
     """
     if config_type == "bool":
         return ["On", "Off"]

daemon/core/mobility.py

@@ -73,7 +73,8 @@ class MobilityManager(ModelManager):
                 continue
 
             for model_name in self.models.iterkeys():
-                config = self.get_configs(node_id=node_id, config_type=model_name)
+                all_configs = self.get_all_configs(node_id)
+                config = all_configs.get(model_name)
                 if not config:
                     continue
                 model_class = self.models[model_name]

daemon/core/service.py

@@ -339,7 +339,7 @@ class CoreServices(object):
         :param str service_name: name of service to set
         :return: nothing
         """
-        logger.debug("setting custom service(%s) for node: %s", node_id, service_name)
+        logger.debug("setting custom service(%s) for node: %s", service_name, node_id)
         service = self.get_service(node_id, service_name)
         if not service:
             service_class = ServiceManager.get(service_name)

daemon/core/xml/corexml.py

@@ -0,0 +1,579 @@
+from lxml import etree
+
+from core import coreobj
+from core.enumerations import NodeTypes
+from core.misc import ipaddress
+from core.misc import nodeutils
+from core.netns import nodes
+
+
+def add_attribute(element, name, value):
+    if value is not None:
+        element.set(name, str(value))
+
+
+def create_emane_config(node_id, emane_config, config):
+    emane_configuration = etree.Element("emane_configuration")
+    add_attribute(emane_configuration, "node", node_id)
+    add_attribute(emane_configuration, "model", "emane")
+    emulator_element = etree.SubElement(emane_configuration, "emulator")
+    for emulator_config in emane_config.emulator_config:
+        config_element = etree.SubElement(emulator_element, "configuration")
+        value = config[emulator_config.id]
+        add_attribute(config_element, "name", emulator_config.id)
+        add_attribute(config_element, "value", value)
+
+    nem_element = etree.SubElement(emane_configuration, "nem")
+    for nem_config in emane_config.nem_config:
+        config_element = etree.SubElement(nem_element, "configuration")
+        value = config[nem_config.id]
+        add_attribute(config_element, "name", nem_config.id)
+        add_attribute(config_element, "value", value)
+
+    return emane_configuration
+
+
+def create_emane_model_config(node_id, model, config):
+    emane_element = etree.Element("emane_configuration")
+    add_attribute(emane_element, "node", node_id)
+    add_attribute(emane_element, "model", model.name)
+
+    mac_element = etree.SubElement(emane_element, "mac")
+    for mac_config in model.mac_config:
+        config_element = etree.SubElement(mac_element, "configuration")
+        value = config[mac_config.id]
+        add_attribute(config_element, "name", mac_config.id)
+        add_attribute(config_element, "value", value)
+
+    phy_element = etree.SubElement(emane_element, "phy")
+    for phy_config in model.phy_config:
+        config_element = etree.SubElement(phy_element, "configuration")
+        value = config[phy_config.id]
+        add_attribute(config_element, "name", phy_config.id)
+        add_attribute(config_element, "value", value)
+
+    return emane_element
+
+
+def get_endpoints(node):
+    endpoints = []
+    for interface in node.netifs(sort=True):
+        endpoint = get_endpoint(node, interface)
+        endpoints.append(endpoint)
+    return endpoints
+
+
+def get_endpoint(node, interface):
+    l2devport = None
+    othernet = getattr(interface, "othernet", None)
+
+    # reference interface of node that is part of this network
+    if interface.net.objid == node.objid and interface.node:
+        params = interface.getparams()
+        if nodeutils.is_node(interface.net, (NodeTypes.HUB, NodeTypes.SWITCH)):
+            l2devport = "%s/e%s" % (interface.net.name, interface.netindex)
+        endpoint_id = "%s/%s" % (interface.node.name, interface.name)
+        endpoint = Endpoint(
+            node,
+            interface,
+            "interface",
+            endpoint_id,
+            l2devport,
+            params
+        )
+    # references another node connected to this network
+    elif othernet and othernet.objid == node.objid:
+        interface.swapparams("_params_up")
+        params = interface.getparams()
+        interface.swapparams("_params_up")
+        l2devport = "%s/e%s" % (othernet.name, interface.netindex)
+        endpoint_id = "%s/%s/%s" % (node.name, interface.node.name, interface.netindex)
+        endpoint = Endpoint(
+            interface.net,
+            interface,
+            "interface",
+            endpoint_id,
+            l2devport,
+            params
+        )
+    else:
+        endpoint = Endpoint(
+            node,
+            interface,
+        )
+
+    return endpoint
+
+
+def get_downstream_l2_devices(node):
+    all_endpoints = []
+    l2_devices = [node]
+    current_endpoint = get_endpoints(node)
+    all_endpoints.extend(current_endpoint)
+    for endpoint in current_endpoint:
+        if endpoint.type and endpoint.network.objid != node.objid:
+            new_l2_devices, new_endpoints = get_downstream_l2_devices(endpoint.network)
+            l2_devices.extend(new_l2_devices)
+            all_endpoints.extend(new_endpoints)
+    return l2_devices, all_endpoints
+
+
+def create_link_element(link_data):
+    link_element = etree.Element("link")
+    add_attribute(link_element, "node_one", link_data.node1_id)
+    add_attribute(link_element, "node_two", link_data.node2_id)
+
+    # check for interface one
+    interface_one = etree.Element("interface_one")
+    add_attribute(interface_one, "id", link_data.interface1_id)
+    add_attribute(interface_one, "name", link_data.interface1_name)
+    add_attribute(interface_one, "mac", link_data.interface1_mac)
+    add_attribute(interface_one, "ip4", link_data.interface1_ip4)
+    add_attribute(interface_one, "ip4_mask", link_data.interface1_ip4_mask)
+    add_attribute(interface_one, "ip6", link_data.interface1_ip6)
+    add_attribute(interface_one, "ip6_mask", link_data.interface1_ip6_mask)
+    if interface_one.items():
+        link_element.append(interface_one)
+
+    # check for interface two
+    interface_two = etree.Element("interface_two")
+    add_attribute(interface_two, "id", link_data.interface2_id)
+    add_attribute(interface_two, "name", link_data.interface2_name)
+    add_attribute(interface_two, "mac", link_data.interface2_mac)
+    add_attribute(interface_two, "ip4", link_data.interface2_ip4)
+    add_attribute(interface_two, "ip4_mask", link_data.interface2_ip4_mask)
+    add_attribute(interface_two, "ip6", link_data.interface2_ip6)
+    add_attribute(interface_two, "ip6_mask", link_data.interface2_ip6_mask)
+    if interface_two.items():
+        link_element.append(interface_two)
+
+    # check for options
+    options = etree.Element("options")
+    add_attribute(options, "delay", link_data.delay)
+    add_attribute(options, "bandwidth", link_data.bandwidth)
+    add_attribute(options, "per", link_data.per)
+    add_attribute(options, "dup", link_data.dup)
+    add_attribute(options, "jitter", link_data.jitter)
+    add_attribute(options, "mer", link_data.mer)
+    add_attribute(options, "burst", link_data.burst)
+    add_attribute(options, "mburst", link_data.mburst)
+    add_attribute(options, "type", link_data.link_type)
+    add_attribute(options, "gui_attributes", link_data.gui_attributes)
+    add_attribute(options, "unidirectional", link_data.unidirectional)
+    add_attribute(options, "emulation_id", link_data.emulation_id)
+    add_attribute(options, "network_id", link_data.network_id)
+    add_attribute(options, "key", link_data.key)
+    add_attribute(options, "opaque", link_data.opaque)
+    if options.items():
+        link_element.append(options)
+
+    return link_element
+
+
+class Endpoint(object):
+    def __init__(self, network, interface, _type=None, _id=None, l2devport=None, params=None):
+        self.network = network
+        self.interface = interface
+        self.type = _type
+        self.id = _id
+        self.l2devport = l2devport
+        self.params = params
+
+
+class NodeElement(object):
+    def __init__(self, session, node, element_name):
+        self.session = session
+        self.node = node
+        self.element = etree.Element(element_name)
+        add_attribute(self.element, "id", node.objid)
+        add_attribute(self.element, "name", node.name)
+        add_attribute(self.element, "icon", node.icon)
+        add_attribute(self.element, "canvas", node.canvas)
+        self.add_position()
+
+    def add_position(self):
+        x = self.node.position.x
+        y = self.node.position.y
+        z = self.node.position.z
+        lat, lon, alt = None, None, None
+        if x is not None and y is not None:
+            lat, lon, alt = self.session.location.getgeo(x, y, z)
+        position = etree.SubElement(self.element, "position")
+        add_attribute(position, "x", x)
+        add_attribute(position, "y", y)
+        add_attribute(position, "z", z)
+        add_attribute(position, "lat", lat)
+        add_attribute(position, "lon", lon)
+        add_attribute(position, "alt", alt)
+
+
+class InterfaceElement(object):
+    def __init__(self, session, node, interface):
+        self.session = session
+        self.node = node
+        self.interface = interface
+        self.element = etree.Element("interface")
+        add_attribute(self.element, "id", interface.netindex)
+        add_attribute(self.element, "name", interface.name)
+        mac = etree.SubElement(self.element, "mac")
+        mac.text = str(interface.hwaddr)
+        self.add_mtu()
+        self.addresses = etree.SubElement(self.element, "addresses")
+        self.add_addresses()
+        self.add_model()
+
+    def add_mtu(self):
+        # check to add mtu
+        if self.interface.mtu and self.interface.mtu != 1500:
+            add_attribute(self.element, "mtu", self.interface.mtu)
+
+    def add_model(self):
+        # check for emane specific interface configuration
+        net_model = None
+        if self.interface.net and hasattr(self.interface.net, "model"):
+            net_model = self.interface.net.model
+
+        if net_model and net_model.name.startswith("emane_"):
+            config = self.session.emane.getifcconfig(self.node.objid, self.interface, net_model.name)
+            if config:
+                emane_element = create_emane_model_config(net_model, config)
+                self.element.append(emane_element)
+
+    def add_addresses(self):
+        for address in self.interface.addrlist:
+            ip, mask = address.split("/")
+            if ipaddress.is_ipv4_address(ip):
+                address_type = "IPv4"
+            else:
+                address_type = "IPv6"
+            address_element = etree.SubElement(self.addresses, "address")
+            add_attribute(address_element, "type", address_type)
+            address_element.text = str(address)
+
+
+class ServiceElement(object):
+    def __init__(self, service):
+        self.service = service
+        self.element = etree.Element("service")
+        add_attribute(self.element, "name", service.name)
+        self.add_directories()
+        self.add_startup()
+        self.add_validate()
+        self.add_shutdown()
+        self.add_files()
+
+    def add_directories(self):
+        # get custom directories
+        directories = etree.Element("directories")
+        for directory in self.service.dirs:
+            directory_element = etree.SubElement(directories, "directory")
+            directory_element.text = directory
+
+        if directories.getchildren():
+            self.element.append(directories)
+
+    def add_files(self):
+        # get custom files
+        file_elements = etree.Element("files")
+        for file_name, data in self.service.config_data.iteritems():
+            file_element = etree.SubElement(file_elements, "file")
+            add_attribute(file_element, "name", file_name)
+            file_element.text = data
+
+        if file_elements.getchildren():
+            self.element.append(file_elements)
+
+    def add_startup(self):
+        # get custom startup
+        startup_elements = etree.Element("startups")
+        for startup in self.service.startup:
+            startup_element = etree.SubElement(startup_elements, "startup")
+            startup_element.text = startup
+
+        if startup_elements.getchildren():
+            self.element.append(startup_elements)
+
+    def add_validate(self):
+        # get custom validate
+        validate_elements = etree.Element("validates")
+        for validate in self.service.validate:
+            validate_element = etree.SubElement(validate_elements, "validate")
+            validate_element.text = validate
+
+        if validate_elements.getchildren():
+            self.element.append(validate_elements)
+
+    def add_shutdown(self):
+        # get custom shutdown
+        shutdown_elements = etree.Element("shutdowns")
+        for shutdown in self.service.shutdown:
+            shutdown_element = etree.SubElement(shutdown_elements, "shutdown")
+            shutdown_element.text = shutdown
+
+        if shutdown_elements.getchildren():
+            self.element.append(shutdown_elements)
+
+
+class DeviceElement(NodeElement):
+    def __init__(self, session, node):
+        super(DeviceElement, self).__init__(session, node, "device")
+        add_attribute(self.element, "type", node.type)
+        # self.add_interfaces()
+        self.add_services()
+
+    def add_services(self):
+        service_elements = etree.Element("services")
+        for service in self.node.services:
+            etree.SubElement(service_elements, "service", name=service.name)
+
+        if service_elements.getchildren():
+            self.element.append(service_elements)
+
+    def add_interfaces(self):
+        interfaces = etree.Element("interfaces")
+        for interface in self.node.netifs(sort=True):
+            interface_element = InterfaceElement(self.session, self.node, interface)
+            interfaces.append(interface_element.element)
+
+        if interfaces.getchildren():
+            self.element.append(interfaces)
+
+
+class NetworkElement(NodeElement):
+    def __init__(self, session, node):
+        super(NetworkElement, self).__init__(session, node, "network")
+        model = getattr(self.node, "model", None)
+        if model:
+            add_attribute(self.element, "model", model.name)
+        mobility = getattr(self.node, "mobility", None)
+        if mobility:
+            add_attribute(self.element, "mobility", mobility.name)
+        grekey = getattr(self.node, "grekey", None)
+        if grekey and grekey is not None:
+            add_attribute(self.element, "grekey", grekey)
+        self.add_type()
+        # self.endpoints = get_endpoints(self.node)
+        # self.l2_devices = self.get_l2_devices()
+        # self.add_configs()
+
+    def add_type(self):
+        if self.node.apitype:
+            node_type = NodeTypes(self.node.apitype).name
+        else:
+            node_type = self.node.__class__.__name__
+        add_attribute(self.element, "type", node_type)
+
+    def get_l2_devices(self):
+        l2_devices = []
+        found_l2_devices = []
+        found_endpoints = []
+        if nodeutils.is_node(self.node, (NodeTypes.SWITCH, NodeTypes.HUB)):
+            for endpoint in self.endpoints:
+                if endpoint.type and endpoint.network.objid != self.node.objid:
+                    downstream_l2_devices, downstream_endpoints = get_downstream_l2_devices(endpoint.network)
+                    found_l2_devices.extend(downstream_l2_devices)
+                    found_endpoints.extend(downstream_endpoints)
+
+            for l2_device in found_l2_devices:
+                pass
+
+            self.endpoints.extend(found_endpoints)
+        return l2_devices
+
+    def add_peer_to_peer_config(self):
+        pass
+
+    def add_switch_hub_tunnel_config(self):
+        pass
+
+    def add_configs(self):
+        if nodeutils.is_node(self.node, NodeTypes.PEER_TO_PEER):
+            self.add_peer_to_peer_config()
+        elif nodeutils.is_node(self.node, (NodeTypes.SWITCH, NodeTypes.HUB, NodeTypes.TUNNEL)):
+            self.add_switch_hub_tunnel_config()
+
+
+class CoreXmlWriter(object):
+    def __init__(self, session):
+        self.session = session
+        self.scenario = None
+        self.networks = None
+        self.devices = None
+
+    def write(self, file_name):
+        self.scenario = etree.Element("scenario", name=file_name)
+        self.networks = etree.SubElement(self.scenario, "networks")
+        self.devices = etree.SubElement(self.scenario, "devices")
+        links = self.write_nodes()
+        self.write_links(links)
+        self.write_mobility_configs()
+        self.write_emane_configs()
+        self.write_service_configs()
+        self.write_session_origin()
+        self.write_session_hooks()
+        self.write_session_options()
+        self.write_session_metadata()
+        self.write_default_services()
+
+        with open(file_name, "w") as xml_file:
+            data = etree.tostring(self.scenario, xml_declaration=True, pretty_print=True, encoding="UTF-8")
+            xml_file.write(data)
+
+    def write_session_origin(self):
+        # origin: geolocation of cartesian coordinate 0,0,0
+        lat, lon, alt = self.session.location.refgeo
+        origin = etree.Element("session_origin")
+        add_attribute(origin, "lat", lat)
+        add_attribute(origin, "lon", lon)
+        add_attribute(origin, "alt", alt)
+        has_origin = len(origin.items()) > 0
+
+        if has_origin:
+            self.scenario.append(origin)
+            refscale = self.session.location.refscale
+            if refscale != 1.0:
+                add_attribute(origin, "scale", refscale)
+            if self.session.location.refxyz != (0.0, 0.0, 0.0):
+                x, y, z = self.session.location.refxyz
+                add_attribute(origin, "x", x)
+                add_attribute(origin, "y", y)
+                add_attribute(origin, "z", z)
+
+    def write_session_hooks(self):
+        # hook scripts
+        hooks = etree.Element("session_hooks")
+        for state in sorted(self.session._hooks.keys()):
+            for file_name, data in self.session._hooks[state]:
+                hook = etree.SubElement(hooks, "hook")
+                add_attribute(hook, "name", file_name)
+                add_attribute(hook, "state", state)
+                hook.text = data
+
+        if hooks.getchildren():
+            self.scenario.append(hooks)
+
+    def write_session_options(self):
+        # options
+        options = etree.Element("session_options")
+        # TODO: should we just save the current config regardless, since it may change?
+        options_config = self.session.options.get_configs()
+        for _id, default_value in self.session.options.default_values().iteritems():
+            value = options_config[_id]
+            if value != default_value:
+                option = etree.SubElement(options, "option")
+                add_attribute(option, "name", _id)
+                add_attribute(option, "value", value)
+
+        if options.getchildren():
+            self.scenario.append(options)
+
+    def write_session_metadata(self):
+        # metadata
+        metadata = etree.Element("session_metadata")
+        for _id, value in self.session.metadata.get_configs().iteritems():
+            data = etree.SubElement(metadata, "data")
+            add_attribute(data, "name", _id)
+            add_attribute(data, "value", value)
+
+        if metadata.getchildren():
+            self.scenario.append(metadata)
+
+    def write_emane_configs(self):
+        emane_configurations = etree.Element("emane_configurations")
+        for node_id in self.session.emane.nodes():
+            all_configs = self.session.emane.get_all_configs(node_id)
+            for model_name, config in all_configs.iteritems():
+                if model_name == -1:
+                    emane_configuration = create_emane_config(node_id, self.session.emane_config, config)
+                else:
+                    model = self.session.emane.models[model_name]
+                    emane_configuration = create_emane_model_config(node_id, model, config)
+                emane_configurations.append(emane_configuration)
+
+        if emane_configurations.getchildren():
+            self.scenario.append(emane_configurations)
+
+    def write_mobility_configs(self):
+        mobility_configurations = etree.Element("mobility_configurations")
+        for node_id in self.session.mobility.nodes():
+            all_configs = self.session.emane.get_all_configs(node_id)
+            for model_name, config in all_configs.iteritems():
+                mobility_configuration = etree.SubElement(mobility_configurations, "mobility_configuration")
+                add_attribute(mobility_configuration, "node", node_id)
+                add_attribute(mobility_configuration, "model", model_name)
+                for name, value in config.iteritems():
+                    config_element = etree.SubElement(mobility_configuration, "configuration")
+                    add_attribute(config_element, "name", name)
+                    add_attribute(config_element, "value", value)
+
+        if mobility_configurations.getchildren():
+            self.scenario.append(mobility_configurations)
+
+    def write_service_configs(self):
+        service_configurations = etree.Element("service_configurations")
+        service_configs = self.session.services.all_configs()
+        for node_id, service in service_configs:
+            service_element = ServiceElement(service)
+            add_attribute(service_element.element, "node", node_id)
+            service_configurations.append(service_element.element)
+
+        if service_configurations.getchildren():
+            self.scenario.append(service_configurations)
+
+    def write_default_services(self):
+        node_types = etree.Element("default_services")
+        for node_type, services in self.session.services.default_services.iteritems():
+            node_type = etree.SubElement(node_types, "node", type=node_type)
+            for service in services:
+                etree.SubElement(node_type, "service", name=service)
+
+        if node_types.getchildren():
+            self.scenario.append(node_types)
+
+    def write_nodes(self):
+        links = []
+        for node in self.session.objects.itervalues():
+            # network node
+            if isinstance(node, coreobj.PyCoreNet) and not nodeutils.is_node(node, NodeTypes.CONTROL_NET):
+                self.write_network(node)
+            # device node
+            elif isinstance(node, nodes.PyCoreNode):
+                self.write_device(node)
+
+            # add known links
+            links.extend(node.all_link_data(0))
+
+        return links
+
+    def write_network(self, node):
+        # ignore p2p and other nodes that are not part of the api
+        if not node.apitype:
+            return
+
+        # ignore nodes tied to a different network
+        if nodeutils.is_node(node, (NodeTypes.SWITCH, NodeTypes.HUB)):
+            for netif in node.netifs(sort=True):
+                othernet = getattr(netif, "othernet", None)
+                if othernet and othernet.objid != node.objid:
+                    return
+
+        network = NetworkElement(self.session, node)
+        self.networks.append(network.element)
+
+    def write_links(self, links):
+        link_elements = etree.Element("links")
+        # add link data
+        for link_data in links:
+            # skip basic range links
+            if not link_data.interface1_id and not link_data.interface2_id:
+                continue
+
+            link_element = create_link_element(link_data)
+            link_elements.append(link_element)
+
+        if link_elements.getchildren():
+            self.scenario.append(link_elements)
+
+    def write_device(self, node):
+        device = DeviceElement(self.session, node)
+        self.devices.append(device.element)

daemon/core/xml/xmlsession.py

@@ -7,6 +7,7 @@ import os.path
 
 from core.enumerations import NodeTypes
 from core.misc import nodeutils
+from core.xml import corexml
 from core.xml.xmlparser import core_document_parser
 from core.xml.xmlwriter import core_document_writer
 
@@ -34,3 +35,4 @@ def save_session_xml(session, filename, version):
     """
     doc = core_document_writer(session, version)
     doc.writexml(filename)
+    corexml.CoreXmlWriter(session).write(filename + ".test")

daemon/data/logging.conf

@@ -14,7 +14,7 @@
 		}
 	},
 	"root": {
-		"level": "INFO",
+		"level": "DEBUG",
 		"handlers": ["console"]
 	}
 }