updates to layout core module packages in a more logical way, including renaming methods from objects to nodes and nodes.objid to nodes.id

daemon/core/api/tlv/coreserver.py

@@ -0,0 +1,30 @@
+"""
+Defines core server for handling TCP connections.
+"""
+
+import SocketServer
+
+from core.emulator.coreemu import CoreEmu
+
+
+class CoreServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
+    """
+    TCP server class, manages sessions and spawns request handlers for
+    incoming connections.
+    """
+    daemon_threads = True
+    allow_reuse_address = True
+
+    def __init__(self, server_address, handler_class, config=None):
+        """
+        Server class initialization takes configuration data and calls
+        the SocketServer constructor
+
+        :param tuple[str, int] server_address: server host and port to use
+        :param class handler_class: request handler
+        :param dict config: configuration setting
+        :return:
+        """
+        self.coreemu = CoreEmu(config)
+        self.config = config
+        SocketServer.TCPServer.__init__(self, server_address, handler_class)

daemon/core/api/tlv/dataconversion.py

@@ -0,0 +1,64 @@
+"""
+Converts CORE data objects into legacy API messages.
+"""
+
+from core.api.tlv import coreapi, structutils
+from core.emulator.enumerations import ConfigTlvs
+from core.emulator.enumerations import NodeTlvs
+
+
+def convert_node(node_data):
+    """
+    Convenience method for converting NodeData to a packed TLV message.
+
+    :param core.data.NodeData node_data: node data to convert
+    :return: packed node message
+    """
+    tlv_data = structutils.pack_values(coreapi.CoreNodeTlv, [
+        (NodeTlvs.NUMBER, node_data.id),
+        (NodeTlvs.TYPE, node_data.node_type),
+        (NodeTlvs.NAME, node_data.name),
+        (NodeTlvs.IP_ADDRESS, node_data.ip_address),
+        (NodeTlvs.MAC_ADDRESS, node_data.mac_address),
+        (NodeTlvs.IP6_ADDRESS, node_data.ip6_address),
+        (NodeTlvs.MODEL, node_data.model),
+        (NodeTlvs.EMULATION_ID, node_data.emulation_id),
+        (NodeTlvs.EMULATION_SERVER, node_data.emulation_server),
+        (NodeTlvs.SESSION, node_data.session),
+        (NodeTlvs.X_POSITION, node_data.x_position),
+        (NodeTlvs.Y_POSITION, node_data.y_position),
+        (NodeTlvs.CANVAS, node_data.canvas),
+        (NodeTlvs.NETWORK_ID, node_data.network_id),
+        (NodeTlvs.SERVICES, node_data.services),
+        (NodeTlvs.LATITUDE, node_data.latitude),
+        (NodeTlvs.LONGITUDE, node_data.longitude),
+        (NodeTlvs.ALTITUDE, node_data.altitude),
+        (NodeTlvs.ICON, node_data.icon),
+        (NodeTlvs.OPAQUE, node_data.opaque)
+    ])
+    return coreapi.CoreNodeMessage.pack(node_data.message_type, tlv_data)
+
+
+def convert_config(config_data):
+    """
+    Convenience method for converting ConfigData to a packed TLV message.
+
+    :param core.data.ConfigData config_data: config data to convert
+    :return: packed message
+    """
+    tlv_data = structutils.pack_values(coreapi.CoreConfigTlv, [
+        (ConfigTlvs.NODE, config_data.node),
+        (ConfigTlvs.OBJECT, config_data.object),
+        (ConfigTlvs.TYPE, config_data.type),
+        (ConfigTlvs.DATA_TYPES, config_data.data_types),
+        (ConfigTlvs.VALUES, config_data.data_values),
+        (ConfigTlvs.CAPTIONS, config_data.captions),
+        (ConfigTlvs.BITMAP, config_data.bitmap),
+        (ConfigTlvs.POSSIBLE_VALUES, config_data.possible_values),
+        (ConfigTlvs.GROUPS, config_data.groups),
+        (ConfigTlvs.SESSION, config_data.session),
+        (ConfigTlvs.INTERFACE_NUMBER, config_data.interface_number),
+        (ConfigTlvs.NETWORK_ID, config_data.network_id),
+        (ConfigTlvs.OPAQUE, config_data.opaque),
+    ])
+    return coreapi.CoreConfMessage.pack(config_data.message_type, tlv_data)

daemon/core/api/tlv/structutils.py

@@ -0,0 +1,46 @@
+"""
+Utilities for working with python struct data.
+"""
+
+import logging
+
+
+def pack_values(clazz, packers):
+    """
+    Pack values for a given legacy class.
+
+    :param class clazz: class that will provide a pack method
+    :param list packers: a list of tuples that are used to pack values and transform them
+    :return: packed data string of all values
+    """
+
+    # iterate through tuples of values to pack
+    data = ""
+    for packer in packers:
+        # check if a transformer was provided for valid values
+        transformer = None
+        if len(packer) == 2:
+            tlv_type, value = packer
+        elif len(packer) == 3:
+            tlv_type, value, transformer = packer
+        else:
+            raise RuntimeError("packer had more than 3 arguments")
+
+        # convert unicode to normal str for packing
+        if isinstance(value, unicode):
+            value = str(value)
+
+        # only pack actual values and avoid packing empty strings
+        # protobuf defaults to empty strings and does no imply a value to set
+        if value is None or (isinstance(value, str) and not value):
+            continue
+
+        # transform values as needed
+        if transformer:
+            value = transformer(value)
+
+        # pack and add to existing data
+        logging.debug("packing: %s - %s", tlv_type, value)
+        data += clazz.pack(tlv_type.value, value)
+
+    return data