cleaned up some of the logic for deleting nodes/edges

coretk/coretk/coreclient.py

@@ -469,13 +469,13 @@ class CoreClient:
         )
         return node
 
-    def delete_graph_nodes(self, node_ids, edge_tokens):
+    def delete_graph_nodes(self, node_ids, edges):
         """
         remove the nodes selected by the user and anything related to that node
         such as link, configurations, interfaces
 
         :param list[int] node_ids: list of nodes to delete
-        :param list edge_tokens: list of edges to delete
+        :param list edges: list of edges to delete
         :return: nothing
         """
         # delete the nodes
@@ -496,11 +496,11 @@ class CoreClient:
         self.reusable.sort()
 
         # delete the edges and interfaces
-        for i in edge_tokens:
+        for edge in edges:
             try:
-                self.links.pop(i)
+                self.links.pop(edge.token)
             except KeyError:
-                logging.error("invalid edge token: %s", i)
+                logging.error("invalid edge token: %s", edge.token)
 
     def create_interface(self, canvas_node):
         node = canvas_node.core_node

coretk/coretk/graph.py

@@ -388,30 +388,11 @@ class CanvasGraph(tk.Canvas):
         :param event:
         :return:
         """
-        # hide nodes, links, link information that shows on the GUI
-        to_delete_nodes, to_delete_edge_tokens = (
-            self.canvas_management.delete_selected_nodes()
-        )
+        # delete canvas data
+        node_ids, edges = self.canvas_management.delete_selected_nodes()
 
-        # delete nodes and link info stored in CanvasGraph object
-        node_ids = []
-        for nid in to_delete_nodes:
-            canvas_node = self.nodes.pop(nid)
-            node_ids.append(canvas_node.core_node.id)
-        for token in to_delete_edge_tokens:
-            self.edges.pop(token)
-
-        # delete the edge data inside of canvas node
-        canvas_node_link_to_delete = []
-        for canvas_id, node in self.nodes.items():
-            for e in node.edges:
-                if e.token in to_delete_edge_tokens:
-                    canvas_node_link_to_delete.append(tuple([canvas_id, e]))
-        for nid, edge in canvas_node_link_to_delete:
-            self.nodes[nid].edges.remove(edge)
-
-        # delete the related data from core
-        self.core.delete_graph_nodes(node_ids, to_delete_edge_tokens)
+        # delete core data
+        self.core.delete_graph_nodes(node_ids, edges)
 
     def add_node(self, x, y):
         plot_id = self.find_all()[0]

coretk/coretk/interface.py

@@ -33,6 +33,9 @@ class InterfaceManager:
             self.cidr = self.cidr.next()
         return self.cidr
 
+    def deleted_interface(self, interface):
+        logging.info("deleted interface: %s", interface)
+
     def determine_subnet(self, canvas_src_node, canvas_dst_node):
         src_node = canvas_src_node.core_node
         dst_node = canvas_dst_node.core_node

coretk/coretk/nodedelete.py

@@ -39,23 +39,30 @@ class CanvasComponentManagement:
         self.selected.clear()
 
     def delete_selected_nodes(self):
-        selected_nodes = list(self.selected.keys())
         edges = set()
-        for n in selected_nodes:
-            edges = edges.union(self.canvas.nodes[n].edges)
-        edge_canvas_ids = [x.id for x in edges]
-        edge_tokens = [x.token for x in edges]
-        link_infos = [x.link_info.id1 for x in edges] + [x.link_info.id2 for x in edges]
-
-        for i in edge_canvas_ids:
-            self.canvas.itemconfig(i, state="hidden")
-
-        for i in link_infos:
-            self.canvas.itemconfig(i, state="hidden")
-
-        for cnid, bbid in self.selected.items():
-            self.canvas.itemconfig(cnid, state="hidden")
-            self.canvas.itemconfig(bbid, state="hidden")
-            self.canvas.itemconfig(self.canvas.nodes[cnid].text_id, state="hidden")
+        node_ids = []
+        for node_id in list(self.selected):
+            bbox_id = self.selected[node_id]
+            canvas_node = self.canvas.nodes.pop(node_id)
+            node_ids.append(canvas_node.core_node.id)
+            self.canvas.delete(node_id)
+            self.canvas.delete(bbox_id)
+            self.canvas.delete(canvas_node.text_id)
+            for edge in canvas_node.edges:
+                if edge in edges:
+                    continue
+                edges.add(edge)
+                self.canvas.edges.pop(edge.token)
+                self.canvas.delete(edge.id)
+                self.canvas.delete(edge.link_info.id1)
+                self.canvas.delete(edge.link_info.id2)
+                other_id = edge.src
+                other_interface = edge.src_interface
+                if edge.src == node_id:
+                    other_id = edge.dst
+                    other_interface = edge.dst_interface
+                other_node = self.canvas.nodes[other_id]
+                other_node.edges.remove(edge)
+                other_node.interfaces.remove(other_interface)
         self.selected.clear()
-        return selected_nodes, edge_tokens
+        return node_ids, edges