def handle_node_event(node_data: NodeData) -> core_pb2.Event: """ Handle node event when there is a node event :param node_data: node data :return: node event that contains node id, name, model, position, and services """ node = node_data.node x, y, _ = node.position.get() position = core_pb2.Position(x=x, y=y) lon, lat, alt = node.position.get_geo() geo = core_pb2.Geo(lon=lon, lat=lat, alt=alt) services = [x.name for x in node.services] node_proto = core_pb2.Node( id=node.id, name=node.name, model=node.type, icon=node.icon, position=position, geo=geo, services=services, ) message_type = node_data.message_type.value node_event = core_pb2.NodeEvent(message_type=message_type, node=node_proto) return core_pb2.Event(node_event=node_event, source=node_data.source)
def create_node(self, x, y, node_type, model): """ Add node, with information filled in, to grpc manager :param int x: x coord :param int y: y coord :param core_pb2.NodeType node_type: node type :param str model: node model :return: nothing """ node_id = self.next_node_id() position = core_pb2.Position(x=x, y=y) image = None if NodeUtils.is_image_node(node_type): image = "ubuntu:latest" emane = None if node_type == core_pb2.NodeType.EMANE: emane = self.emane_models[0] node = core_pb2.Node( id=node_id, type=node_type, name=f"n{node_id}", model=model, position=position, image=image, emane=emane, ) logging.debug( "adding node to core session: %s, coords: (%s, %s), name: %s", self.session_id, x, y, node.name, ) return node
def main(): core = client.CoreGrpcClient() with core.context_connect(): # create session response = core.create_session() logging.info("created session: %s", response) # handle events session may broadcast session_id = response.session_id core.events(session_id, log_event) # change session state response = core.set_session_state( session_id, core_pb2.SessionState.CONFIGURATION ) logging.info("set session state: %s", response) # create switch node switch = core_pb2.Node(type=core_pb2.NodeType.SWITCH) response = core.add_node(session_id, switch) logging.info("created switch: %s", response) switch_id = response.node_id # helper to create interfaces interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/16") for i in range(2): # create node position = core_pb2.Position(x=50 + 50 * i, y=50) node = core_pb2.Node(position=position) response = core.add_node(session_id, node) logging.info("created node: %s", response) node_id = response.node_id # create link interface_one = interface_helper.create_interface(node_id, 0) response = core.add_link(session_id, node_id, switch_id, interface_one) logging.info("created link: %s", response) # change session state response = core.set_session_state( session_id, core_pb2.SessionState.INSTANTIATION ) logging.info("set session state: %s", response)
def _handle_node_event(self, event): position = core_pb2.Position(x=event.x_position, y=event.y_position) services = event.services or "" services = services.split("|") node_proto = core_pb2.Node(id=event.id, name=event.name, model=event.model, position=position, services=services) return core_pb2.NodeEvent(node=node_proto)
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 to_proto(self) -> core_pb2.Node: emane_configs = [] for key, config in self.emane_model_configs.items(): model, iface_id = key if iface_id is None: iface_id = -1 config = {k: v.to_proto() for k, v in config.items()} emane_config = emane_pb2.NodeEmaneConfig(iface_id=iface_id, model=model, config=config) emane_configs.append(emane_config) service_configs = {} for service, service_data in self.service_configs.items(): service_configs[service] = services_pb2.NodeServiceConfig( service=service, data=service_data.to_proto()) for service, file_configs in self.service_file_configs.items(): service_config = service_configs.get(service) if service_config: service_config.files.update(file_configs) else: service_configs[service] = services_pb2.NodeServiceConfig( service=service, files=file_configs) config_service_configs = {} for service, service_config in self.config_service_configs.items(): config_service_configs[ service] = configservices_pb2.ConfigServiceConfig( templates=service_config.templates, config=service_config.config) return core_pb2.Node( id=self.id, name=self.name, type=self.type.value, model=self.model, position=self.position.to_proto(), services=self.services, config_services=self.config_services, emane=self.emane, icon=self.icon, image=self.image, server=self.server, dir=self.dir, channel=self.channel, canvas=self.canvas, wlan_config={k: v.to_proto() for k, v in self.wlan_config.items()}, mobility_config={ k: v.to_proto() for k, v in self.mobility_config.items() }, service_configs=service_configs, config_service_configs=config_service_configs, emane_configs=emane_configs, )
def test_add_node(self, grpc_server): # given client = CoreGrpcClient() session = grpc_server.coreemu.create_session() # then with client.context_connect(): node = core_pb2.Node() response = client.add_node(session.id, node) # then assert response.node_id is not None assert session.get_node(response.node_id) is not None
def create_node( self, x: float, y: float, node_type: core_pb2.NodeType, model: str ) -> Optional[core_pb2.Node]: """ Add node, with information filled in, to grpc manager """ node_id = self.next_node_id() position = core_pb2.Position(x=x, y=y) image = None if NodeUtils.is_image_node(node_type): image = "ubuntu:latest" emane = None if node_type == core_pb2.NodeType.EMANE: if not self.emane_models: dialog = EmaneInstallDialog(self.app) dialog.show() return emane = self.emane_models[0] name = f"EMANE{node_id}" elif node_type == core_pb2.NodeType.WIRELESS_LAN: name = f"WLAN{node_id}" elif node_type in [core_pb2.NodeType.RJ45, core_pb2.NodeType.TUNNEL]: name = "UNASSIGNED" else: name = f"n{node_id}" node = core_pb2.Node( id=node_id, type=node_type, name=name, model=model, position=position, image=image, emane=emane, ) if NodeUtils.is_custom(node_type, model): services = NodeUtils.get_custom_node_services(self.app.guiconfig, model) node.services[:] = services # assign default services to CORE node else: services = self.default_services.get(model) if services: node.services[:] = services logging.info( "add node(%s) to session(%s), coordinates(%s, %s)", node.name, self.session_id, x, y, ) return node
def to_proto(self) -> core_pb2.Node: return core_pb2.Node( id=self.id, name=self.name, type=self.type.value, model=self.model, position=self.position.to_proto(), services=self.services, config_services=self.config_services, emane=self.emane, icon=self.icon, image=self.image, server=self.server, dir=self.dir, channel=self.channel, )
def handle_node_event(event: NodeData) -> core_pb2.NodeEvent: """ Handle node event when there is a node event :param event: node data :return: node event that contains node id, name, model, position, and services """ position = core_pb2.Position(x=event.x_position, y=event.y_position) node_proto = core_pb2.Node( id=event.id, name=event.name, model=event.model, position=position, services=event.services, ) return core_pb2.NodeEvent(node=node_proto, source=event.source)
def get_node_proto(session: Session, node: NodeBase) -> core_pb2.Node: """ Convert CORE node to protobuf representation. :param session: session containing node :param node: node to convert :return: node proto """ node_type = session.get_node_type(node.__class__) position = core_pb2.Position(x=node.position.x, y=node.position.y, z=node.position.z) geo = core_pb2.Geo(lat=node.position.lat, lon=node.position.lon, alt=node.position.alt) services = [x.name for x in node.services] model = node.type node_dir = None config_services = [] if isinstance(node, CoreNodeBase): node_dir = node.nodedir config_services = [x for x in node.config_services] channel = None if isinstance(node, CoreNode): channel = node.ctrlchnlname emane_model = None if isinstance(node, EmaneNet): emane_model = node.model.name image = None if isinstance(node, (DockerNode, LxcNode)): image = node.image return core_pb2.Node( id=node.id, name=node.name, emane=emane_model, model=model, type=node_type.value, position=position, geo=geo, services=services, icon=node.icon, image=image, config_services=config_services, dir=node_dir, channel=channel, canvas=node.canvas, )
def get_node_proto(session: Session, node: NodeBase) -> core_pb2.Node: """ Convert CORE node to protobuf representation. :param session: session containing node :param node: node to convert :return: node proto """ node_type = session.get_node_type(node.__class__) position = core_pb2.Position(x=node.position.x, y=node.position.y, z=node.position.z) geo = core_pb2.Geo(lat=node.position.lat, lon=node.position.lon, alt=node.position.alt) services = getattr(node, "services", []) if services is None: services = [] services = [x.name for x in services] config_services = getattr(node, "config_services", {}) config_services = [x for x in config_services] emane_model = None if isinstance(node, EmaneNet): emane_model = node.model.name model = getattr(node, "type", None) node_dir = getattr(node, "nodedir", None) channel = getattr(node, "ctrlchnlname", None) image = getattr(node, "image", None) return core_pb2.Node( id=node.id, name=node.name, emane=emane_model, model=model, type=node_type.value, position=position, geo=geo, services=services, icon=node.icon, image=image, config_services=config_services, dir=node_dir, channel=channel, )
def handle_node_event(event): """ Handle node event when there is a node event :param core.emulator.data.NodeData event: node data :return: node event that contains node id, name, model, position, and services :rtype: core.api.grpc.core_pb2.NodeEvent """ position = core_pb2.Position(x=event.x_position, y=event.y_position) services = event.services or "" services = services.split("|") node_proto = core_pb2.Node( id=event.id, name=event.name, model=event.model, position=position, services=services, ) return core_pb2.NodeEvent(node=node_proto, source=event.source)
def GetSession(self, request, context): logging.debug("get session: %s", request) session = self.get_session(request.session_id, context) links = [] nodes = [] for _id in session.nodes: node = session.nodes[_id] if not isinstance(node.id, int): continue node_type = nodeutils.get_node_type(node.__class__).value model = getattr(node, "type", None) position = core_pb2.Position(x=node.position.x, y=node.position.y, z=node.position.z) services = getattr(node, "services", []) if services is None: services = [] services = [x.name for x in services] emane_model = None if nodeutils.is_node(node, NodeTypes.EMANE): emane_model = node.model.name node_proto = core_pb2.Node(id=node.id, name=node.name, emane=emane_model, model=model, type=node_type, position=position, services=services) nodes.append(node_proto) node_links = get_links(session, node) links.extend(node_links) session_proto = core_pb2.Session(state=session.state, nodes=nodes, links=links) return core_pb2.GetSessionResponse(session=session_proto)
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 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 get_node_proto(session: Session, node: NodeBase, emane_configs: List[NodeEmaneConfig]) -> core_pb2.Node: """ Convert CORE node to protobuf representation. :param session: session containing node :param node: node to convert :param emane_configs: emane configs related to node :return: node proto """ node_type = session.get_node_type(node.__class__) position = core_pb2.Position(x=node.position.x, y=node.position.y, z=node.position.z) geo = core_pb2.Geo(lat=node.position.lat, lon=node.position.lon, alt=node.position.alt) services = [x.name for x in node.services] model = node.type node_dir = None config_services = [] if isinstance(node, CoreNodeBase): node_dir = str(node.directory) config_services = [x for x in node.config_services] channel = None if isinstance(node, CoreNode): channel = str(node.ctrlchnlname) emane_model = None if isinstance(node, EmaneNet): emane_model = node.model.name image = None if isinstance(node, (DockerNode, LxcNode)): image = node.image # check for wlan config wlan_config = session.mobility.get_configs( node.id, config_type=BasicRangeModel.name) if wlan_config: wlan_config = get_config_options(wlan_config, BasicRangeModel) # check for mobility config mobility_config = session.mobility.get_configs( node.id, config_type=Ns2ScriptedMobility.name) if mobility_config: mobility_config = get_config_options(mobility_config, Ns2ScriptedMobility) # check for service configs custom_services = session.services.custom_services.get(node.id) service_configs = {} if custom_services: for service in custom_services.values(): service_proto = get_service_configuration(service) service_configs[service.name] = NodeServiceConfig( node_id=node.id, service=service.name, data=service_proto, files=service.config_data, ) # check for config service configs config_service_configs = {} if isinstance(node, CoreNode): for service in node.config_services.values(): if not service.custom_templates and not service.custom_config: continue config_service_configs[service.name] = ConfigServiceConfig( node_id=node.id, name=service.name, templates=service.custom_templates, config=service.custom_config, ) return core_pb2.Node( id=node.id, name=node.name, emane=emane_model, model=model, type=node_type.value, position=position, geo=geo, services=services, icon=node.icon, image=image, config_services=config_services, dir=node_dir, channel=channel, canvas=node.canvas, wlan_config=wlan_config, mobility_config=mobility_config, service_configs=service_configs, config_service_configs=config_service_configs, emane_configs=emane_configs, )
def main(args): core = client.CoreGrpcClient() with core.context_connect(): # create session response = core.create_session() session_id = response.session_id logging.info("created session: %s", response) # add distributed server server_name = "core2" response = core.add_session_server(session_id, server_name, args.server) logging.info("added session server: %s", response) # handle events session may broadcast core.events(session_id, log_event) # change session state response = core.set_session_state( session_id, core_pb2.SessionState.CONFIGURATION ) logging.info("set session state: %s", response) # create switch node switch = core_pb2.Node(type=core_pb2.NodeType.SWITCH) response = core.add_node(session_id, switch) logging.info("created switch: %s", response) switch_id = response.node_id # helper to create interfaces interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/16") # create node one position = core_pb2.Position(x=100, y=50) node = core_pb2.Node(position=position) response = core.add_node(session_id, node) logging.info("created node one: %s", response) node_one_id = response.node_id # create link interface_one = interface_helper.create_interface(node_one_id, 0) response = core.add_link(session_id, node_one_id, switch_id, interface_one) logging.info("created link from node one to switch: %s", response) # create node two position = core_pb2.Position(x=200, y=50) node = core_pb2.Node(position=position, server=server_name) response = core.add_node(session_id, node) logging.info("created node two: %s", response) node_two_id = response.node_id # create link interface_one = interface_helper.create_interface(node_two_id, 0) response = core.add_link(session_id, node_two_id, switch_id, interface_one) logging.info("created link from node two to switch: %s", response) # change session state response = core.set_session_state( session_id, core_pb2.SessionState.INSTANTIATION ) logging.info("set session state: %s", response)