afonso/core-extra
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

updated remove antenna logic to simplify, updated wireless edges to be objects

Browse source
This commit is contained in:
Blake Harnden 2019-11-27 15:40:54 -08:00
parent 3c7bf57b5c
commit 693d7beeb7
4 changed files with 69 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
coretk/coretk/coreclient.py
View file

@ -121,13 +121,12 @@ class CoreClient:
def handle_events(self, event):
if event.HasField("link_event"):
logging.info("link event: %s", event)
self.app.canvas.wireless_draw.handle_link_event(event.link_event)
self.handle_link_event(event.link_event)
elif event.HasField("session_event"):
logging.info("session event: %s", event)
session_event = event.session_event
if session_event.event <= core_pb2.SessionState.SHUTDOWN:
self.state = event.session_event.event
# mobility start
elif session_event.event in {7, 8, 9}:
node_id = session_event.node_id
dialog = self.mobility_players.get(node_id)
@ -145,6 +144,19 @@ class CoreClient:
else:
logging.info("unhandled event: %s", event)
def handle_link_event(self, event):
node_one_id = event.link.node_one_id
node_two_id = event.link.node_two_id
canvas_node_one = self.canvas_nodes[node_one_id]
canvas_node_two = self.canvas_nodes[node_two_id]
if event.message_type == core_pb2.MessageType.ADD:
self.app.canvas.add_wireless_edge(canvas_node_one, canvas_node_two)
elif event.message_type == core_pb2.MessageType.DELETE:
self.app.canvas.delete_wireless_edge(canvas_node_one, canvas_node_two)
else:
logging.warning("unknown link event: %s", event.message_type)
def handle_node_event(self, event):
if event.source == "gui":
return

51
coretk/coretk/graph.py
View file

@ -17,7 +17,6 @@ from coretk.images import Images
from coretk.linkinfo import LinkInfo, Throughput
from coretk.nodedelete import CanvasComponentManagement
from coretk.nodeutils import NodeUtils
from coretk.wirelessconnection import WirelessConnection
NODE_TEXT_OFFSET = 5
@ -50,6 +49,7 @@ class CanvasGraph(tk.Canvas):
self.context = None
self.nodes = {}
self.edges = {}
self.wireless_edges = {}
self.drawing_edge = None
self.grid = None
self.canvas_management = CanvasComponentManagement(self, core)
@ -58,7 +58,6 @@ class CanvasGraph(tk.Canvas):
self.core = core
self.helper = GraphHelper(self, core)
self.throughput_draw = Throughput(self, core)
self.wireless_draw = WirelessConnection(self, core)
# background related
self.wallpaper_id = None
@ -120,8 +119,8 @@ class CanvasGraph(tk.Canvas):
self.selected = None
self.nodes.clear()
self.edges.clear()
self.wireless_edges.clear()
self.drawing_edge = None
self.wireless_draw.map.clear()
self.draw_session(session)
def setup_bindings(self):
@ -162,6 +161,25 @@ class CanvasGraph(tk.Canvas):
self.tag_lower("gridline")
self.tag_lower(self.grid)
def add_wireless_edge(self, src, dst):
token = tuple(sorted((src.id, dst.id)))
x1, y1 = self.coords(src.id)
x2, y2 = self.coords(dst.id)
position = (x1, y1, x2, y2)
edge = CanvasWirelessEdge(token, position, src.id, dst.id, self)
self.wireless_edges[token] = edge
src.wireless_edges.add(edge)
dst.wireless_edges.add(edge)
self.tag_raise(src.id)
self.tag_raise(dst.id)
def delete_wireless_edge(self, src, dst):
token = tuple(sorted((src.id, dst.id)))
edge = self.wireless_edges.pop(token)
edge.delete()
src.wireless_edges.remove(edge)
dst.wireless_edges.remove(edge)
def draw_session(self, session):
"""
Draw existing session.
@ -187,7 +205,7 @@ class CanvasGraph(tk.Canvas):
canvas_node_two = self.core.canvas_nodes[link.node_two_id]
node_two = canvas_node_two.core_node
if link.type == core_pb2.LinkType.WIRELESS:
self.wireless_draw.add_connection(link.node_one_id, link.node_two_id)
self.add_wireless_edge(canvas_node_one, canvas_node_two)
else:
is_node_one_wireless = NodeUtils.is_wireless_node(node_one.type)
is_node_two_wireless = NodeUtils.is_wireless_node(node_two.type)
@ -492,6 +510,20 @@ class CanvasGraph(tk.Canvas):
self.itemconfig("gridline", state=tk.HIDDEN)
class CanvasWirelessEdge:
def __init__(self, token, position, src, dst, canvas):
self.token = token
self.src = src
self.dst = dst
self.canvas = canvas
self.id = self.canvas.create_line(
*position, tags="wireless", width=1.5, fill="#009933"
)
def delete(self):
self.canvas.delete(self.id)
class CanvasEdge:
"""
Canvas edge class
@ -580,7 +612,7 @@ class CanvasNode:
self.canvas.tag_bind(self.id, "<Leave>", self.on_leave)
self.edges = set()
self.interfaces = []
self.wlans = []
self.wireless_edges = set()
self.moving = None
def redraw(self):
@ -605,7 +637,14 @@ class CanvasNode:
else:
self.canvas.coords(edge.id, x1, y1, x, y)
edge.link_info.recalculate_info()
self.canvas.helper.update_wlan_connection(old_x, old_y, x, y, self.wlans)
for edge in self.wireless_edges:
x1, y1, x2, y2 = self.canvas.coords(edge.id)
if edge.src == self.id:
self.canvas.coords(edge.id, x, y, x2, y2)
else:
self.canvas.coords(edge.id, x1, y1, x, y)
if self.app.core.is_runtime():
self.app.core.edit_node(self.core_node.id, int(x), int(y))
def on_enter(self, event):
if self.app.core.is_runtime() and self.app.core.observer:

