def AddNode(self, request, context): logging.debug("add node: %s", request) session = self.get_session(request.session_id, context) node_proto = request.node node_id = node_proto.id node_type = node_proto.type if node_type is None: node_type = NodeTypes.DEFAULT.value node_type = NodeTypes(node_type) node_options = NodeOptions(name=node_proto.name, model=node_proto.model) node_options.icon = node_proto.icon node_options.opaque = node_proto.opaque node_options.services = node_proto.services position = node_proto.position node_options.set_position(position.x, position.y) node_options.set_location(position.lat, position.lon, position.alt) node = session.add_node(_type=node_type, _id=node_id, node_options=node_options) # configure emane if provided emane_model = node_proto.emane if emane_model: session.emane.set_model_config(node_id, emane_model) return core_pb2.AddNodeResponse(node_id=node.id)
def add_node_data( node_proto: core_pb2.Node) -> Tuple[NodeTypes, int, NodeOptions]: """ Convert node protobuf message to data for creating a node. :param node_proto: node proto message :return: node type, id, and options """ _id = node_proto.id _type = node_proto.type if _type is None: _type = NodeTypes.DEFAULT.value _type = NodeTypes(_type) options = NodeOptions(name=node_proto.name, model=node_proto.model) options.icon = node_proto.icon options.opaque = node_proto.opaque options.image = node_proto.image options.services = node_proto.services options.config_services = node_proto.config_services if node_proto.emane: options.emane = node_proto.emane if node_proto.server: options.server = node_proto.server position = node_proto.position options.set_position(position.x, position.y) if node_proto.HasField("geo"): geo = node_proto.geo options.set_location(geo.lat, geo.lon, geo.alt) return _type, _id, options
def add_node_data(node_proto): """ Convert node protobuf message to data for creating a node. :param core_pb2.Node node_proto: node proto message :return: node type, id, and options :rtype: tuple """ _id = node_proto.id _type = node_proto.type if _type is None: _type = NodeTypes.DEFAULT.value _type = NodeTypes(_type) options = NodeOptions(name=node_proto.name, model=node_proto.model) options.icon = node_proto.icon options.opaque = node_proto.opaque options.image = node_proto.image options.services = node_proto.services if node_proto.emane: options.emane = node_proto.emane if node_proto.server: options.server = node_proto.server position = node_proto.position options.set_position(position.x, position.y) options.set_location(position.lat, position.lon, position.alt) return _type, _id, options
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 handlenodemsg(self, message): """ Determine and return the servers to which this node message should be forwarded. Also keep track of link-layer nodes and the mapping of nodes to servers. :param core.api.coreapi.CoreMessage message: message to handle :return: boolean for handling locally and set of servers :rtype: tuple """ servers = set() handle_locally = False serverfiletxt = None # snoop Node Message for emulation server TLV and record mapping n = message.tlv_data[NodeTlvs.NUMBER.value] # replicate link-layer nodes on all servers nodetype = message.get_tlv(NodeTlvs.TYPE.value) if nodetype is not None: try: nodecls = nodeutils.get_node_class(NodeTypes(nodetype)) except KeyError: logging.warning("broker invalid node type %s", nodetype) return handle_locally, servers if nodecls is None: logging.warning("broker unimplemented node type %s", nodetype) return handle_locally, servers if issubclass(nodecls, CoreNetworkBase ) and nodetype != NodeTypes.WIRELESS_LAN.value: # network node replicated on all servers; could be optimized # don"t replicate WLANs, because ebtables rules won"t work servers = self.getservers() handle_locally = True self.addnet(n) for server in servers: self.addnodemap(server, n) # do not record server name for networks since network # nodes are replicated across all server return handle_locally, servers elif issubclass(nodecls, CoreNodeBase): name = message.get_tlv(NodeTlvs.NAME.value) if name: serverfiletxt = "%s %s %s" % (n, name, nodecls) if issubclass(nodecls, PhysicalNode): # remember physical nodes self.addphys(n) # emulation server TLV specifies server servername = message.get_tlv(NodeTlvs.EMULATION_SERVER.value) server = self.getserverbyname(servername) if server is not None: self.addnodemap(server, n) if server not in servers: servers.add(server) if serverfiletxt and self.session.master: self.writenodeserver(serverfiletxt, server) # hook to update coordinates of physical nodes if n in self.physical_nodes: self.session.mobility.physnodeupdateposition(message) return handle_locally, servers
def handlenodemsg(self, msg): """ Process a Node Message to add/delete or move a node on the SDT display. Node properties are found in a session or self.remotes for remote nodes (or those not yet instantiated). :param msg: node message to handle :return: nothing """ # for distributed sessions to work properly, the SDT option should be # enabled prior to starting the session if not self.is_enabled(): return False # node.(_id, type, icon, name) are used. nodenum = msg.get_tlv(NodeTlvs.NUMBER.value) if not nodenum: return x = msg.get_tlv(NodeTlvs.X_POSITION.value) y = msg.get_tlv(NodeTlvs.Y_POSITION.value) z = None name = msg.get_tlv(NodeTlvs.NAME.value) nodetype = msg.get_tlv(NodeTlvs.TYPE.value) model = msg.get_tlv(NodeTlvs.MODEL.value) icon = msg.get_tlv(NodeTlvs.ICON.value) net = False if nodetype == NodeTypes.DEFAULT.value or nodetype == NodeTypes.PHYSICAL.value: if model is None: model = "router" nodetype = model elif nodetype is not None: nodetype = NodeTypes(nodetype) nodetype = self.session.get_node_class(nodetype).type net = True else: nodetype = None try: node = self.session.get_node(nodenum) except CoreError: node = None if node: self.updatenode(node.id, msg.flags, x, y, z, node.name, node.type, node.icon) else: if nodenum in self.remotes: remote = self.remotes[nodenum] if name is None: name = remote.name if nodetype is None: nodetype = remote.type if icon is None: icon = remote.icon else: remote = Bunch( _id=nodenum, type=nodetype, icon=icon, name=name, net=net, links=set(), ) self.remotes[nodenum] = remote remote.pos = (x, y, z) self.updatenode(nodenum, msg.flags, x, y, z, name, nodetype, icon)