def __init__(self, app: "Application", proxy: bool) -> None: """ Create a CoreGrpc instance """ self.app: "Application" = app self.master: tk.Tk = app.master self._client: client.CoreGrpcClient = client.CoreGrpcClient( proxy=proxy) self.session: Optional[Session] = None self.user = getpass.getuser() # global service settings self.services: Dict[str, Set[str]] = {} self.config_services_groups: Dict[str, Set[str]] = {} self.config_services: Dict[str, ConfigService] = {} # loaded configuration data self.servers: Dict[str, CoreServer] = {} self.custom_nodes: Dict[str, NodeDraw] = {} self.custom_observers: Dict[str, Observer] = {} self.read_config() # helpers self.iface_to_edge: Dict[Tuple[int, ...], CanvasEdge] = {} self.ifaces_manager: InterfaceManager = InterfaceManager(self.app) self.observer: Optional[str] = None # session data self.mobility_players: Dict[int, MobilityPlayer] = {} self.canvas_nodes: Dict[int, CanvasNode] = {} self.links: Dict[str, CanvasEdge] = {} self.handling_throughputs: Optional[grpc.Future] = None self.handling_cpu_usage: Optional[grpc.Future] = None self.handling_events: Optional[grpc.Future] = None
def main(args): # helper to create interfaces interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/16") # create grpc client and connect core = client.CoreGrpcClient() core.connect() # create session session = core.create_session() # add distributed server server = Server(name="core2", host=args.server) session.servers.append(server) # handle events session may broadcast core.events(session.id, log_event) # create switch node position = Position(x=150, y=100) switch = session.add_node(1, _type=NodeType.SWITCH, position=position) position = Position(x=100, y=50) node1 = session.add_node(2, position=position) position = Position(x=200, y=50) node2 = session.add_node(3, position=position, server=server.name) # create links iface1 = interface_helper.create_iface(node1.id, 0) session.add_link(node1=node1, node2=switch, iface1=iface1) iface1 = interface_helper.create_iface(node2.id, 0) session.add_link(node1=node2, node2=switch, iface1=iface1) # start session core.start_session(session)
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, SessionState.CONFIGURATION) logging.info("set session state: %s", response) # create switch node switch = Node(type=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 = Position(x=100, y=50) node = Node(position=position) response = core.add_node(session_id, node) logging.info("created node one: %s", response) node1_id = response.node_id # create link interface1 = interface_helper.create_iface(node1_id, 0) response = core.add_link(session_id, node1_id, switch_id, interface1) logging.info("created link from node one to switch: %s", response) # create node two position = Position(x=200, y=50) node = Node(position=position, server=server_name) response = core.add_node(session_id, node) logging.info("created node two: %s", response) node2_id = response.node_id # create link interface1 = interface_helper.create_iface(node2_id, 0) response = core.add_link(session_id, node2_id, switch_id, interface1) logging.info("created link from node two to switch: %s", response) # change session state response = core.set_session_state(session_id, SessionState.INSTANTIATION) logging.info("set session state: %s", response)
def main(): # helper to create interface addresses interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/24") # create grpc client and start connection context, which auto closes connection 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 to configuration so that nodes get started when added response = core.set_session_state(session_id, SessionState.CONFIGURATION) logging.info("set session state: %s", response) # create emane node position = Position(x=200, y=200) emane = Node(type=NodeType.EMANE, position=position) response = core.add_node(session_id, emane) logging.info("created emane: %s", response) emane_id = response.node_id # an emane model must be configured for use, by the emane node core.set_emane_model_config(session_id, emane_id, EmaneIeee80211abgModel.name) # create node one position = Position(x=100, y=100) node1 = Node(type=NodeType.DEFAULT, position=position) response = core.add_node(session_id, node1) logging.info("created node: %s", response) node1_id = response.node_id # create node two position = Position(x=300, y=100) node2 = Node(type=NodeType.DEFAULT, position=position) response = core.add_node(session_id, node2) logging.info("created node: %s", response) node2_id = response.node_id # links nodes to switch interface1 = interface_helper.create_iface(node1_id, 0) response = core.add_link(session_id, node1_id, emane_id, interface1) logging.info("created link: %s", response) interface1 = interface_helper.create_iface(node2_id, 0) response = core.add_link(session_id, node2_id, emane_id, interface1) logging.info("created link: %s", response) # change session state response = core.set_session_state(session_id, SessionState.INSTANTIATION) logging.info("set session state: %s", response)
def __init__(self, app: "Application", proxy: bool): """ Create a CoreGrpc instance """ self._client = client.CoreGrpcClient(proxy=proxy) self.session_id = None self.node_ids = [] self.app = app self.master = app.master self.services = {} self.config_services_groups = {} self.config_services = {} self.default_services = {} self.emane_models = [] self.observer = None # loaded configuration data self.servers = {} self.custom_nodes = {} self.custom_observers = {} self.read_config() # helpers self.interface_to_edge = {} self.interfaces_manager = InterfaceManager(self.app) # session data self.state = None self.canvas_nodes = {} self.location = None self.links = {} self.hooks = {} self.wlan_configs = {} self.mobility_configs = {} self.emane_model_configs = {} self.emane_config = None self.service_configs = {} self.config_service_configs = {} self.file_configs = {} self.mobility_players = {} self.handling_throughputs = None self.handling_events = None self.xml_dir = None self.xml_file = None self.modified_service_nodes = set()
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 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 __init__(self, app: "Application", proxy: bool) -> None: """ Create a CoreGrpc instance """ self.app: "Application" = app self.master: tk.Tk = app.master self._client: client.CoreGrpcClient = client.CoreGrpcClient(proxy=proxy) self.session_id: Optional[int] = None self.services: Dict[str, Set[str]] = {} self.config_services_groups: Dict[str, Set[str]] = {} self.config_services: Dict[str, ConfigService] = {} self.default_services: Dict[NodeType, Set[str]] = {} self.emane_models: List[str] = [] self.observer: Optional[str] = None self.user = getpass.getuser() # loaded configuration data self.servers: Dict[str, CoreServer] = {} self.custom_nodes: Dict[str, NodeDraw] = {} self.custom_observers: Dict[str, Observer] = {} self.read_config() # helpers self.iface_to_edge: Dict[Tuple[int, ...], Tuple[int, ...]] = {} self.ifaces_manager: InterfaceManager = InterfaceManager(self.app) # session data self.state: Optional[SessionState] = None self.canvas_nodes: Dict[int, CanvasNode] = {} self.location: Optional[SessionLocation] = None self.links: Dict[Tuple[int, int], CanvasEdge] = {} self.hooks: Dict[str, Hook] = {} self.emane_config: Dict[str, ConfigOption] = {} self.mobility_players: Dict[int, MobilityPlayer] = {} self.handling_throughputs: Optional[grpc.Future] = None self.handling_cpu_usage: Optional[grpc.Future] = None self.handling_events: Optional[grpc.Future] = None self.xml_dir: Optional[str] = None self.xml_file: Optional[str] = None
def main(): global uavs global protocol global nodepath global mynodeseq global nodecnt global core global session_id #global ack_list # Get command line inputs parser = argparse.ArgumentParser() parser.add_argument('-my', '--my-id', dest='uav_id', metavar='my id', type=int, default='1', help='My Node ID') parser.add_argument('-c', '--covered-zone', dest='covered_zone', metavar='covered zone', type=int, default='1200', help='UAV covered zone limit on X axis') parser.add_argument('-r', '--track_range', dest='track_range', metavar='track range', type=int, default='600', help='UAV tracking range') parser.add_argument('-i', '--update_interval', dest='interval', metavar='update interval', type=int, default='1', help='Update Inteval') parser.add_argument('-p', '--protocol', dest='protocol', metavar='comms protocol', type=str, default='none', help='Comms Protocol') # Parse command line options args = parser.parse_args() protocol = args.protocol # Create grpc client core = client.CoreGrpcClient("172.16.0.254:50051") core.connect() response = core.get_sessions() if not response.sessions: raise ValueError("no current core sessions") session_summary = response.sessions[0] session_id = int(session_summary.id) session = core.get_session(session_id).session # Populate the uavs list with current UAV node information mynodeseq = 0 node = CORENode(args.uav_id, -1) uavs.append(node) RedeployUAV(node) RecordTarget(node) nodecnt += 1 if mynodeseq == -1: print("Error: my id needs to be in the list of UAV IDs") sys.exit() # Initialize values corepath = "/tmp/pycore.*/" nodepath = glob.glob(corepath)[0] msecinterval = float(args.interval) secinterval = msecinterval / 1000 #import pdb; pdb.set_trace() #import pdb #breakpoint() #pdb.set_trace() if protocol == "udp": # Create UDP receiving thread recvthrd = ReceiveUDPThread() recvthrd.start() # Start tracking targets while 1: time.sleep(secinterval) if protocol == "udp": thrdlock.acquire() TrackTargets(args.covered_zone, args.track_range) if protocol == "udp": thrdlock.release()
# required imports from core.api.grpc import client from core.api.grpc.core_pb2 import Node, NodeType, Position, SessionState # interface helper iface_helper = client.InterfaceHelper(ip4_prefix="10.0.0.0/24", ip6_prefix="2001::/64") # create grpc client and connect core = client.CoreGrpcClient() core.connect() # create session and get id response = core.create_session() session_id = response.session_id # change session state to configuration so that nodes get started when added core.set_session_state(session_id, SessionState.CONFIGURATION) # create switch node position = Position(x=200, y=200) switch = Node(type=NodeType.SWITCH, position=position) response = core.add_node(session_id, switch) switch_id = response.node_id # create node one position = Position(x=100, y=100) n1 = Node(type=NodeType.DEFAULT, position=position, model="PC") response = core.add_node(session_id, n1) n1_id = response.node_id
def main(): # helper to create interface addresses interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/24") # create grpc client and start connection context, which auto closes connection 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 to configuration so that nodes get started when added response = core.set_session_state(session_id, SessionState.CONFIGURATION) logging.info("set session state: %s", response) # create wlan node position = Position(x=200, y=200) wlan = Node(type=NodeType.WIRELESS_LAN, position=position) response = core.add_node(session_id, wlan) logging.info("created wlan: %s", response) wlan_id = response.node_id # change/configure wlan if desired # NOTE: error = loss, and named this way for legacy purposes for now config = { "bandwidth": "54000000", "range": "500", "jitter": "0", "delay": "5000", "error": "0", } response = core.set_wlan_config(session_id, wlan_id, config) logging.info("set wlan config: %s", response) # create node one position = Position(x=100, y=100) node1 = Node(type=NodeType.DEFAULT, position=position) response = core.add_node(session_id, node1) logging.info("created node: %s", response) node1_id = response.node_id # create node two position = Position(x=300, y=100) node2 = Node(type=NodeType.DEFAULT, position=position) response = core.add_node(session_id, node2) logging.info("created node: %s", response) node2_id = response.node_id # links nodes to switch interface1 = interface_helper.create_iface(node1_id, 0) response = core.add_link(session_id, node1_id, wlan_id, interface1) logging.info("created link: %s", response) interface1 = interface_helper.create_iface(node2_id, 0) response = core.add_link(session_id, node2_id, wlan_id, interface1) logging.info("created link: %s", response) # change session state response = core.set_session_state(session_id, SessionState.INSTANTIATION) logging.info("set session state: %s", response)
def main(): global targets # Original waypoints original_wypts = { 1: (100, 150), 2: (100, 300), 3: (100, 450), 4: (100, 600), 6: (400, 150), 7: (400, 300), 8: (400, 450), 9: (400, 600) } # Targets colors colors = [ 'blue', 'yellow', 'green', 'red', 'lime', 'orange', 'pink', 'purple', 'lavender', 'cyan' ] targets = { 11: colors[0], 12: colors[1], 13: colors[2], 14: colors[3], 16: colors[4], 17: colors[5], 18: colors[6], 19: colors[7] } # Get command line inputs if len(sys.argv) >= 7: node_id = int(sys.argv[1]) xuav = int(sys.argv[2]) yuav = int(sys.argv[3]) rad = int(sys.argv[4]) speed = float(sys.argv[5]) msecduration = float(sys.argv[6]) duration = msecduration / 1000 else: print("move_node.py nodenum xuav yuav radius speed duration(msec)\n") sys.exit() # Create grpc client core = client.CoreGrpcClient("172.16.0.254:50051") core.connect() response = core.get_sessions() if not response.sessions: raise ValueError("no current core sessions") session_summary = response.sessions[0] session_id = int(session_summary.id) session = core.get_session(session_id).session # Set CORE UAV node_wypt = original_wypts[node_id] core_uav = CoreUav(core, session_id, node_id, xuav, yuav, node_wypt[0], node_wypt[1]) # Initialize targets SetColor(core, session_id, node_id, 'grey', "uav") for target_id, color in targets.items(): SetColor(core, session_id, target_id, color, "target") print("Start XML RPC thread") # Initiate xmlrpc server xml_rpc_server_thread = StartXmlRpcServerThread(core_uav) xml_rpc_server_thread.start() print("Start MOVE UAV thread") # Move UAV node while 1: time.sleep(duration) position = core_uav.getWypt() xtrgt, ytrgt = position[0], position[1] xuav, yuav = MoveVehicle(xuav, yuav, xtrgt, ytrgt, rad, speed, duration) #print("xuav: %d, yuav: %d" % (xuav, yuav)) # Find UAV color to set target_id = core_uav.target color = "grey" if target_id in targets: color = targets[target_id] icon_file_path = iconpath + color + "_plane.png" # Set position and keep current UAV color pos = core_pb2.Position(x=xuav, y=yuav) response = core.edit_node(session_id=session_id, node_id=node_id, position=pos, icon=icon_file_path) core_uav.setPosition(xuav, yuav)