def __init__(self, session, _id=None, name=None, mtu=1500, start=True, server=None): """ Create an RJ45Node instance. :param core.emulator.session.Session session: core session instance :param int _id: node id :param str name: node name :param mtu: rj45 mtu :param bool start: start flag :param core.emulator.distributed.DistributedServer server: remote server node will run on, default is None for localhost """ CoreNodeBase.__init__(self, session, _id, name, start, server) CoreInterface.__init__(self, session, self, name, mtu, server) self.up = False self.lock = threading.RLock() self.ifindex = None # the following are PyCoreNetIf attributes self.transport_type = "raw" self.localname = name self.old_up = False self.old_addrs = [] if start: self.startup()
def __init__(self, session, _id=None, name=None, nodedir=None, start=True): CoreNodeBase.__init__(self, session, _id, name, start=start) self.nodedir = nodedir self.up = start self.lock = threading.RLock() self._mounts = [] if start: self.startup()
def get_router_id(node: CoreNodeBase) -> str: """ Helper to return the first IPv4 address of a node as its router ID. """ for iface in node.get_ifaces(control=False): ip4 = iface.get_ip4() if ip4: return str(ip4.ip) return "0.0.0.0"
def get_router_id(node: CoreNodeBase) -> str: """ Helper to return the first IPv4 address of a node as its router ID. """ for ifc in node.netifs(): if getattr(ifc, "control", False): continue for a in ifc.addrlist: a = a.split("/")[0] if netaddr.valid_ipv4(a): return a return "0.0.0.0"
def setposition(self, x: float = None, y: float = None, z: float = None) -> bool: """ Uses setposition from both parent classes. :param x: x position :param y: y position :param z: z position :return: True if position changed, False otherwise """ result = CoreNodeBase.setposition(self, x, y, z) CoreInterface.setposition(self, x, y, z) return result
def setposition(self, x=None, y=None, z=None): """ Uses setposition from both parent classes. :param float x: x position :param float y: y position :param float z: z position :return: True if position changed, False otherwise :rtype: bool """ result = CoreNodeBase.setposition(self, x, y, z) CoreInterface.setposition(self, x, y, z) return result
def __init__(self, session, _id=None, name=None, mtu=1500, start=True): """ Create an RJ45Node instance. :param core.emulator.session.Session session: core session instance :param int _id: node id :param str name: node name :param mtu: rj45 mtu :param bool start: start flag :return: """ CoreNodeBase.__init__(self, session, _id, name, start=start) CoreInterface.__init__(self, node=self, name=name, mtu=mtu) self.up = False self.lock = threading.RLock() self.ifindex = None # the following are PyCoreNetIf attributes self.transport_type = "raw" self.localname = name self.old_up = False self.old_addrs = [] if start: self.startup()
def physnodehandlelink(self, message): """ Broker handler. Snoop Link add messages to get node numbers of PhyiscalNodes and their nets. Physical nodes exist only on other servers, but a shadow object is created here for tracking node position. :param message: link message to handle :return: nothing """ if message.message_type == MessageTypes.LINK.value and message.flags & MessageFlags.ADD.value: nn = message.node_numbers() # first node is always link layer node in Link add message if nn[0] not in self.session.broker.network_nodes: return if nn[1] in self.session.broker.physical_nodes: # record the fact that this PhysicalNode is linked to a net dummy = CoreNodeBase(session=self.session, _id=nn[1], name="n%d" % nn[1], start=False) self.addphys(nn[0], dummy)
def start_daemon(self, node: CoreNodeBase) -> None: """ Start one EMANE daemon per node having a radio. Add a control network even if the user has not configured one. """ logging.info("starting emane daemons...") loglevel = str(EmaneManager.DEFAULT_LOG_LEVEL) cfgloglevel = self.session.options.get_config_int("emane_log_level") realtime = self.session.options.get_config_bool("emane_realtime", default=True) if cfgloglevel: logging.info("setting user-defined emane log level: %d", cfgloglevel) loglevel = str(cfgloglevel) emanecmd = f"emane -d -l {loglevel}" if realtime: emanecmd += " -r" if isinstance(node, CoreNode): otagroup, _otaport = self.get_config("otamanagergroup").split(":") otadev = self.get_config("otamanagerdevice") otanetidx = self.session.get_control_net_index(otadev) eventgroup, _eventport = self.get_config( "eventservicegroup").split(":") eventdev = self.get_config("eventservicedevice") eventservicenetidx = self.session.get_control_net_index(eventdev) # control network not yet started here self.session.add_remove_control_iface(node, 0, remove=False, conf_required=False) if otanetidx > 0: logging.info("adding ota device ctrl%d", otanetidx) self.session.add_remove_control_iface(node, otanetidx, remove=False, conf_required=False) if eventservicenetidx >= 0: logging.info("adding event service device ctrl%d", eventservicenetidx) self.session.add_remove_control_iface(node, eventservicenetidx, remove=False, conf_required=False) # multicast route is needed for OTA data logging.info("OTA GROUP(%s) OTA DEV(%s)", otagroup, otadev) node.node_net_client.create_route(otagroup, otadev) # multicast route is also needed for event data if on control network if eventservicenetidx >= 0 and eventgroup != otagroup: node.node_net_client.create_route(eventgroup, eventdev) # start emane log_file = os.path.join(node.nodedir, f"{node.name}-emane.log") platform_xml = os.path.join(node.nodedir, f"{node.name}-platform.xml") args = f"{emanecmd} -f {log_file} {platform_xml}" node.cmd(args) logging.info("node(%s) emane daemon running: %s", node.name, args) else: path = self.session.session_dir log_file = os.path.join(path, f"{node.name}-emane.log") platform_xml = os.path.join(path, f"{node.name}-platform.xml") emanecmd += f" -f {log_file} {platform_xml}" node.host_cmd(emanecmd, cwd=path) logging.info("node(%s) host emane daemon running: %s", node.name, emanecmd)