def add_link( self, session_id, node_one_id, node_two_id, interface_one=None, interface_two=None, options=None, ): """ Add a link between nodes. :param int session_id: session id :param int node_one_id: node one id :param int node_two_id: node two id :param core_pb2.Interface interface_one: node one interface data :param core_pb2.Interface interface_two: node two interface data :param core_pb2.LinkOptions options: options for link (jitter, bandwidth, etc) :return: response with result of success or failure :rtype: core_pb2.AddLinkResponse :raises grpc.RpcError: when session or one of the nodes don't exist """ link = core_pb2.Link( node_one_id=node_one_id, node_two_id=node_two_id, type=core_pb2.LinkType.WIRED, interface_one=interface_one, interface_two=interface_two, options=options, ) request = core_pb2.AddLinkRequest(session_id=session_id, link=link) return self.stub.AddLink(request)
def create_link( self, edge: CanvasEdge, canvas_src_node: CanvasNode, canvas_dst_node: CanvasNode ): """ Create core link for a pair of canvas nodes, with token referencing the canvas edge. """ src_node = canvas_src_node.core_node dst_node = canvas_dst_node.core_node # determine subnet self.interfaces_manager.determine_subnets(canvas_src_node, canvas_dst_node) src_interface = None if NodeUtils.is_container_node(src_node.type): src_interface = self.create_interface(canvas_src_node) edge.src_interface = src_interface self.interface_to_edge[(src_node.id, src_interface.id)] = edge.token dst_interface = None if NodeUtils.is_container_node(dst_node.type): dst_interface = self.create_interface(canvas_dst_node) edge.dst_interface = dst_interface self.interface_to_edge[(dst_node.id, dst_interface.id)] = edge.token link = core_pb2.Link( type=core_pb2.LinkType.WIRED, node_one_id=src_node.id, node_two_id=dst_node.id, interface_one=src_interface, interface_two=dst_interface, ) edge.set_link(link) self.links[edge.token] = edge logging.info("Add link between %s and %s", src_node.name, dst_node.name)
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 """ iface1 = None if link_data.iface1 is not None: iface1 = convert_iface(link_data.iface1) iface2 = None if link_data.iface2 is not None: iface2 = convert_iface(link_data.iface2) options = convert_link_options(link_data.options) return core_pb2.Link( type=link_data.type.value, node1_id=link_data.node1_id, node2_id=link_data.node2_id, iface1=iface1, iface2=iface2, options=options, network_id=link_data.network_id, label=link_data.label, color=link_data.color, )
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 start_session(self) -> core_pb2.StartSessionResponse: self.interfaces_manager.reset_mac() nodes = [x.core_node for x in self.canvas_nodes.values()] links = [] for edge in self.links.values(): link = core_pb2.Link() link.CopyFrom(edge.link) if link.HasField("interface_one") and not link.interface_one.mac: link.interface_one.mac = self.interfaces_manager.next_mac() if link.HasField("interface_two") and not link.interface_two.mac: link.interface_two.mac = self.interfaces_manager.next_mac() links.append(link) wlan_configs = self.get_wlan_configs_proto() mobility_configs = self.get_mobility_configs_proto() emane_model_configs = self.get_emane_model_configs_proto() hooks = list(self.hooks.values()) service_configs = self.get_service_configs_proto() file_configs = self.get_service_file_configs_proto() asymmetric_links = [ x.asymmetric_link for x in self.links.values() if x.asymmetric_link ] config_service_configs = self.get_config_service_configs_proto() if self.emane_config: emane_config = {x: self.emane_config[x].value for x in self.emane_config} else: emane_config = None response = core_pb2.StartSessionResponse(result=False) try: response = self.client.start_session( self.session_id, nodes, links, self.location, hooks, emane_config, emane_model_configs, wlan_configs, mobility_configs, service_configs, file_configs, asymmetric_links, config_service_configs, ) logging.info( "start session(%s), result: %s", self.session_id, response.result ) if response.result: self.set_metadata() except grpc.RpcError as e: self.app.show_grpc_exception("Start Session Error", e) return response
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 to_proto(self) -> core_pb2.Link: iface1 = self.iface1.to_proto() if self.iface1 else None iface2 = self.iface2.to_proto() if self.iface2 else None options = self.options.to_proto() if self.options else None return core_pb2.Link( type=self.type.value, node1_id=self.node1_id, node2_id=self.node2_id, iface1=iface1, iface2=iface2, options=options, network_id=self.network_id, label=self.label, color=self.color, )
def main(): core = client.CoreGrpcClient() with core.context_connect(): # create session response = core.create_session() session_id = response.session_id logging.info("created session: %s", response) # create nodes for session nodes = [] position = core_pb2.Position(x=50, y=100) switch = core_pb2.Node(id=1, type=core_pb2.NodeType.SWITCH, position=position) nodes.append(switch) for i in range(2, 50): position = core_pb2.Position(x=50 + 50 * i, y=50) node = core_pb2.Node(id=i, position=position, model="PC") nodes.append(node) # create links interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/16") links = [] for node in nodes: interface_one = interface_helper.create_interface(node.id, 0) link = core_pb2.Link( type=core_pb2.LinkType.WIRED, node_one_id=node.id, node_two_id=switch.id, interface_one=interface_one, ) links.append(link) # start session response = core.start_session(session_id, nodes, links) logging.info("started session: %s", response) input("press enter to shutdown session") response = core.stop_session(session_id) logging.info("stop sessionL %s", response)
def create_link(self, edge, canvas_src_node, canvas_dst_node): """ Create core link for a pair of canvas nodes, with token referencing the canvas edge. :param edge: edge for link :param canvas_src_node: canvas node one :param canvas_dst_node: canvas node two :return: nothing """ src_node = canvas_src_node.core_node dst_node = canvas_dst_node.core_node # determine subnet self.interfaces_manager.determine_subnet(canvas_src_node, canvas_dst_node) src_interface = None if NodeUtils.is_container_node(src_node.type): src_interface = self.create_interface(canvas_src_node) edge.src_interface = src_interface self.interface_to_edge[(src_node.id, src_interface.id)] = edge.token dst_interface = None if NodeUtils.is_container_node(dst_node.type): dst_interface = self.create_interface(canvas_dst_node) edge.dst_interface = dst_interface self.interface_to_edge[(dst_node.id, dst_interface.id)] = edge.token link = core_pb2.Link( type=core_pb2.LinkType.WIRED, node_one_id=src_node.id, node_two_id=dst_node.id, interface_one=src_interface, interface_two=dst_interface, ) edge.set_link(link) self.links[edge.token] = edge
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 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 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 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()
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 test_start_session(self, grpc_server): # given client = CoreGrpcClient() session = grpc_server.coreemu.create_session() position = core_pb2.Position(x=50, y=100) node_one = core_pb2.Node(id=1, position=position, model="PC") position = core_pb2.Position(x=100, y=100) node_two = core_pb2.Node(id=2, position=position, model="PC") position = core_pb2.Position(x=200, y=200) wlan_node = core_pb2.Node(id=3, type=NodeTypes.WIRELESS_LAN.value, position=position) nodes = [node_one, node_two, wlan_node] interface_helper = InterfaceHelper(ip4_prefix="10.83.0.0/16") interface_one = interface_helper.create_interface(node_one.id, 0) interface_two = interface_helper.create_interface(node_two.id, 0) link = core_pb2.Link( type=core_pb2.LinkType.WIRED, node_one_id=node_one.id, node_two_id=node_two.id, interface_one=interface_one, interface_two=interface_two, ) links = [link] hook = core_pb2.Hook(state=core_pb2.SessionState.RUNTIME, file="echo.sh", data="echo hello") hooks = [hook] location_x = 5 location_y = 10 location_z = 15 location_lat = 20 location_lon = 30 location_alt = 40 location_scale = 5 location = core_pb2.SessionLocation( x=location_x, y=location_y, z=location_z, lat=location_lat, lon=location_lon, alt=location_alt, scale=location_scale, ) emane_config_key = "platform_id_start" emane_config_value = "2" emane_config = {emane_config_key: emane_config_value} model_node_id = 20 model_config_key = "bandwidth" model_config_value = "500000" model_config = core_pb2.EmaneModelConfig( node_id=model_node_id, interface_id=-1, model=EmaneIeee80211abgModel.name, config={model_config_key: model_config_value}, ) model_configs = [model_config] wlan_config_key = "range" wlan_config_value = "333" wlan_config = core_pb2.WlanConfig( node_id=wlan_node.id, config={wlan_config_key: wlan_config_value}) wlan_configs = [wlan_config] mobility_config_key = "refresh_ms" mobility_config_value = "60" mobility_config = core_pb2.MobilityConfig( node_id=wlan_node.id, config={mobility_config_key: mobility_config_value}) mobility_configs = [mobility_config] service_config = core_pb2.ServiceConfig(node_id=node_one.id, service="DefaultRoute", validate=["echo hello"]) service_configs = [service_config] service_file_config = core_pb2.ServiceFileConfig( node_id=node_one.id, service="DefaultRoute", file="defaultroute.sh", data="echo hello", ) service_file_configs = [service_file_config] # when with patch.object(CoreXmlWriter, "write"): with client.context_connect(): client.start_session( session.id, nodes, links, location, hooks, emane_config, model_configs, wlan_configs, mobility_configs, service_configs, service_file_configs, ) # then assert node_one.id in session.nodes assert node_two.id in session.nodes assert wlan_node.id in session.nodes assert session.nodes[node_one.id].netif(0) is not None assert session.nodes[node_two.id].netif(0) is not None hook_file, hook_data = session._hooks[core_pb2.SessionState.RUNTIME][0] assert hook_file == hook.file assert hook_data == hook.data assert session.location.refxyz == (location_x, location_y, location_z) assert session.location.refgeo == (location_lat, location_lon, location_alt) assert session.location.refscale == location_scale assert session.emane.get_config(emane_config_key) == emane_config_value set_wlan_config = session.mobility.get_model_config( wlan_node.id, BasicRangeModel.name) assert set_wlan_config[wlan_config_key] == wlan_config_value set_mobility_config = session.mobility.get_model_config( wlan_node.id, Ns2ScriptedMobility.name) assert set_mobility_config[ mobility_config_key] == mobility_config_value set_model_config = session.emane.get_model_config( model_node_id, EmaneIeee80211abgModel.name) assert set_model_config[model_config_key] == model_config_value service = session.services.get_service(node_one.id, service_config.service, default_service=True) assert service.validate == tuple(service_config.validate) service_file = session.services.get_service_file( node_one, service_file_config.service, service_file_config.file) assert service_file.data == service_file_config.data
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"), )