def handle_link_event(event): """ Handle link event when there is a link event :param core.emulator.data.LinkData event: link data :return: link event that has message type and link information :rtype: core.api.grpc.core_pb2.LinkEvent """ interface_one = None if event.interface1_id is not None: interface_one = core_pb2.Interface( id=event.interface1_id, name=event.interface1_name, mac=convert_value(event.interface1_mac), ip4=convert_value(event.interface1_ip4), ip4mask=event.interface1_ip4_mask, ip6=convert_value(event.interface1_ip6), ip6mask=event.interface1_ip6_mask, ) interface_two = None if event.interface2_id is not None: interface_two = core_pb2.Interface( id=event.interface2_id, name=event.interface2_name, mac=convert_value(event.interface2_mac), ip4=convert_value(event.interface2_ip4), ip4mask=event.interface2_ip4_mask, ip6=convert_value(event.interface2_ip6), ip6mask=event.interface2_ip6_mask, ) options = core_pb2.LinkOptions( opaque=event.opaque, jitter=event.jitter, key=event.key, mburst=event.mburst, mer=event.mer, per=event.per, bandwidth=event.bandwidth, burst=event.burst, delay=event.delay, dup=event.dup, unidirectional=event.unidirectional, ) link = core_pb2.Link( type=event.link_type, node_one_id=event.node1_id, node_two_id=event.node2_id, interface_one=interface_one, interface_two=interface_two, options=options, ) return core_pb2.LinkEvent(message_type=event.message_type, link=link)
def convert_link(link_data: LinkData) -> core_pb2.Link: """ Convert link_data into core protobuf link. :param link_data: link to convert :return: core protobuf Link """ interface_one = None if link_data.interface1_id is not None: interface_one = core_pb2.Interface( id=link_data.interface1_id, name=link_data.interface1_name, mac=convert_value(link_data.interface1_mac), ip4=convert_value(link_data.interface1_ip4), ip4mask=link_data.interface1_ip4_mask, ip6=convert_value(link_data.interface1_ip6), ip6mask=link_data.interface1_ip6_mask, ) interface_two = None if link_data.interface2_id is not None: interface_two = core_pb2.Interface( id=link_data.interface2_id, name=link_data.interface2_name, mac=convert_value(link_data.interface2_mac), ip4=convert_value(link_data.interface2_ip4), ip4mask=link_data.interface2_ip4_mask, ip6=convert_value(link_data.interface2_ip6), ip6mask=link_data.interface2_ip6_mask, ) options = core_pb2.LinkOptions( opaque=link_data.opaque, jitter=link_data.jitter, key=link_data.key, mburst=link_data.mburst, mer=link_data.mer, per=link_data.per, bandwidth=link_data.bandwidth, burst=link_data.burst, delay=link_data.delay, dup=link_data.dup, unidirectional=link_data.unidirectional, ) return core_pb2.Link( type=link_data.link_type.value, node_one_id=link_data.node1_id, node_two_id=link_data.node2_id, interface_one=interface_one, interface_two=interface_two, options=options, network_id=link_data.network_id, label=link_data.label, color=link_data.color, )
def convert_link(session, link_data): interface_one = None if link_data.interface1_id is not None: node = session.get_node(link_data.node1_id) interface_name = None if not isinstance(node, CoreNetworkBase): interface = node.netif(link_data.interface1_id) interface_name = interface.name interface_one = core_pb2.Interface( id=link_data.interface1_id, name=interface_name, mac=convert_value(link_data.interface1_mac), ip4=convert_value(link_data.interface1_ip4), ip4mask=link_data.interface1_ip4_mask, ip6=convert_value(link_data.interface1_ip6), ip6mask=link_data.interface1_ip6_mask) interface_two = None if link_data.interface2_id is not None: node = session.get_node(link_data.node2_id) interface_name = None if not isinstance(node, CoreNetworkBase): interface = node.netif(link_data.interface2_id) interface_name = interface.name interface_two = core_pb2.Interface( id=link_data.interface2_id, name=interface_name, mac=convert_value(link_data.interface2_mac), ip4=convert_value(link_data.interface2_ip4), ip4mask=link_data.interface2_ip4_mask, ip6=convert_value(link_data.interface2_ip6), ip6mask=link_data.interface2_ip6_mask) options = core_pb2.LinkOptions(opaque=link_data.opaque, jitter=link_data.jitter, key=link_data.key, mburst=link_data.mburst, mer=link_data.mer, per=link_data.per, bandwidth=link_data.bandwidth, burst=link_data.burst, delay=link_data.delay, dup=link_data.dup, unidirectional=link_data.unidirectional) return core_pb2.Link(type=link_data.link_type, node_one_id=link_data.node1_id, node_two_id=link_data.node2_id, interface_one=interface_one, interface_two=interface_two, options=options)
def interface_to_proto(interface: CoreInterface) -> core_pb2.Interface: """ Convenience for converting a core interface to the protobuf representation. :param interface: interface to convert :return: interface proto """ net_id = None if interface.net: net_id = interface.net.id ip4 = None ip4mask = None ip6 = None ip6mask = None for addr in interface.addrlist: network = netaddr.IPNetwork(addr) mask = network.prefixlen ip = str(network.ip) if netaddr.valid_ipv4(ip) and not ip4: ip4 = ip ip4mask = mask elif netaddr.valid_ipv6(ip) and not ip6: ip6 = ip ip6mask = mask return core_pb2.Interface( id=interface.netindex, netid=net_id, name=interface.name, mac=str(interface.hwaddr), mtu=interface.mtu, flowid=interface.flow_id, ip4=ip4, ip4mask=ip4mask, ip6=ip6, ip6mask=ip6mask, )
def convert_iface(iface_data: InterfaceData) -> core_pb2.Interface: return core_pb2.Interface( id=iface_data.id, name=iface_data.name, mac=iface_data.mac, ip4=iface_data.ip4, ip4_mask=iface_data.ip4_mask, ip6=iface_data.ip6, ip6_mask=iface_data.ip6_mask, )
def _handle_link_event(self, event): interface_one = None if event.interface1_id is not None: interface_one = core_pb2.Interface( id=event.interface1_id, name=event.interface1_name, mac=convert_value(event.interface1_mac), ip4=convert_value(event.interface1_ip4), ip4mask=event.interface1_ip4_mask, ip6=convert_value(event.interface1_ip6), ip6mask=event.interface1_ip6_mask) interface_two = None if event.interface2_id is not None: interface_two = core_pb2.Interface( id=event.interface2_id, name=event.interface2_name, mac=convert_value(event.interface2_mac), ip4=convert_value(event.interface2_ip4), ip4mask=event.interface2_ip4_mask, ip6=convert_value(event.interface2_ip6), ip6mask=event.interface2_ip6_mask) options = core_pb2.LinkOptions(opaque=event.opaque, jitter=event.jitter, key=event.key, mburst=event.mburst, mer=event.mer, per=event.per, bandwidth=event.bandwidth, burst=event.burst, delay=event.delay, dup=event.dup, unidirectional=event.unidirectional) link = core_pb2.Link(type=event.link_type, node_one_id=event.node1_id, node_two_id=event.node2_id, interface_one=interface_one, interface_two=interface_two, options=options) return core_pb2.LinkEvent(message_type=event.message_type, link=link)
def to_proto(self) -> core_pb2.Interface: return core_pb2.Interface( id=self.id, name=self.name, mac=self.mac, ip4=self.ip4, ip4_mask=self.ip4_mask, ip6=self.ip6, ip6_mask=self.ip6_mask, net_id=self.net_id, flow_id=self.flow_id, mtu=self.mtu, node_id=self.node_id, net2_id=self.net2_id, )
def create_interface(self, canvas_node): node = canvas_node.core_node ip4, ip6, prefix = self.interfaces_manager.get_ips(node.id) interface_id = len(canvas_node.interfaces) name = f"eth{interface_id}" interface = core_pb2.Interface(id=interface_id, name=name, ip4=ip4, ip4mask=prefix, ip6=ip6, ip6mask=prefix) canvas_node.interfaces.append(interface) logging.debug( "create node(%s) interface IPv4: %s, name: %s", node.name, interface.ip4, interface.name, ) return interface
def create_interface(self, node_id: int, interface_id: int, name: str = None, mac: str = None) -> core_pb2.Interface: """ Creates interface data for linking nodes, using the nodes unique id for generation, along with a random mac address, unless provided. :param node_id: node id to create interface for :param interface_id: interface id for interface :param name: name to set for interface, default is eth{id} :param mac: mac address to use for this interface, default is random generation :return: new interface data for the provided node """ # generate ip4 data ip4 = None ip4_mask = None if self.ip4: ip4 = self.ip4_address(node_id) ip4_mask = self.ip4.prefixlen # generate ip6 data ip6 = None ip6_mask = None if self.ip6: ip6 = self.ip6_address(node_id) ip6_mask = self.ip6.prefixlen # random mac if not mac: mac = utils.random_mac() return core_pb2.Interface( id=interface_id, name=name, ip4=ip4, ip4mask=ip4_mask, ip6=ip6, ip6mask=ip6_mask, mac=str(mac), )
def create_interface(self, canvas_node: CanvasNode) -> core_pb2.Interface: node = canvas_node.core_node ip4, ip6 = self.interfaces_manager.get_ips(node) ip4_mask = self.interfaces_manager.ip4_mask ip6_mask = self.interfaces_manager.ip6_mask interface_id = len(canvas_node.interfaces) name = f"eth{interface_id}" interface = core_pb2.Interface( id=interface_id, name=name, ip4=ip4, ip4mask=ip4_mask, ip6=ip6, ip6mask=ip6_mask, ) logging.debug( "create node(%s) interface(%s) IPv4(%s) IPv6(%s)", node.name, interface.name, interface.ip4, interface.ip6, ) return interface
def GetNode(self, request, context): logging.debug("get node: %s", request) session = self.get_session(request.session_id, context) node = self.get_node(session, request.node_id, context) interfaces = [] for interface_id in node._netif: interface = node._netif[interface_id] net_id = None if interface.net: net_id = interface.net.id interface_proto = core_pb2.Interface(id=interface_id, netid=net_id, name=interface.name, mac=str(interface.hwaddr), mtu=interface.mtu, flowid=interface.flow_id) interfaces.append(interface_proto) emane_model = None if nodeutils.is_node(node, NodeTypes.EMANE): emane_model = node.model.name services = [x.name for x in getattr(node, "services", [])] position = core_pb2.Position(x=node.position.x, y=node.position.y, z=node.position.z) node_type = nodeutils.get_node_type(node.__class__).value node = core_pb2.Node(id=node.id, name=node.name, type=node_type, emane=emane_model, model=node.type, position=position, services=services) return core_pb2.GetNodeResponse(node=node, interfaces=interfaces)
def iface_to_proto(node_id: int, iface: CoreInterface) -> core_pb2.Interface: """ Convenience for converting a core interface to the protobuf representation. :param node_id: id of node to convert interface for :param iface: interface to convert :return: interface proto """ if iface.node and iface.node.id == node_id: _id = iface.node_id else: _id = iface.net_id net_id = iface.net.id if iface.net else None node_id = iface.node.id if iface.node else None net2_id = iface.othernet.id if iface.othernet else None ip4_net = iface.get_ip4() ip4 = str(ip4_net.ip) if ip4_net else None ip4_mask = ip4_net.prefixlen if ip4_net else None ip6_net = iface.get_ip6() ip6 = str(ip6_net.ip) if ip6_net else None ip6_mask = ip6_net.prefixlen if ip6_net else None mac = str(iface.mac) if iface.mac else None return core_pb2.Interface( id=_id, net_id=net_id, net2_id=net2_id, node_id=node_id, name=iface.name, mac=mac, mtu=iface.mtu, flow_id=iface.flow_id, ip4=ip4, ip4_mask=ip4_mask, ip6=ip6, ip6_mask=ip6_mask, )
def create_interface(self, node_id: int, interface_id: int, name: str = None, mac: str = None) -> core_pb2.Interface: """ Create an interface protobuf object. :param node_id: node id to create interface for :param interface_id: interface id :param name: name of interface :param mac: mac address for interface :return: interface protobuf """ interface_data = self.prefixes.gen_interface(node_id, name, mac) return core_pb2.Interface( id=interface_id, name=interface_data.name, ip4=interface_data.ip4, ip4mask=interface_data.ip4_mask, ip6=interface_data.ip6, ip6mask=interface_data.ip6_mask, mac=interface_data.mac, )
def paste(self): if self.core.is_runtime(): logging.info("paste is disabled during runtime state") return # maps original node canvas id to copy node canvas id copy_map = {} # the edges that will be copy over to_copy_edges = [] for canvas_node in self.to_copy: core_node = canvas_node.core_node actual_x = core_node.position.x + 50 actual_y = core_node.position.y + 50 scaled_x, scaled_y = self.get_scaled_coords(actual_x, actual_y) copy = self.core.create_node(actual_x, actual_y, core_node.type, core_node.model) if not copy: continue node = CanvasNode(self.app, scaled_x, scaled_y, copy, canvas_node.image) # copy configurations and services node.core_node.services[:] = canvas_node.core_node.services node.core_node.config_services[:] = canvas_node.core_node.config_services node.emane_model_configs = deepcopy( canvas_node.emane_model_configs) node.wlan_config = deepcopy(canvas_node.wlan_config) node.mobility_config = deepcopy(canvas_node.mobility_config) node.service_configs = deepcopy(canvas_node.service_configs) node.service_file_configs = deepcopy( canvas_node.service_file_configs) node.config_service_configs = deepcopy( canvas_node.config_service_configs) copy_map[canvas_node.id] = node.id self.core.canvas_nodes[copy.id] = node self.nodes[node.id] = node for edge in canvas_node.edges: if edge.src not in self.to_copy or edge.dst not in self.to_copy: if canvas_node.id == edge.src: dst_node = self.nodes[edge.dst] self.create_edge(node, dst_node) elif canvas_node.id == edge.dst: src_node = self.nodes[edge.src] self.create_edge(src_node, node) else: to_copy_edges.append(edge) # copy link and link config for edge in to_copy_edges: src_node_id = copy_map[edge.token[0]] dst_node_id = copy_map[edge.token[1]] src_node_copy = self.nodes[src_node_id] dst_node_copy = self.nodes[dst_node_id] self.create_edge(src_node_copy, dst_node_copy) token = create_edge_token(src_node_copy.id, dst_node_copy.id) copy_edge = self.edges[token] copy_link = copy_edge.link options = edge.link.options copy_link.options.CopyFrom(options) interface_one = None if copy_link.HasField("interface_one"): interface_one = copy_link.interface_one.id interface_two = None if copy_link.HasField("interface_two"): interface_two = copy_link.interface_two.id if not options.unidirectional: copy_edge.asymmetric_link = None else: asym_interface_one = None if interface_one: asym_interface_one = core_pb2.Interface(id=interface_one) asym_interface_two = None if interface_two: asym_interface_two = core_pb2.Interface(id=interface_two) copy_edge.asymmetric_link = core_pb2.Link( node_one_id=copy_link.node_two_id, node_two_id=copy_link.node_one_id, interface_one=asym_interface_one, interface_two=asym_interface_two, options=edge.asymmetric_link.options, ) self.itemconfig( copy_edge.id, width=self.itemcget(edge.id, "width"), fill=self.itemcget(edge.id, "fill"), ) self.tag_raise(tags.NODE)
def convert_link(session, link_data): """ Convert link_data into core protobuf Link :param core.emulator.session.Session session: :param core.emulator.data.LinkData link_data: :return: core protobuf Link :rtype: core.api.grpc.core_pb2.Link """ interface_one = None if link_data.interface1_id is not None: node = session.get_node(link_data.node1_id) interface_name = None if not isinstance(node, CoreNetworkBase): interface = node.netif(link_data.interface1_id) interface_name = interface.name interface_one = core_pb2.Interface( id=link_data.interface1_id, name=interface_name, mac=convert_value(link_data.interface1_mac), ip4=convert_value(link_data.interface1_ip4), ip4mask=link_data.interface1_ip4_mask, ip6=convert_value(link_data.interface1_ip6), ip6mask=link_data.interface1_ip6_mask, ) interface_two = None if link_data.interface2_id is not None: node = session.get_node(link_data.node2_id) interface_name = None if not isinstance(node, CoreNetworkBase): interface = node.netif(link_data.interface2_id) interface_name = interface.name interface_two = core_pb2.Interface( id=link_data.interface2_id, name=interface_name, mac=convert_value(link_data.interface2_mac), ip4=convert_value(link_data.interface2_ip4), ip4mask=link_data.interface2_ip4_mask, ip6=convert_value(link_data.interface2_ip6), ip6mask=link_data.interface2_ip6_mask, ) options = core_pb2.LinkOptions( opaque=link_data.opaque, jitter=link_data.jitter, key=link_data.key, mburst=link_data.mburst, mer=link_data.mer, per=link_data.per, bandwidth=link_data.bandwidth, burst=link_data.burst, delay=link_data.delay, dup=link_data.dup, unidirectional=link_data.unidirectional, ) return core_pb2.Link( type=link_data.link_type, node_one_id=link_data.node1_id, node_two_id=link_data.node2_id, interface_one=interface_one, interface_two=interface_two, options=options, )
def paste(self): if self.app.core.is_runtime(): logging.info("paste is disabled during runtime state") return # maps original node canvas id to copy node canvas id copy_map = {} # the edges that will be copy over to_copy_edges = [] for canvas_nid in self.to_copy: core_node = self.nodes[canvas_nid].core_node actual_x = core_node.position.x + 50 actual_y = core_node.position.y + 50 scaled_x, scaled_y = self.get_scaled_coords(actual_x, actual_y) copy = self.core.create_node(actual_x, actual_y, core_node.type, core_node.model) node = CanvasNode(self.master, scaled_x, scaled_y, copy, self.nodes[canvas_nid].image) # add new node to modified_service_nodes set if that set contains the to_copy node if self.app.core.service_been_modified(core_node.id): self.app.core.modified_service_nodes.add(copy.id) copy_map[canvas_nid] = node.id self.core.canvas_nodes[copy.id] = node self.nodes[node.id] = node self.core.copy_node_config(core_node.id, copy.id) edges = self.nodes[canvas_nid].edges for edge in edges: if edge.src not in self.to_copy or edge.dst not in self.to_copy: if canvas_nid == edge.src: self.create_edge(node, self.nodes[edge.dst]) elif canvas_nid == edge.dst: self.create_edge(self.nodes[edge.src], node) else: to_copy_edges.append(edge) # copy link and link config for edge in to_copy_edges: source_node_copy = self.nodes[copy_map[edge.token[0]]] dest_node_copy = self.nodes[copy_map[edge.token[1]]] self.create_edge(source_node_copy, dest_node_copy) copy_edge = self.edges[EdgeUtils.get_token(source_node_copy.id, dest_node_copy.id)] copy_link = copy_edge.link options = edge.link.options copy_link.options.CopyFrom(options) interface_one = None if copy_link.HasField("interface_one"): interface_one = copy_link.interface_one.id interface_two = None if copy_link.HasField("interface_two"): interface_two = copy_link.interface_two.id if not options.unidirectional: copy_edge.asymmetric_link = None else: asym_interface_one = None if interface_one: asym_interface_one = core_pb2.Interface(id=interface_one) asym_interface_two = None if interface_two: asym_interface_two = core_pb2.Interface(id=interface_two) copy_edge.asymmetric_link = core_pb2.Link( node_one_id=copy_link.node_two_id, node_two_id=copy_link.node_one_id, interface_one=asym_interface_one, interface_two=asym_interface_two, options=edge.asymmetric_link.options, ) self.itemconfig( copy_edge.id, width=self.itemcget(edge.id, "width"), fill=self.itemcget(edge.id, "fill"), )
def click_apply(self): self.app.canvas.itemconfigure(self.edge.id, width=self.width.get()) self.app.canvas.itemconfigure(self.edge.id, fill=self.color.get()) link = self.edge.link bandwidth = get_int(self.bandwidth) jitter = get_int(self.jitter) delay = get_int(self.delay) duplicate = get_int(self.duplicate) loss = get_float(self.loss) options = core_pb2.LinkOptions(bandwidth=bandwidth, jitter=jitter, delay=delay, dup=duplicate, per=loss) link.options.CopyFrom(options) interface_one = None if link.HasField("interface_one"): interface_one = link.interface_one.id interface_two = None if link.HasField("interface_two"): interface_two = link.interface_two.id if not self.is_symmetric: link.options.unidirectional = True asym_interface_one = None if interface_one: asym_interface_one = core_pb2.Interface(id=interface_one) asym_interface_two = None if interface_two: asym_interface_two = core_pb2.Interface(id=interface_two) down_bandwidth = get_int(self.down_bandwidth) down_jitter = get_int(self.down_jitter) down_delay = get_int(self.down_delay) down_duplicate = get_int(self.down_duplicate) down_loss = get_float(self.down_loss) options = core_pb2.LinkOptions( bandwidth=down_bandwidth, jitter=down_jitter, delay=down_delay, dup=down_duplicate, per=down_loss, unidirectional=True, ) self.edge.asymmetric_link = core_pb2.Link( node_one_id=link.node_two_id, node_two_id=link.node_one_id, interface_one=asym_interface_one, interface_two=asym_interface_two, options=options, ) else: link.options.unidirectional = False self.edge.asymmetric_link = None if self.app.core.is_runtime() and link.HasField("options"): session_id = self.app.core.session_id self.app.core.client.edit_link( session_id, link.node_one_id, link.node_two_id, link.options, interface_one, interface_two, ) if self.edge.asymmetric_link: self.app.core.client.edit_link( session_id, link.node_two_id, link.node_one_id, self.edge.asymmetric_link.options, interface_one, interface_two, ) self.destroy()
def click_apply(self) -> None: self.app.canvas.itemconfigure(self.edge.id, width=self.width.get()) self.app.canvas.itemconfigure(self.edge.id, fill=self.color.get()) link = self.edge.link bandwidth = get_int(self.bandwidth) jitter = get_int(self.jitter) delay = get_int(self.delay) duplicate = get_int(self.duplicate) loss = get_float(self.loss) options = core_pb2.LinkOptions(bandwidth=bandwidth, jitter=jitter, delay=delay, dup=duplicate, loss=loss) link.options.CopyFrom(options) iface1_id = None if link.HasField("iface1"): iface1_id = link.iface1.id iface2_id = None if link.HasField("iface2"): iface2_id = link.iface2.id if not self.is_symmetric: link.options.unidirectional = True asym_iface1 = None if iface1_id: asym_iface1 = core_pb2.Interface(id=iface1_id) asym_iface2 = None if iface2_id: asym_iface2 = core_pb2.Interface(id=iface2_id) down_bandwidth = get_int(self.down_bandwidth) down_jitter = get_int(self.down_jitter) down_delay = get_int(self.down_delay) down_duplicate = get_int(self.down_duplicate) down_loss = get_float(self.down_loss) options = core_pb2.LinkOptions( bandwidth=down_bandwidth, jitter=down_jitter, delay=down_delay, dup=down_duplicate, loss=down_loss, unidirectional=True, ) self.edge.asymmetric_link = core_pb2.Link( node1_id=link.node2_id, node2_id=link.node1_id, iface1=asym_iface1, iface2=asym_iface2, options=options, ) else: link.options.unidirectional = False self.edge.asymmetric_link = None if self.app.core.is_runtime() and link.HasField("options"): session_id = self.app.core.session_id self.app.core.client.edit_link( session_id, link.node1_id, link.node2_id, link.options, iface1_id, iface2_id, ) if self.edge.asymmetric_link: self.app.core.client.edit_link( session_id, link.node2_id, link.node1_id, self.edge.asymmetric_link.options, iface1_id, iface2_id, ) # update edge label self.edge.draw_link_options() self.destroy()