def handlenodemsg(self, msg): """ Process a Node Message to add/delete or move a node on the SDT display. Node properties are found in session._objs 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.(objid, 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 or \ nodetype == NodeTypes.XEN.value: if model is None: model = "router" type = model elif nodetype is not None: type = nodeutils.get_node_class(NodeTypes(nodetype)).type net = True else: type = None try: node = self.session.get_object(nodenum) except KeyError: node = None if node: self.updatenode(node.objid, 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 type is None: type = remote.type if icon is None: icon = remote.icon else: remote = Bunch(objid=nodenum, type=type, 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, type, icon)
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: logger.warn("broker invalid node type %s", nodetype) return handle_locally, servers if nodecls is None: logger.warn("broker unimplemented node type %s", nodetype) return handle_locally, servers if issubclass(nodecls, PyCoreNet) 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, PyCoreNode): 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 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)