53
coretk/coretk/nodedelete.py
View file

@ -1,7 +1,7 @@
"""
manage deletion
"""
from core.api.grpc import core_pb2
from coretk.nodeutils import NodeUtils
class CanvasComponentManagement:
@ -48,48 +48,6 @@ class CanvasComponentManagement:
edges = set()
nodes = []
node_to_wlink = {}
for link_tuple in self.canvas.wireless_draw.map:
nid_one, nid_two = link_tuple
if nid_one not in node_to_wlink:
node_to_wlink[nid_one] = []
if nid_two not in node_to_wlink:
node_to_wlink[nid_two] = []
node_to_wlink[nid_one].append(link_tuple)
node_to_wlink[nid_two].append(link_tuple)
# delete antennas and wireless links
for cnid in self.selected:
canvas_node = self.canvas.nodes[cnid]
if canvas_node.core_node.type != core_pb2.NodeType.WIRELESS_LAN:
canvas_node.antenna_draw.delete_antennas()
else:
for e in canvas_node.edges:
link_proto = self.app.links[e.token]
node_one_id, node_two_id = (
link_proto.node_one_id,
link_proto.node_two_id,
)
if node_one_id == canvas_node.core_node.id:
neighbor_id = node_two_id
else:
neighbor_id = node_one_id
neighbor = self.app.canvas_nodes[neighbor_id]
if neighbor.core_node.type != core_pb2.NodeType.WIRELESS_LAN:
neighbor.antenna_draw.delete_antenna()
for link_tuple in node_to_wlink.get(canvas_node.core_node.id, []):
nid_one, nid_two = link_tuple
if link_tuple in self.canvas.wireless_draw.map:
self.canvas.delete(self.canvas.wireless_draw.map[link_tuple])
link_cid = self.canvas.wireless_draw.map.pop(link_tuple, None)
canvas_node_one = self.app.canvas_nodes[nid_one]
canvas_node_two = self.app.canvas_nodes[nid_two]
if link_cid in canvas_node_one.wlans:
canvas_node_one.wlans.remove(link_cid)
if link_cid in canvas_node_two.wlans:
canvas_node_two.wlans.remove(link_cid)
for node_id in list(self.selected):
bbox_id = self.selected[node_id]
canvas_node = self.canvas.nodes.pop(node_id)
@ -97,6 +55,13 @@ class CanvasComponentManagement:
self.canvas.delete(node_id)
self.canvas.delete(bbox_id)
self.canvas.delete(canvas_node.text_id)
# delete antennas
is_wireless = NodeUtils.is_wireless_node(canvas_node.core_node.type)
if is_wireless:
canvas_node.antenna_draw.delete_antennas()
# delete related edges
for edge in canvas_node.edges:
if edge in edges:
continue
@ -116,5 +81,7 @@ class CanvasComponentManagement:
other_node.interfaces.remove(other_interface)
except ValueError:
pass
if is_wireless:
other_node.antenna_draw.delete_antenna()
self.selected.clear()
return nodes

51
coretk/coretk/wirelessconnection.py
View file

@ -1,51 +0,0 @@
"""
Wireless connection handler
"""
from core.api.grpc import core_pb2
class WirelessConnection:
def __init__(self, canvas, core):
self.canvas = canvas
self.core = core
# map a (node_one_id, node_two_id) to a wlan canvas id
self.map = {}
def add_connection(self, node_one_id, node_two_id):
canvas_node_one = self.core.canvas_nodes[node_one_id]
canvas_node_two = self.core.canvas_nodes[node_two_id]
key = tuple(sorted((node_one_id, node_two_id)))
if key not in self.map:
x1, y1 = self.canvas.coords(canvas_node_one.id)
x2, y2 = self.canvas.coords(canvas_node_two.id)
wlan_canvas_id = self.canvas.create_line(
x1, y1, x2, y2, fill="#009933", tags="wireless", width=1.5
)
self.map[key] = wlan_canvas_id
canvas_node_one.wlans.append(wlan_canvas_id)
canvas_node_two.wlans.append(wlan_canvas_id)
else:
print("in map")
self.canvas.itemconfig(self.map[key], state="normal")
def delete_connection(self, node_one_id, node_two_id):
canvas_node_one = self.core.canvas_nodes[node_one_id]
canvas_node_two = self.core.canvas_nodes[node_two_id]
key = tuple(sorted((node_one_id, node_two_id)))
wlan_canvas_id = self.map[key]
canvas_node_one.wlans.remove(wlan_canvas_id)
canvas_node_two.wlans.remove(wlan_canvas_id)
self.canvas.delete(wlan_canvas_id)
self.map.pop(key, None)
def handle_link_event(self, link_event):
if link_event.message_type == core_pb2.MessageType.ADD:
self.add_connection(
link_event.link.node_one_id, link_event.link.node_two_id
)
self.canvas.tag_raise("node")
if link_event.message_type == core_pb2.MessageType.DELETE:
self.delete_connection(
link_event.link.node_one_id, link_event.link.node_two_id
)