diff --git a/coretk/coretk/app.py b/coretk/coretk/app.py index 9102f4d1..9a9506e2 100644 --- a/coretk/coretk/app.py +++ b/coretk/coretk/app.py @@ -16,16 +16,20 @@ class Application(tk.Frame): self.setup_app() self.menubar = None self.canvas = None + + # start grpc self.core_grpc = CoreGrpc() + self.create_menu() self.create_widgets() def load_images(self): + """ + Load core images + :return: + """ images.load_core_images(Images) - def close_grpc(self): - self.core_grpc.close() - def setup_app(self): self.master.title("CORE") self.master.geometry("1000x800") @@ -47,8 +51,8 @@ class Application(tk.Frame): core_editbar.create_toolbar() self.canvas = CanvasGraph( - grpc=self.core_grpc, master=self, + grpc=self.core_grpc, background="#cccccc", scrollregion=(0, 0, 1000, 1000), ) @@ -79,4 +83,3 @@ if __name__ == "__main__": logging.basicConfig(level=logging.DEBUG) app = Application() app.mainloop() - app.close_grpc() diff --git a/coretk/coretk/coregrpc.py b/coretk/coretk/coregrpc.py index 268c3a13..8596366c 100644 --- a/coretk/coretk/coregrpc.py +++ b/coretk/coretk/coregrpc.py @@ -14,18 +14,20 @@ class CoreGrpc: self.core = client.CoreGrpcClient() self.session_id = None self.set_up() + self.interface_helper = None def log_event(self, event): logging.info("event: %s", event) - def set_up(self): + def redraw_canvas(self): + return + + def create_new_session(self): """ - Create session, handle events session may broadcast, change session state + Create a new session :return: nothing """ - self.core.connect() - # create session response = self.core.create_session() logging.info("created session: %s", response) @@ -33,39 +35,67 @@ class CoreGrpc: self.session_id = response.session_id self.core.events(self.session_id, self.log_event) - # change session state + def query_existing_sessions(self, sessions): + """ + Query for existing sessions and prompt to join one + + :param repeated core_pb2.SessionSummary sessions: summaries of all the existing sessions + + :return: nothing + """ + for session in sessions: + logging.info("Session id: %s, Session state: %s", session.id, session.state) + logging.info("Input a session you want to enter from the keyboard:") + usr_input = int(input()) + if usr_input == 0: + self.create_new_session() + else: + response = self.core.get_session(usr_input) + self.session_id = usr_input + # self.core.events(self.session_id, self.log_event) + logging.info("Entering session_id %s.... Result: %s", usr_input, response) + + def set_up(self): + """ + Query sessions, if there exist any, promt whether to join one + + :return: nothing + """ + self.core.connect() + + response = self.core.get_sessions() + logging.info("all sessions: %s", response) + + # if there are no sessions, create a new session, else join a session + sessions = response.sessions + + if len(sessions) == 0: + self.create_new_session() + else: + # self.create_new_session() + self.query_existing_sessions(sessions) + + def set_configuration_state(self): response = self.core.set_session_state( self.session_id, core_pb2.SessionState.CONFIGURATION ) logging.info("set session state: %s", response) + def set_instantiate_state(self): + response = self.core.set_session_state( + self.session_id, core_pb2.SessionState.INSTANTIATION + ) + logging.info("set session state: %s", response) + def get_session_id(self): return self.session_id - # TODO add checkings to the function - def add_node(self, x, y, node_name): - link_layer_nodes = ["switch", "hub", "wlan", "rj45", "tunnel"] - network_layer_nodes = ["default"] - node = None - if node_name in link_layer_nodes: - if node_name == "switch": - node = core_pb2.Node(type=core_pb2.NodeType.SWITCH) - elif node_name == "hub": - node = core_pb2.Node(type=core_pb2.NodeType.HUB) - elif node_name == "wlan": - node = core_pb2.Node(type=core_pb2.NodeType.WIRELESS_LAN) - elif node_name == "rj45": - node = core_pb2.Node(type=core_pb2.NodeType.RJ45) - elif node_name == "tunnel": - node = core_pb2.Node(type=core_pb2.NodeType.TUNNEL) - - elif node_name in network_layer_nodes: - position = core_pb2.Position(x=x, y=y) - node = core_pb2.Node(position=position) - else: - return + def add_node(self, node_type, model, x, y, name): + logging.info("ADD NODE %s", name) + position = core_pb2.Position(x=x, y=y) + node = core_pb2.Node(type=node_type, position=position, model=model, image=name) response = self.core.add_node(self.session_id, node) - logging.info("created %s: %s", node_name, response) + logging.info("created node: %s", response) return response.node_id def edit_node(self, session_id, node_id, x, y): @@ -73,6 +103,34 @@ class CoreGrpc: response = self.core.edit_node(session_id, node_id, position) logging.info("updated node id %s: %s", node_id, response) + # def create_interface_helper(self): + # self.interface_helper = self.core.InterfaceHelper(ip4_prefix="10.83.0.0/16") + + # TODO case for other core_pb2.NodeType + def add_link(self, id1, id2, type1, type2): + """ + Grpc client request add link + + :param int session_id: session id + :param int id1: node 1 core id + :param core_pb2.NodeType type1: node 1 core node type + :param int id2: node 2 core id + :param core_pb2.NodeType type2: node 2 core node type + :return: nothing + """ + if not self.interface_helper: + logging.debug("INTERFACE HELPER NOT CREATED YET, CREATING ONE...") + self.interface_helper = client.InterfaceHelper(ip4_prefix="10.83.0.0/16") + + interface1 = None + interface2 = None + if type1 == core_pb2.NodeType.DEFAULT: + interface1 = self.interface_helper.create_interface(id1, 0) + if type2 == core_pb2.NodeType.DEFAULT: + interface2 = self.interface_helper.create_interface(id2, 0) + response = self.core.add_link(self.session_id, id1, id2, interface1, interface2) + logging.info("created link: %s", response) + def close(self): """ Clean ups when done using grpc diff --git a/coretk/coretk/coretoolbar.py b/coretk/coretk/coretoolbar.py index d4009f1b..8af43240 100644 --- a/coretk/coretk/coretoolbar.py +++ b/coretk/coretk/coretoolbar.py @@ -27,7 +27,6 @@ class CoreToolbar(object): self.width = 32 self.height = 32 - # Used for drawing the horizontally displayed menu items for network-layer nodes and link-layer node self.selection_tool_button = None # Reference to the option menus @@ -35,8 +34,6 @@ class CoreToolbar(object): self.marker_option_menu = None self.network_layer_option_menu = None - # variables used by canvas graph - self.image_to_draw = None self.canvas = None def update_canvas(self, canvas): @@ -151,63 +148,79 @@ class CoreToolbar(object): logging.debug("Click SELECTION TOOL") self.canvas.mode = GraphMode.SELECT - def click_start_stop_session_tool(self): + def click_start_session_tool(self): logging.debug("Click START STOP SESSION button") self.destroy_children_widgets(self.edit_frame) - self.canvas.set_canvas_mode(GraphMode.SELECT) + self.canvas.mode = GraphMode.SELECT self.create_runtime_toolbar() + # set configuration state + self.canvas.core_grpc.set_configuration_state() + + # grpc client requests creating nodes + for node in self.canvas.grpc_manager.nodes_to_create.values(): + self.canvas.core_grpc.add_node( + node.type, node.model, int(node.x), int(node.y), node.name + ) + self.canvas.grpc_manager.nodes_to_create.clear() + + for edge in self.canvas.grpc_manager.edges_to_create.values(): + self.canvas.core_grpc.add_link(edge.id1, edge.id2, edge.type1, edge.type2) + self.canvas.grpc_manager.edges_to_create.clear() + + self.canvas.core_grpc.set_instantiate_state() + def click_link_tool(self): logging.debug("Click LINK button") - self.canvas.set_canvas_mode(GraphMode.EDGE) + self.canvas.mode = GraphMode.EDGE def pick_router(self, main_button): logging.debug("Pick router option") self.network_layer_option_menu.destroy() main_button.configure(image=Images.get("router")) - self.canvas.set_canvas_mode(GraphMode.PICKNODE) - self.canvas.set_drawing_image(Images.get("router")) - self.canvas.set_drawing_name("default") + self.canvas.mode = GraphMode.PICKNODE + self.canvas.draw_node_image = Images.get("router") + self.canvas.draw_node_name = "router" def pick_host(self, main_button): logging.debug("Pick host option") self.network_layer_option_menu.destroy() main_button.configure(image=Images.get("host")) - self.canvas.set_canvas_mode(GraphMode.PICKNODE) - self.canvas.set_drawing_image(Images.get("host")) - self.canvas.set_drawing_name("default") + self.canvas.mode = GraphMode.PICKNODE + self.canvas.draw_node_image = Images.get("host") + self.canvas.draw_node_name = "host" def pick_pc(self, main_button): logging.debug("Pick PC option") self.network_layer_option_menu.destroy() main_button.configure(image=Images.get("pc")) - self.canvas.set_canvas_mode(GraphMode.PICKNODE) - self.canvas.set_drawing_image(Images.get("pc")) - self.canvas.set_drawing_name("default") + self.canvas.mode = GraphMode.PICKNODE + self.canvas.draw_node_image = Images.get("pc") + self.canvas.draw_node_name = "PC" def pick_mdr(self, main_button): logging.debug("Pick MDR option") self.network_layer_option_menu.destroy() main_button.configure(image=Images.get("mdr")) - self.canvas.set_canvas_mode(GraphMode.PICKNODE) - self.canvas.set_drawing_image(Images.get("mdr")) - self.canvas.set_drawing_name("default") + self.canvas.mode = GraphMode.PICKNODE + self.canvas.draw_node_image = Images.get("mdr") + self.canvas.draw_node_name = "mdr" def pick_prouter(self, main_button): logging.debug("Pick prouter option") self.network_layer_option_menu.destroy() main_button.configure(image=Images.get("prouter")) - self.canvas.set_canvas_mode(GraphMode.PICKNODE) - self.canvas.set_drawing_image(Images.get("prouter")) - self.canvas.set_drawing_name("default") + self.canvas.mode = GraphMode.PICKNODE + self.canvas.draw_node_image = Images.get("prouter") + self.canvas.draw_node_name = "prouter" def pick_ovs(self, main_button): logging.debug("Pick OVS option") self.network_layer_option_menu.destroy() main_button.configure(image=Images.get("ovs")) - self.canvas.set_canvas_mode(GraphMode.PICKNODE) - self.canvas.set_drawing_image(Images.get("ovs")) - self.canvas.set_drawing_name("default") + self.canvas.mode = GraphMode.PICKNODE + self.canvas.draw_node_image = Images.get("ovs") + self.canvas.draw_node_name = "OVS" # TODO what graph node is this def pick_editnode(self, main_button): @@ -294,40 +307,41 @@ class CoreToolbar(object): logging.debug("Pick link-layer node HUB") self.link_layer_option_menu.destroy() main_button.configure(image=Images.get("hub")) - self.canvas.set_canvas_mode(GraphMode.PICKNODE) - self.canvas.set_drawing_image(Images.get("hub")) - self.canvas.set_drawing_name("hub") + self.canvas.mode = GraphMode.PICKNODE + self.canvas.draw_node_image = Images.get("hub") + self.canvas.draw_node_name = "hub" def pick_switch(self, main_button): logging.debug("Pick link-layer node SWITCH") self.link_layer_option_menu.destroy() main_button.configure(image=Images.get("switch")) - self.canvas.set_canvas_mode(GraphMode.PICKNODE) - self.canvas.set_drawing_image(Images.get("switch")) - self.canvas.set_drawing_name("switch") + self.canvas.mode = GraphMode.PICKNODE + self.canvas.draw_node_image = Images.get("switch") + self.canvas.draw_node_name = "switch" def pick_wlan(self, main_button): logging.debug("Pick link-layer node WLAN") self.link_layer_option_menu.destroy() main_button.configure(image=Images.get("wlan")) - self.canvas.set_canvas_mode(GraphMode.PICKNODE) - self.canvas.set_drawing_image(Images.get("wlan")) - self.canvas.set_drawing_name("wlan") + self.canvas.mode = GraphMode.PICKNODE + self.canvas.draw_node_image = Images.get("wlan") + self.canvas.draw_node_name = "wlan" def pick_rj45(self, main_button): logging.debug("Pick link-layer node RJ45") self.link_layer_option_menu.destroy() main_button.configure(image=Images.get("rj45")) - self.canvas.set_canvas_mode(GraphMode.PICKNODE) - self.canvas.set_drawing_image(Images.get("rj45")) + self.canvas.mode = GraphMode.PICKNODE + self.canvas.draw_node_image = Images.get("rj45") + self.canvas.draw_node_name = "rj45" def pick_tunnel(self, main_button): logging.debug("Pick link-layer node TUNNEL") self.link_layer_option_menu.destroy() main_button.configure(image=Images.get("tunnel")) - self.canvas.set_canvas_mode(GraphMode.PICKNODE) - self.canvas.set_drawing_image(Images.get("tunnel")) - self.canvas.set_drawing_image(Images.get("tunnel")) + self.canvas.mode = GraphMode.PICKNODE + self.canvas.draw_node_image = Images.get("tunnel") + self.canvas.draw_node_name = "tunnel" def draw_link_layer_options(self, link_layer_button): """ @@ -476,11 +490,10 @@ class CoreToolbar(object): CreateToolTip(marker_main_button, "background annotation tools") def create_toolbar(self): - # self.load_toolbar_images() self.create_regular_button( self.edit_frame, Images.get("start"), - self.click_start_stop_session_tool, + self.click_start_session_tool, "start the session", ) self.create_radio_button( diff --git a/coretk/coretk/graph.py b/coretk/coretk/graph.py index 06f16488..5a25188b 100644 --- a/coretk/coretk/graph.py +++ b/coretk/coretk/graph.py @@ -2,6 +2,9 @@ import enum import logging import tkinter as tk +from coretk.grpcmanagement import GrpcManager +from coretk.images import Images + class GraphMode(enum.Enum): SELECT = 0 @@ -12,12 +15,11 @@ class GraphMode(enum.Enum): class CanvasGraph(tk.Canvas): - def __init__(self, grpc=None, master=None, cnf=None, **kwargs): + def __init__(self, master=None, grpc=None, cnf=None, **kwargs): if cnf is None: cnf = {} kwargs["highlightthickness"] = 0 super().__init__(master, cnf, **kwargs) - self.core_grpc = grpc self.mode = GraphMode.SELECT self.draw_node_image = None self.draw_node_name = None @@ -26,19 +28,32 @@ class CanvasGraph(tk.Canvas): self.nodes = {} self.edges = {} self.drawing_edge = None - self.setup_menus() self.setup_bindings() self.draw_grid() + self.core_grpc = grpc + self.grpc_manager = GrpcManager() + self.draw_existing_node() - def set_canvas_mode(self, mode): - self.mode = mode + def setup_menus(self): + self.node_context = tk.Menu(self.master) + self.node_context.add_command(label="One") + self.node_context.add_command(label="Two") + self.node_context.add_command(label="Three") - def set_drawing_image(self, img): - self.draw_node_image = img + def setup_bindings(self): + """ + Bind any mouse events or hot keys to the matching action - def set_drawing_name(self, name): - self.draw_node_name = name + :return: nothing + """ + self.bind("", self.click_press) + self.bind("", self.click_release) + self.bind("", self.click_motion) + self.bind("", self.context) + # self.bind("e", self.set_mode) + # self.bind("s", self.set_mode) + # self.bind("n", self.set_mode) def draw_grid(self, width=1000, height=750): """ @@ -65,25 +80,20 @@ class CanvasGraph(tk.Canvas): for i in range(0, height, 27): self.create_line(0, i, width, i, dash=(2, 4), tags="grid line") - def setup_menus(self): - self.node_context = tk.Menu(self.master) - self.node_context.add_command(label="One") - self.node_context.add_command(label="Two") - self.node_context.add_command(label="Three") - - def setup_bindings(self): + def draw_existing_node(self): """ - Bind any mouse events or hot keys to the matching action + Draw existing node while updating the grpc manager based on that :return: nothing """ - self.bind("", self.click_press) - self.bind("", self.click_release) - self.bind("", self.click_motion) - self.bind("", self.context) - # self.bind("e", self.set_mode) - # self.bind("s", self.set_mode) - # self.bind("n", self.set_mode) + session_id = self.core_grpc.session_id + response = self.core_grpc.core.get_session(session_id) + nodes = response.session.nodes + if len(nodes) > 0: + for node in nodes: + image = Images.convert_type_and_model_to_image(node.type, node.model) + return image + # n = CanvasNode(node.position.x, node.position.y, image, self, node.id) def canvas_xy(self, event): """ @@ -172,6 +182,10 @@ class CanvasGraph(tk.Canvas): node_dst = self.nodes[edge.dst] node_dst.edges.add(edge) + self.grpc_manager.add_edge( + self.core_grpc.get_session_id(), edge.token, node_src.id, node_dst.id + ) + logging.debug(f"edges: {self.find_withtag('edge')}") def click_press(self, event): @@ -207,40 +221,14 @@ class CanvasGraph(tk.Canvas): logging.debug(f"node context: {selected}") self.node_context.post(event.x_root, event.y_root) - # def set_mode(self, event): - # """ - # Set canvas mode according to the hot key that has been pressed - # - # :param event: key event - # :return: nothing - # """ - # logging.debug(f"mode event: {event}") - # if event.char == "e": - # self.mode = GraphMode.EDGE - # elif event.char == "s": - # self.mode = GraphMode.SELECT - # elif event.char == "n": - # self.mode = GraphMode.NODE - # logging.debug(f"graph mode: {self.mode}") - - # def add_node(self, x, y, image_name): - # image = Images.get(image_name) - # node = CanvasNode(x, y, image, self) - # self.nodes[node.id] = node - # return node - def add_node(self, x, y, image, node_name): - core_session_id = self.core_grpc.get_session_id() - core_node_id = self.core_grpc.add_node(int(x), int(y), node_name) node = CanvasNode( - core_session_id=core_session_id, - core_node_id=core_node_id, - x=x, - y=y, - image=image, - canvas=self, + x=x, y=y, image=image, canvas=self, core_id=self.grpc_manager.peek_id() ) self.nodes[node.id] = node + self.grpc_manager.add_node( + self.core_grpc.get_session_id(), node.id, x, y, node_name + ) return node @@ -283,17 +271,16 @@ class CanvasEdge: class CanvasNode: - def __init__(self, core_session_id, core_node_id, x, y, image, canvas): + def __init__(self, x, y, image, canvas, core_id): self.image = image self.canvas = canvas self.id = self.canvas.create_image( x, y, anchor=tk.CENTER, image=self.image, tags="node" ) + self.core_id = core_id self.x_coord = x self.y_coord = y - self.core_session_id = core_session_id - self.core_node_id = core_node_id - self.name = f"Node {self.core_node_id}" + self.name = f"Node {self.core_id}" self.text_id = self.canvas.create_text(x, y + 20, text=self.name) self.canvas.tag_bind(self.id, "", self.click_press) self.canvas.tag_bind(self.id, "", self.click_release) @@ -315,12 +302,6 @@ class CanvasNode: def click_release(self, event): logging.debug(f"click release {self.name}: {event}") self.update_coords() - self.canvas.core_grpc.edit_node( - self.core_session_id, - self.core_node_id, - int(self.x_coord), - int(self.y_coord), - ) self.moving = None def motion(self, event): diff --git a/coretk/coretk/grpcmanagement.py b/coretk/coretk/grpcmanagement.py new file mode 100644 index 00000000..d090f6d6 --- /dev/null +++ b/coretk/coretk/grpcmanagement.py @@ -0,0 +1,157 @@ +""" +Manage useful informations about the nodes, edges and configuration +that can be useful for grpc, acts like a session class +""" +import logging + +from core.api.grpc import core_pb2 + +link_layer_nodes = ["switch", "hub", "wlan", "rj45", "tunnel"] +network_layer_nodes = ["router", "host", "PC", "mdr", "prouter", "OVS"] + + +class Node: + def __init__(self, session_id, node_id, type, model, x, y, name): + """ + Create an instance of a node + + :param int session_id: session id + :param int node_id: node id + :param core_pb2.NodeType type: node type + :param int x: x coordinate + :param int y: coordinate + """ + self.session_id = session_id + self.node_id = node_id + self.type = type + self.x = x + self.y = y + self.model = model + self.name = name + + +class Edge: + def __init__(self, session_id, node_id_1, node_type_1, node_id_2, node_type_2): + """ + Create an instance of an edge + :param int session_id: session id + :param int node_id_1: node 1 id + :param int node_type_1: node 1 type + :param core_pb2.NodeType node_id_2: node 2 id + :param core_pb2.NodeType node_type_2: node 2 type + """ + self.session_id = session_id + self.id1 = node_id_1 + self.id2 = node_id_2 + self.type1 = node_type_1 + self.type2 = node_type_2 + + +class GrpcManager: + def __init__(self): + self.nodes = {} + self.edges = {} + self.id = 1 + # A list of id for re-use, keep in increasing order + self.reusable = [] + self.nodes_to_create = {} + self.edges_to_create = {} + + def peek_id(self): + """ + Peek the next id to be used + + :return: nothing + """ + if len(self.reusable) == 0: + return self.id + else: + return self.reusable[0] + + def get_id(self): + """ + Get the next node id as well as update id status and reusable ids + + :rtype: int + :return: the next id to be used + """ + if len(self.reusable) == 0: + new_id = self.id + self.id = self.id + 1 + return new_id + else: + return self.reusable.pop(0) + + # TODO figure out the name of ovs node + def add_node(self, session_id, canvas_id, x, y, name): + """ + Add node, with information filled in, to grpc manager + + :param int session_id: session id + :param int canvas_id: node's canvas id + :param int x: x coord + :param int y: y coord + :param str name: node type + :return: nothing + """ + node_type = None + node_model = None + if name in link_layer_nodes: + if name == "switch": + node_type = core_pb2.NodeType.SWITCH + elif name == "hub": + node_type = core_pb2.NodeType.HUB + elif name == "wlan": + node_type = core_pb2.NodeType.WIRELESS_LAN + elif name == "rj45": + node_type = core_pb2.NodeType.RJ45 + elif name == "tunnel": + node_type = core_pb2.NodeType.TUNNEL + elif name in network_layer_nodes: + node_type = core_pb2.NodeType.DEFAULT + # TODO what is the model name for ovs + node_model = name + else: + logging.error("grpcmanagemeny.py INVALID node name") + create_node = Node(session_id, self.get_id(), node_type, node_model, x, y, name) + self.nodes[canvas_id] = create_node + self.nodes_to_create[canvas_id] = create_node + logging.debug( + "Adding node to GrpcManager.. Session id: %s, Coords: (%s, %s), Name: %s", + session_id, + x, + y, + name, + ) + + def add_preexisting_node(self): + return + + def delete_node(self, canvas_id): + """ + Delete a node from the session + + :param int canvas_id: node's id in the canvas + :return: thing + """ + try: + self.nodes.pop(canvas_id) + self.reuseable.append(canvas_id) + self.reuseable.sort() + except KeyError: + logging.error("grpcmanagement.py INVALID NODE CANVAS ID") + + def add_edge(self, session_id, token, canvas_id_1, canvas_id_2): + if canvas_id_1 in self.nodes and canvas_id_2 in self.nodes: + edge = Edge( + session_id, + self.nodes[canvas_id_1].node_id, + self.nodes[canvas_id_1].type, + self.nodes[canvas_id_2].node_id, + self.nodes[canvas_id_2].type, + ) + self.edges[token] = edge + self.edges_to_create[token] = edge + logging.debug("Adding edge to grpc manager...") + else: + logging.error("grpcmanagement.py INVALID CANVAS NODE ID") diff --git a/coretk/coretk/images.py b/coretk/coretk/images.py index 71758cc2..4911efac 100644 --- a/coretk/coretk/images.py +++ b/coretk/coretk/images.py @@ -1,7 +1,10 @@ +import logging import os from PIL import Image, ImageTk +from core.api.grpc import core_pb2 + PATH = os.path.abspath(os.path.dirname(__file__)) @@ -19,6 +22,41 @@ class Images: def get(cls, name): return cls.images[name] + @classmethod + def convert_type_and_model_to_image(cls, node_type, node_model): + """ + Retrieve image based on type and model + :param core_pb2.NodeType node_type: core node type + :param string node_model: the node model + + :return: the matching image + """ + if node_type == core_pb2.NodeType.SWITCH: + return Images.get("switch") + if node_type == core_pb2.NodeType.HUB: + return Images.get("hub") + if node_type == core_pb2.NodeType.WIRELESS_LAN: + return Images.get("wlan") + if node_type == core_pb2.NodeType.RJ45: + return Images.get("rj45") + if node_type == core_pb2.NodeType.TUNNEL: + return Images.get("tunnel") + if node_type == core_pb2.NodeType.DEFAULT: + if node_model == "router": + return Images.get("router") + if node_model == "host": + return Images.get(("host")) + if node_model == "PC": + return Images.get("pc") + if node_model == "mdr": + return Images.get("mdr") + if node_model == "prouter": + return Images.get("prouter") + if node_model == "OVS": + return Images.get("ovs") + else: + logging.debug("INVALID INPUT OR NOT CONSIDERED YET") + def load_core_images(images): images.load("core", "core-icon.png")