import logging import os from tempfile import NamedTemporaryFile from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple from lxml import etree from core import utils from core.config import Configuration from core.emane.nodes import EmaneNet from core.emulator.distributed import DistributedServer from core.nodes.interface import CoreInterface from core.nodes.network import CtrlNet from core.xml import corexml if TYPE_CHECKING: from core.emane.emanemanager import EmaneManager from core.emane.emanemodel import EmaneModel _hwaddr_prefix = "02:02" def is_external(config: Dict[str, str]) -> bool: """ Checks if the configuration is for an external transport. :param config: configuration to check :return: True if external, False otherwise """ return config.get("external") == "1" def _value_to_params(value: str) -> Optional[Tuple[str]]: """ Helper to convert a parameter to a parameter tuple. :param value: value string to convert to tuple :return: parameter tuple, None otherwise """ try: values = utils.make_tuple_fromstr(value, str) if not hasattr(values, "__iter__"): return None if len(values) < 2: return None return values except SyntaxError: logging.exception("error in value string to param list") return None def create_file( xml_element: etree.Element, doc_name: str, file_path: str, server: DistributedServer = None, ) -> None: """ Create xml file. :param xml_element: root element to write to file :param doc_name: name to use in the emane doctype :param file_path: file path to write xml file to :param server: remote server node will run on, default is None for localhost :return: nothing """ doctype = ( f'' ) if server is not None: temp = NamedTemporaryFile(delete=False) create_file(xml_element, doc_name, temp.name) temp.close() server.remote_put(temp.name, file_path) os.unlink(temp.name) else: corexml.write_xml_file(xml_element, file_path, doctype=doctype) def add_param(xml_element: etree.Element, name: str, value: str) -> None: """ Add emane configuration parameter to xml element. :param xml_element: element to append parameter to :param name: name of parameter :param value: value for parameter :return: nothing """ etree.SubElement(xml_element, "param", name=name, value=value) def add_configurations( xml_element: etree.Element, configurations: List[Configuration], config: Dict[str, str], config_ignore: Set, ) -> None: """ Add emane model configurations to xml element. :param xml_element: xml element to add emane configurations to :param configurations: configurations to add to xml :param config: configuration values :param config_ignore: configuration options to ignore :return: """ for configuration in configurations: # ignore custom configurations name = configuration.id if name in config_ignore: continue # check if value is a multi param value = str(config[name]) params = _value_to_params(value) if params: params_element = etree.SubElement(xml_element, "paramlist", name=name) for param in params: etree.SubElement(params_element, "item", value=param) else: add_param(xml_element, name, value) def build_node_platform_xml( emane_manager: "EmaneManager", control_net: CtrlNet, node: EmaneNet, nem_id: int, platform_xmls: Dict[str, etree.Element], ) -> int: """ Create platform xml for a specific node. :param emane_manager: emane manager with emane configurations :param control_net: control net node for this emane network :param node: node to write platform xml for :param nem_id: nem id to use for interfaces for this node :param platform_xmls: stores platform xml elements to append nem entries to :return: the next nem id that can be used for creating platform xml files """ logging.debug( "building emane platform xml for node(%s) nem_id(%s): %s", node, nem_id, node.name, ) nem_entries = {} if node.model is None: logging.warning("warning: EMANE network %s has no associated model", node.name) return nem_id for netif in node.netifs(): logging.debug( "building platform xml for interface(%s) nem_id(%s)", netif.name, nem_id ) # build nem xml nem_definition = nem_file_name(node.model, netif) nem_element = etree.Element( "nem", id=str(nem_id), name=netif.localname, definition=nem_definition ) # check if this is an external transport, get default config if an interface # specific one does not exist config = emane_manager.getifcconfig(node.model.id, netif, node.model.name) if is_external(config): nem_element.set("transport", "external") platform_endpoint = "platformendpoint" add_param(nem_element, platform_endpoint, config[platform_endpoint]) transport_endpoint = "transportendpoint" add_param(nem_element, transport_endpoint, config[transport_endpoint]) else: # build transport xml transport_type = netif.transport_type if not transport_type: logging.info("warning: %s interface type unsupported!", netif.name) transport_type = "raw" transport_file = transport_file_name(node.id, transport_type) transport_element = etree.SubElement( nem_element, "transport", definition=transport_file ) # add transport parameter add_param(transport_element, "device", netif.name) # add nem entry nem_entries[netif] = nem_element # merging code key = netif.node.id if netif.transport_type == "raw": key = "host" otadev = control_net.brname eventdev = control_net.brname else: otadev = None eventdev = None platform_element = platform_xmls.get(key) if platform_element is None: platform_element = etree.Element("platform") if otadev: emane_manager.set_config("otamanagerdevice", otadev) if eventdev: emane_manager.set_config("eventservicedevice", eventdev) # append all platform options (except starting id) to doc for configuration in emane_manager.emane_config.emulator_config: name = configuration.id if name == "platform_id_start": continue value = emane_manager.get_config(name) add_param(platform_element, name, value) # add platform xml platform_xmls[key] = platform_element platform_element.append(nem_element) node.setnemid(netif, nem_id) macstr = _hwaddr_prefix + ":00:00:" macstr += f"{(nem_id >> 8) & 0xFF:02X}:{nem_id & 0xFF:02X}" netif.sethwaddr(macstr) # increment nem id nem_id += 1 doc_name = "platform" for key in sorted(platform_xmls.keys()): platform_element = platform_xmls[key] if key == "host": file_name = "platform.xml" file_path = os.path.join(emane_manager.session.session_dir, file_name) create_file(platform_element, doc_name, file_path) else: file_name = f"platform{key}.xml" file_path = os.path.join(emane_manager.session.session_dir, file_name) linked_node = emane_manager.session.nodes[key] create_file(platform_element, doc_name, file_path, linked_node.server) return nem_id def build_xml_files(emane_manager: "EmaneManager", node: EmaneNet) -> None: """ Generate emane xml files required for node. :param emane_manager: emane manager with emane configurations :param node: node to write platform xml for :return: nothing """ logging.debug("building all emane xml for node(%s): %s", node, node.name) if node.model is None: return # get model configurations config = emane_manager.get_configs(node.model.id, node.model.name) if not config: return # build XML for overall network EMANE configs node.model.build_xml_files(config) # build XML for specific interface (NEM) configs need_virtual = False need_raw = False vtype = "virtual" rtype = "raw" for netif in node.netifs(): # check for interface specific emane configuration and write xml files config = emane_manager.getifcconfig(node.model.id, netif, node.model.name) if config: node.model.build_xml_files(config, netif) # check transport type needed for interface if "virtual" in netif.transport_type: need_virtual = True vtype = netif.transport_type else: need_raw = True rtype = netif.transport_type if need_virtual: build_transport_xml(emane_manager, node, vtype) if need_raw: build_transport_xml(emane_manager, node, rtype) def build_transport_xml( emane_manager: "EmaneManager", node: EmaneNet, transport_type: str ) -> None: """ Build transport xml file for node and transport type. :param emane_manager: emane manager with emane configurations :param node: node to write platform xml for :param transport_type: transport type to build xml for :return: nothing """ transport_element = etree.Element( "transport", name=f"{transport_type.capitalize()} Transport", library=f"trans{transport_type.lower()}", ) # add bitrate add_param(transport_element, "bitrate", "0") # get emane model cnfiguration config = emane_manager.get_configs(node.id, node.model.name) flowcontrol = config.get("flowcontrolenable", "0") == "1" if "virtual" in transport_type.lower(): device_path = "/dev/net/tun_flowctl" if not os.path.exists(device_path): device_path = "/dev/net/tun" add_param(transport_element, "devicepath", device_path) if flowcontrol: add_param(transport_element, "flowcontrolenable", "on") doc_name = "transport" file_name = transport_file_name(node.id, transport_type) file_path = os.path.join(emane_manager.session.session_dir, file_name) create_file(transport_element, doc_name, file_path) emane_manager.session.distributed.execute( lambda x: create_file(transport_element, doc_name, file_path, x) ) def create_phy_xml( emane_model: "EmaneModel", config: Dict[str, str], file_path: str, server: DistributedServer, ) -> None: """ Create the phy xml document. :param emane_model: emane model to create xml :param config: all current configuration values :param file_path: path to write file to :param server: remote server node will run on, default is None for localhost :return: nothing """ phy_element = etree.Element("phy", name=f"{emane_model.name} PHY") if emane_model.phy_library: phy_element.set("library", emane_model.phy_library) add_configurations( phy_element, emane_model.phy_config, config, emane_model.config_ignore ) create_file(phy_element, "phy", file_path) if server is not None: create_file(phy_element, "phy", file_path, server) else: create_file(phy_element, "phy", file_path) emane_model.session.distributed.execute( lambda x: create_file(phy_element, "phy", file_path, x) ) def create_mac_xml( emane_model: "EmaneModel", config: Dict[str, str], file_path: str, server: DistributedServer, ) -> None: """ Create the mac xml document. :param emane_model: emane model to create xml :param config: all current configuration values :param file_path: path to write file to :param server: remote server node will run on, default is None for localhost :return: nothing """ if not emane_model.mac_library: raise ValueError("must define emane model library") mac_element = etree.Element( "mac", name=f"{emane_model.name} MAC", library=emane_model.mac_library ) add_configurations( mac_element, emane_model.mac_config, config, emane_model.config_ignore ) create_file(mac_element, "mac", file_path) if server is not None: create_file(mac_element, "mac", file_path, server) else: create_file(mac_element, "mac", file_path) emane_model.session.distributed.execute( lambda x: create_file(mac_element, "mac", file_path, x) ) def create_nem_xml( emane_model: "EmaneModel", config: Dict[str, str], nem_file: str, transport_definition: str, mac_definition: str, phy_definition: str, server: DistributedServer, ) -> None: """ Create the nem xml document. :param emane_model: emane model to create xml :param config: all current configuration values :param nem_file: nem file path to write :param transport_definition: transport file definition path :param mac_definition: mac file definition path :param phy_definition: phy file definition path :param server: remote server node will run on, default is None for localhost :return: nothing """ nem_element = etree.Element("nem", name=f"{emane_model.name} NEM") if is_external(config): nem_element.set("type", "unstructured") else: etree.SubElement(nem_element, "transport", definition=transport_definition) etree.SubElement(nem_element, "mac", definition=mac_definition) etree.SubElement(nem_element, "phy", definition=phy_definition) if server is not None: create_file(nem_element, "nem", nem_file, server) else: create_file(nem_element, "nem", nem_file) emane_model.session.distributed.execute( lambda x: create_file(nem_element, "nem", nem_file, x) ) def create_event_service_xml( group: str, port: str, device: str, file_directory: str, server: DistributedServer = None, ) -> None: """ Create a emane event service xml file. :param group: event group :param port: event port :param device: event device :param file_directory: directory to create file in :param server: remote server node will run on, default is None for localhost :return: nothing """ event_element = etree.Element("emaneeventmsgsvc") for name, value in ( ("group", group), ("port", port), ("device", device), ("mcloop", "1"), ("ttl", "32"), ): sub_element = etree.SubElement(event_element, name) sub_element.text = value file_name = "libemaneeventservice.xml" file_path = os.path.join(file_directory, file_name) create_file(event_element, "emaneeventmsgsvc", file_path, server) def transport_file_name(node_id: int, transport_type: str) -> str: """ Create name for a transport xml file. :param node_id: node id to generate transport file name for :param transport_type: transport type to generate transport file :return: """ return f"n{node_id}trans{transport_type}.xml" def _basename(emane_model: "EmaneModel", interface: CoreInterface = None) -> str: """ Create name that is leveraged for configuration file creation. :param emane_model: emane model to create name for :param interface: interface for this model :return: basename used for file creation """ name = f"n{emane_model.id}" if interface: node_id = interface.node.id if emane_model.session.emane.getifcconfig(node_id, interface, emane_model.name): name = interface.localname.replace(".", "_") return f"{name}{emane_model.name}" def nem_file_name(emane_model: "EmaneModel", interface: CoreInterface = None) -> str: """ Return the string name for the NEM XML file, e.g. "n3rfpipenem.xml" :param emane_model: emane model to create file :param interface: interface for this model :return: nem xml filename """ basename = _basename(emane_model, interface) append = "" if interface and interface.transport_type == "raw": append = "_raw" return f"{basename}nem{append}.xml" def shim_file_name(emane_model: "EmaneModel", interface: CoreInterface = None) -> str: """ Return the string name for the SHIM XML file, e.g. "commeffectshim.xml" :param emane_model: emane model to create file :param interface: interface for this model :return: shim xml filename """ name = _basename(emane_model, interface) return f"{name}shim.xml" def mac_file_name(emane_model: "EmaneModel", interface: CoreInterface = None) -> str: """ Return the string name for the MAC XML file, e.g. "n3rfpipemac.xml" :param emane_model: emane model to create file :param interface: interface for this model :return: mac xml filename """ name = _basename(emane_model, interface) return f"{name}mac.xml" def phy_file_name(emane_model: "EmaneModel", interface: CoreInterface = None) -> str: """ Return the string name for the PHY XML file, e.g. "n3rfpipephy.xml" :param emane_model: emane model to create file :param interface: interface for this model :return: phy xml filename """ name = _basename(emane_model, interface) return f"{name}phy.xml"