initial sweeping changes to call all usages of various interface related variables and functions (netif, interface, if, ifc, etc) to use a consistent name iface
This commit is contained in:
Blake Harnden
parent
0462c1b084
commit
0725199d6d
93 changed files with 1955 additions and 2156 deletions
|
|
@ -57,8 +57,8 @@ class CoreClient:
|
|||
self.read_config()
|
||||
|
||||
# helpers
|
||||
self.interface_to_edge = {}
|
||||
self.interfaces_manager = InterfaceManager(self.app)
|
||||
self.iface_to_edge = {}
|
||||
self.ifaces_manager = InterfaceManager(self.app)
|
||||
|
||||
# session data
|
||||
self.state = None
|
||||
|
|
@ -91,8 +91,8 @@ class CoreClient:
|
|||
|
||||
def reset(self):
|
||||
# helpers
|
||||
self.interfaces_manager.reset()
|
||||
self.interface_to_edge.clear()
|
||||
self.ifaces_manager.reset()
|
||||
self.iface_to_edge.clear()
|
||||
# session data
|
||||
self.canvas_nodes.clear()
|
||||
self.links.clear()
|
||||
|
|
@ -263,7 +263,7 @@ class CoreClient:
|
|||
self.emane_config = response.config
|
||||
|
||||
# update interface manager
|
||||
self.interfaces_manager.joined(session.links)
|
||||
self.ifaces_manager.joined(session.links)
|
||||
|
||||
# draw session
|
||||
self.app.canvas.reset_and_redraw(session)
|
||||
|
|
@ -278,11 +278,11 @@ class CoreClient:
|
|||
# get emane model config
|
||||
response = self.client.get_emane_model_configs(self.session_id)
|
||||
for config in response.configs:
|
||||
interface = None
|
||||
if config.interface != -1:
|
||||
interface = config.interface
|
||||
iface_id = None
|
||||
if config.iface_id != -1:
|
||||
iface_id = config.iface_id
|
||||
canvas_node = self.canvas_nodes[config.node_id]
|
||||
canvas_node.emane_model_configs[(config.model, interface)] = dict(
|
||||
canvas_node.emane_model_configs[(config.model, iface_id)] = dict(
|
||||
config.config
|
||||
)
|
||||
|
||||
|
|
@ -460,16 +460,16 @@ class CoreClient:
|
|||
self.app.show_grpc_exception("Edit Node Error", e)
|
||||
|
||||
def start_session(self) -> core_pb2.StartSessionResponse:
|
||||
self.interfaces_manager.reset_mac()
|
||||
self.ifaces_manager.reset_mac()
|
||||
nodes = [x.core_node for x in self.canvas_nodes.values()]
|
||||
links = []
|
||||
for edge in self.links.values():
|
||||
link = core_pb2.Link()
|
||||
link.CopyFrom(edge.link)
|
||||
if link.HasField("interface1") and not link.interface1.mac:
|
||||
link.interface1.mac = self.interfaces_manager.next_mac()
|
||||
if link.HasField("interface2") and not link.interface2.mac:
|
||||
link.interface2.mac = self.interfaces_manager.next_mac()
|
||||
if link.HasField("iface1") and not link.iface1.mac:
|
||||
link.iface1.mac = self.ifaces_manager.next_mac()
|
||||
if link.HasField("iface2") and not link.iface2.mac:
|
||||
link.iface2.mac = self.ifaces_manager.next_mac()
|
||||
links.append(link)
|
||||
wlan_configs = self.get_wlan_configs_proto()
|
||||
mobility_configs = self.get_mobility_configs_proto()
|
||||
|
|
@ -689,8 +689,8 @@ class CoreClient:
|
|||
self.session_id,
|
||||
link_proto.node1_id,
|
||||
link_proto.node2_id,
|
||||
link_proto.interface1,
|
||||
link_proto.interface2,
|
||||
link_proto.iface1,
|
||||
link_proto.iface2,
|
||||
link_proto.options,
|
||||
)
|
||||
logging.debug("create link: %s", response)
|
||||
|
|
@ -733,7 +733,7 @@ class CoreClient:
|
|||
config_proto.node_id,
|
||||
config_proto.model,
|
||||
config_proto.config,
|
||||
config_proto.interface_id,
|
||||
config_proto.iface_id,
|
||||
)
|
||||
if self.emane_config:
|
||||
config = {x: self.emane_config[x].value for x in self.emane_config}
|
||||
|
|
@ -824,31 +824,26 @@ class CoreClient:
|
|||
for edge in edges:
|
||||
del self.links[edge.token]
|
||||
links.append(edge.link)
|
||||
self.interfaces_manager.removed(links)
|
||||
self.ifaces_manager.removed(links)
|
||||
|
||||
def create_interface(self, canvas_node: CanvasNode) -> core_pb2.Interface:
|
||||
def create_iface(self, canvas_node: CanvasNode) -> core_pb2.Interface:
|
||||
node = canvas_node.core_node
|
||||
ip4, ip6 = self.interfaces_manager.get_ips(node)
|
||||
ip4_mask = self.interfaces_manager.ip4_mask
|
||||
ip6_mask = self.interfaces_manager.ip6_mask
|
||||
interface_id = canvas_node.next_interface_id()
|
||||
name = f"eth{interface_id}"
|
||||
interface = core_pb2.Interface(
|
||||
id=interface_id,
|
||||
name=name,
|
||||
ip4=ip4,
|
||||
ip4mask=ip4_mask,
|
||||
ip6=ip6,
|
||||
ip6mask=ip6_mask,
|
||||
ip4, ip6 = self.ifaces_manager.get_ips(node)
|
||||
ip4_mask = self.ifaces_manager.ip4_mask
|
||||
ip6_mask = self.ifaces_manager.ip6_mask
|
||||
iface_id = canvas_node.next_iface_id()
|
||||
name = f"eth{iface_id}"
|
||||
iface = core_pb2.Interface(
|
||||
id=iface_id, name=name, ip4=ip4, ip4mask=ip4_mask, ip6=ip6, ip6mask=ip6_mask
|
||||
)
|
||||
logging.info(
|
||||
"create node(%s) interface(%s) IPv4(%s) IPv6(%s)",
|
||||
node.name,
|
||||
interface.name,
|
||||
interface.ip4,
|
||||
interface.ip6,
|
||||
iface.name,
|
||||
iface.ip4,
|
||||
iface.ip6,
|
||||
)
|
||||
return interface
|
||||
return iface
|
||||
|
||||
def create_link(
|
||||
self, edge: CanvasEdge, canvas_src_node: CanvasNode, canvas_dst_node: CanvasNode
|
||||
|
|
@ -861,34 +856,34 @@ class CoreClient:
|
|||
dst_node = canvas_dst_node.core_node
|
||||
|
||||
# determine subnet
|
||||
self.interfaces_manager.determine_subnets(canvas_src_node, canvas_dst_node)
|
||||
self.ifaces_manager.determine_subnets(canvas_src_node, canvas_dst_node)
|
||||
|
||||
src_interface = None
|
||||
src_iface = None
|
||||
if NodeUtils.is_container_node(src_node.type):
|
||||
src_interface = self.create_interface(canvas_src_node)
|
||||
self.interface_to_edge[(src_node.id, src_interface.id)] = edge.token
|
||||
src_iface = self.create_iface(canvas_src_node)
|
||||
self.iface_to_edge[(src_node.id, src_iface.id)] = edge.token
|
||||
|
||||
dst_interface = None
|
||||
dst_iface = None
|
||||
if NodeUtils.is_container_node(dst_node.type):
|
||||
dst_interface = self.create_interface(canvas_dst_node)
|
||||
self.interface_to_edge[(dst_node.id, dst_interface.id)] = edge.token
|
||||
dst_iface = self.create_iface(canvas_dst_node)
|
||||
self.iface_to_edge[(dst_node.id, dst_iface.id)] = edge.token
|
||||
|
||||
link = core_pb2.Link(
|
||||
type=core_pb2.LinkType.WIRED,
|
||||
node1_id=src_node.id,
|
||||
node2_id=dst_node.id,
|
||||
interface1=src_interface,
|
||||
interface2=dst_interface,
|
||||
iface1=src_iface,
|
||||
iface2=dst_iface,
|
||||
)
|
||||
# assign after creating link proto, since interfaces are copied
|
||||
if src_interface:
|
||||
interface1 = link.interface1
|
||||
edge.src_interface = interface1
|
||||
canvas_src_node.interfaces[interface1.id] = interface1
|
||||
if dst_interface:
|
||||
interface2 = link.interface2
|
||||
edge.dst_interface = interface2
|
||||
canvas_dst_node.interfaces[interface2.id] = interface2
|
||||
if src_iface:
|
||||
iface1 = link.iface1
|
||||
edge.src_iface = iface1
|
||||
canvas_src_node.ifaces[iface1.id] = iface1
|
||||
if dst_iface:
|
||||
iface2 = link.iface2
|
||||
edge.dst_iface = iface2
|
||||
canvas_dst_node.ifaces[iface2.id] = iface2
|
||||
edge.set_link(link)
|
||||
self.links[edge.token] = edge
|
||||
logging.info("Add link between %s and %s", src_node.name, dst_node.name)
|
||||
|
|
@ -928,12 +923,12 @@ class CoreClient:
|
|||
continue
|
||||
node_id = canvas_node.core_node.id
|
||||
for key, config in canvas_node.emane_model_configs.items():
|
||||
model, interface = key
|
||||
model, iface_id = key
|
||||
config = {x: config[x].value for x in config}
|
||||
if interface is None:
|
||||
interface = -1
|
||||
if iface_id is None:
|
||||
iface_id = -1
|
||||
config_proto = EmaneModelConfig(
|
||||
node_id=node_id, interface_id=interface, model=model, config=config
|
||||
node_id=node_id, iface_id=iface_id, model=model, config=config
|
||||
)
|
||||
configs.append(config_proto)
|
||||
return configs
|
||||
|
|
@ -1021,19 +1016,19 @@ class CoreClient:
|
|||
return dict(config)
|
||||
|
||||
def get_emane_model_config(
|
||||
self, node_id: int, model: str, interface: int = None
|
||||
self, node_id: int, model: str, iface_id: int = None
|
||||
) -> Dict[str, common_pb2.ConfigOption]:
|
||||
if interface is None:
|
||||
interface = -1
|
||||
if iface_id is None:
|
||||
iface_id = -1
|
||||
response = self.client.get_emane_model_config(
|
||||
self.session_id, node_id, model, interface
|
||||
self.session_id, node_id, model, iface_id
|
||||
)
|
||||
config = response.config
|
||||
logging.debug(
|
||||
"get emane model config: node id: %s, EMANE model: %s, interface: %s, config: %s",
|
||||
node_id,
|
||||
model,
|
||||
interface,
|
||||
iface_id,
|
||||
config,
|
||||
)
|
||||
return dict(config)
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ class EmaneModelDialog(Dialog):
|
|||
app: "Application",
|
||||
canvas_node: "CanvasNode",
|
||||
model: str,
|
||||
interface: int = None,
|
||||
iface_id: int = None,
|
||||
):
|
||||
super().__init__(
|
||||
app, f"{canvas_node.core_node.name} {model} Configuration", master=master
|
||||
|
|
@ -64,16 +64,16 @@ class EmaneModelDialog(Dialog):
|
|||
self.canvas_node = canvas_node
|
||||
self.node = canvas_node.core_node
|
||||
self.model = f"emane_{model}"
|
||||
self.interface = interface
|
||||
self.iface_id = iface_id
|
||||
self.config_frame = None
|
||||
self.has_error = False
|
||||
try:
|
||||
self.config = self.canvas_node.emane_model_configs.get(
|
||||
(self.model, self.interface)
|
||||
(self.model, self.iface_id)
|
||||
)
|
||||
if not self.config:
|
||||
self.config = self.app.core.get_emane_model_config(
|
||||
self.node.id, self.model, self.interface
|
||||
self.node.id, self.model, self.iface_id
|
||||
)
|
||||
self.draw()
|
||||
except grpc.RpcError as e:
|
||||
|
|
@ -103,7 +103,7 @@ class EmaneModelDialog(Dialog):
|
|||
|
||||
def click_apply(self):
|
||||
self.config_frame.parse_config()
|
||||
key = (self.model, self.interface)
|
||||
key = (self.model, self.iface_id)
|
||||
self.canvas_node.emane_model_configs[key] = self.config
|
||||
self.destroy()
|
||||
|
||||
|
|
|
|||
|
|
@ -146,6 +146,6 @@ class IpConfigDialog(Dialog):
|
|||
ip_config.ip6 = self.ip6
|
||||
ip_config.ip4s = ip4s
|
||||
ip_config.ip6s = ip6s
|
||||
self.app.core.interfaces_manager.update_ips(self.ip4, self.ip6)
|
||||
self.app.core.ifaces_manager.update_ips(self.ip4, self.ip6)
|
||||
self.app.save_config()
|
||||
self.destroy()
|
||||
|
|
|
|||
|
|
@ -227,21 +227,21 @@ class LinkConfigurationDialog(Dialog):
|
|||
)
|
||||
link.options.CopyFrom(options)
|
||||
|
||||
interface1_id = None
|
||||
if link.HasField("interface1"):
|
||||
interface1_id = link.interface1.id
|
||||
interface2_id = None
|
||||
if link.HasField("interface2"):
|
||||
interface2_id = link.interface2.id
|
||||
iface1_id = None
|
||||
if link.HasField("iface1"):
|
||||
iface1_id = link.iface1.id
|
||||
iface2_id = None
|
||||
if link.HasField("iface2"):
|
||||
iface2_id = link.iface2.id
|
||||
|
||||
if not self.is_symmetric:
|
||||
link.options.unidirectional = True
|
||||
asym_interface1 = None
|
||||
if interface1_id:
|
||||
asym_interface1 = core_pb2.Interface(id=interface1_id)
|
||||
asym_interface2 = None
|
||||
if interface2_id:
|
||||
asym_interface2 = core_pb2.Interface(id=interface2_id)
|
||||
asym_iface1 = None
|
||||
if iface1_id:
|
||||
asym_iface1 = core_pb2.Interface(id=iface1_id)
|
||||
asym_iface2 = None
|
||||
if iface2_id:
|
||||
asym_iface2 = core_pb2.Interface(id=iface2_id)
|
||||
down_bandwidth = get_int(self.down_bandwidth)
|
||||
down_jitter = get_int(self.down_jitter)
|
||||
down_delay = get_int(self.down_delay)
|
||||
|
|
@ -258,8 +258,8 @@ class LinkConfigurationDialog(Dialog):
|
|||
self.edge.asymmetric_link = core_pb2.Link(
|
||||
node1_id=link.node2_id,
|
||||
node2_id=link.node1_id,
|
||||
interface1=asym_interface1,
|
||||
interface2=asym_interface2,
|
||||
iface1=asym_iface1,
|
||||
iface2=asym_iface2,
|
||||
options=options,
|
||||
)
|
||||
else:
|
||||
|
|
@ -273,8 +273,8 @@ class LinkConfigurationDialog(Dialog):
|
|||
link.node1_id,
|
||||
link.node2_id,
|
||||
link.options,
|
||||
interface1_id,
|
||||
interface2_id,
|
||||
iface1_id,
|
||||
iface2_id,
|
||||
)
|
||||
if self.edge.asymmetric_link:
|
||||
self.app.core.client.edit_link(
|
||||
|
|
@ -282,8 +282,8 @@ class LinkConfigurationDialog(Dialog):
|
|||
link.node2_id,
|
||||
link.node1_id,
|
||||
self.edge.asymmetric_link.options,
|
||||
interface1_id,
|
||||
interface2_id,
|
||||
iface1_id,
|
||||
iface2_id,
|
||||
)
|
||||
|
||||
self.destroy()
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ class MacConfigDialog(Dialog):
|
|||
if not netaddr.valid_mac(mac):
|
||||
messagebox.showerror("MAC Error", f"{mac} is an invalid mac")
|
||||
else:
|
||||
self.app.core.interfaces_manager.mac = netaddr.EUI(mac)
|
||||
self.app.core.ifaces_manager.mac = netaddr.EUI(mac)
|
||||
self.app.guiconfig.mac = mac
|
||||
self.app.save_config()
|
||||
self.destroy()
|
||||
|
|
|
|||
|
|
@ -111,7 +111,7 @@ class NodeConfigDialog(Dialog):
|
|||
if self.node.server:
|
||||
server = self.node.server
|
||||
self.server = tk.StringVar(value=server)
|
||||
self.interfaces = {}
|
||||
self.ifaces = {}
|
||||
self.draw()
|
||||
|
||||
def draw(self):
|
||||
|
|
@ -183,53 +183,53 @@ class NodeConfigDialog(Dialog):
|
|||
row += 1
|
||||
|
||||
if NodeUtils.is_rj45_node(self.node.type):
|
||||
response = self.app.core.client.get_interfaces()
|
||||
response = self.app.core.client.get_ifaces()
|
||||
logging.debug("host machine available interfaces: %s", response)
|
||||
interfaces = ListboxScroll(frame)
|
||||
interfaces.listbox.config(state=state)
|
||||
interfaces.grid(
|
||||
ifaces = ListboxScroll(frame)
|
||||
ifaces.listbox.config(state=state)
|
||||
ifaces.grid(
|
||||
row=row, column=0, columnspan=2, sticky="ew", padx=PADX, pady=PADY
|
||||
)
|
||||
for inf in sorted(response.interfaces[:]):
|
||||
interfaces.listbox.insert(tk.END, inf)
|
||||
for inf in sorted(response.ifaces[:]):
|
||||
ifaces.listbox.insert(tk.END, inf)
|
||||
row += 1
|
||||
interfaces.listbox.bind("<<ListboxSelect>>", self.interface_select)
|
||||
ifaces.listbox.bind("<<ListboxSelect>>", self.iface_select)
|
||||
|
||||
# interfaces
|
||||
if self.canvas_node.interfaces:
|
||||
self.draw_interfaces()
|
||||
if self.canvas_node.ifaces:
|
||||
self.draw_ifaces()
|
||||
|
||||
self.draw_spacer()
|
||||
self.draw_buttons()
|
||||
|
||||
def draw_interfaces(self):
|
||||
def draw_ifaces(self):
|
||||
notebook = ttk.Notebook(self.top)
|
||||
notebook.grid(sticky="nsew", pady=PADY)
|
||||
self.top.rowconfigure(notebook.grid_info()["row"], weight=1)
|
||||
state = tk.DISABLED if self.app.core.is_runtime() else tk.NORMAL
|
||||
for interface_id in sorted(self.canvas_node.interfaces):
|
||||
interface = self.canvas_node.interfaces[interface_id]
|
||||
for iface_id in sorted(self.canvas_node.ifaces):
|
||||
iface = self.canvas_node.ifaces[iface_id]
|
||||
tab = ttk.Frame(notebook, padding=FRAME_PAD)
|
||||
tab.grid(sticky="nsew", pady=PADY)
|
||||
tab.columnconfigure(1, weight=1)
|
||||
tab.columnconfigure(2, weight=1)
|
||||
notebook.add(tab, text=interface.name)
|
||||
notebook.add(tab, text=iface.name)
|
||||
|
||||
row = 0
|
||||
emane_node = self.canvas_node.has_emane_link(interface.id)
|
||||
emane_node = self.canvas_node.has_emane_link(iface.id)
|
||||
if emane_node:
|
||||
emane_model = emane_node.emane.split("_")[1]
|
||||
button = ttk.Button(
|
||||
tab,
|
||||
text=f"Configure EMANE {emane_model}",
|
||||
command=lambda: self.click_emane_config(emane_model, interface.id),
|
||||
command=lambda: self.click_emane_config(emane_model, iface.id),
|
||||
)
|
||||
button.grid(row=row, sticky="ew", columnspan=3, pady=PADY)
|
||||
row += 1
|
||||
|
||||
label = ttk.Label(tab, text="MAC")
|
||||
label.grid(row=row, column=0, padx=PADX, pady=PADY)
|
||||
auto_set = not interface.mac
|
||||
auto_set = not iface.mac
|
||||
mac_state = tk.DISABLED if auto_set else tk.NORMAL
|
||||
is_auto = tk.BooleanVar(value=auto_set)
|
||||
checkbutton = ttk.Checkbutton(
|
||||
|
|
@ -237,7 +237,7 @@ class NodeConfigDialog(Dialog):
|
|||
)
|
||||
checkbutton.var = is_auto
|
||||
checkbutton.grid(row=row, column=1, padx=PADX)
|
||||
mac = tk.StringVar(value=interface.mac)
|
||||
mac = tk.StringVar(value=iface.mac)
|
||||
entry = ttk.Entry(tab, textvariable=mac, state=mac_state)
|
||||
entry.grid(row=row, column=2, sticky="ew")
|
||||
func = partial(mac_auto, is_auto, entry, mac)
|
||||
|
|
@ -247,8 +247,8 @@ class NodeConfigDialog(Dialog):
|
|||
label = ttk.Label(tab, text="IPv4")
|
||||
label.grid(row=row, column=0, padx=PADX, pady=PADY)
|
||||
ip4_net = ""
|
||||
if interface.ip4:
|
||||
ip4_net = f"{interface.ip4}/{interface.ip4mask}"
|
||||
if iface.ip4:
|
||||
ip4_net = f"{iface.ip4}/{iface.ip4mask}"
|
||||
ip4 = tk.StringVar(value=ip4_net)
|
||||
entry = ttk.Entry(tab, textvariable=ip4, state=state)
|
||||
entry.grid(row=row, column=1, columnspan=2, sticky="ew")
|
||||
|
|
@ -257,13 +257,13 @@ class NodeConfigDialog(Dialog):
|
|||
label = ttk.Label(tab, text="IPv6")
|
||||
label.grid(row=row, column=0, padx=PADX, pady=PADY)
|
||||
ip6_net = ""
|
||||
if interface.ip6:
|
||||
ip6_net = f"{interface.ip6}/{interface.ip6mask}"
|
||||
if iface.ip6:
|
||||
ip6_net = f"{iface.ip6}/{iface.ip6mask}"
|
||||
ip6 = tk.StringVar(value=ip6_net)
|
||||
entry = ttk.Entry(tab, textvariable=ip6, state=state)
|
||||
entry.grid(row=row, column=1, columnspan=2, sticky="ew")
|
||||
|
||||
self.interfaces[interface.id] = InterfaceData(is_auto, mac, ip4, ip6)
|
||||
self.ifaces[iface.id] = InterfaceData(is_auto, mac, ip4, ip6)
|
||||
|
||||
def draw_buttons(self):
|
||||
frame = ttk.Frame(self.top)
|
||||
|
|
@ -277,9 +277,9 @@ class NodeConfigDialog(Dialog):
|
|||
button = ttk.Button(frame, text="Cancel", command=self.destroy)
|
||||
button.grid(row=0, column=1, sticky="ew")
|
||||
|
||||
def click_emane_config(self, emane_model: str, interface_id: int):
|
||||
def click_emane_config(self, emane_model: str, iface_id: int):
|
||||
dialog = EmaneModelDialog(
|
||||
self, self.app, self.canvas_node, emane_model, interface_id
|
||||
self, self.app, self.canvas_node, emane_model, iface_id
|
||||
)
|
||||
dialog.show()
|
||||
|
||||
|
|
@ -309,12 +309,12 @@ class NodeConfigDialog(Dialog):
|
|||
self.canvas_node.image = self.image
|
||||
|
||||
# update node interface data
|
||||
for interface in self.canvas_node.interfaces.values():
|
||||
data = self.interfaces[interface.id]
|
||||
for iface in self.canvas_node.ifaces.values():
|
||||
data = self.ifaces[iface.id]
|
||||
|
||||
# validate ip4
|
||||
ip4_net = data.ip4.get()
|
||||
if not check_ip4(self, interface.name, ip4_net):
|
||||
if not check_ip4(self, iface.name, ip4_net):
|
||||
error = True
|
||||
break
|
||||
if ip4_net:
|
||||
|
|
@ -322,12 +322,12 @@ class NodeConfigDialog(Dialog):
|
|||
ip4mask = int(ip4mask)
|
||||
else:
|
||||
ip4, ip4mask = "", 0
|
||||
interface.ip4 = ip4
|
||||
interface.ip4mask = ip4mask
|
||||
iface.ip4 = ip4
|
||||
iface.ip4mask = ip4mask
|
||||
|
||||
# validate ip6
|
||||
ip6_net = data.ip6.get()
|
||||
if not check_ip6(self, interface.name, ip6_net):
|
||||
if not check_ip6(self, iface.name, ip6_net):
|
||||
error = True
|
||||
break
|
||||
if ip6_net:
|
||||
|
|
@ -335,28 +335,28 @@ class NodeConfigDialog(Dialog):
|
|||
ip6mask = int(ip6mask)
|
||||
else:
|
||||
ip6, ip6mask = "", 0
|
||||
interface.ip6 = ip6
|
||||
interface.ip6mask = ip6mask
|
||||
iface.ip6 = ip6
|
||||
iface.ip6mask = ip6mask
|
||||
|
||||
mac = data.mac.get()
|
||||
auto_mac = data.is_auto.get()
|
||||
if not auto_mac and not netaddr.valid_mac(mac):
|
||||
title = f"MAC Error for {interface.name}"
|
||||
title = f"MAC Error for {iface.name}"
|
||||
messagebox.showerror(title, "Invalid MAC Address")
|
||||
error = True
|
||||
break
|
||||
elif not auto_mac:
|
||||
mac = netaddr.EUI(mac, dialect=netaddr.mac_unix_expanded)
|
||||
interface.mac = str(mac)
|
||||
iface.mac = str(mac)
|
||||
|
||||
# redraw
|
||||
if not error:
|
||||
self.canvas_node.redraw()
|
||||
self.destroy()
|
||||
|
||||
def interface_select(self, event: tk.Event):
|
||||
def iface_select(self, event: tk.Event):
|
||||
listbox = event.widget
|
||||
cur = listbox.curselection()
|
||||
if cur:
|
||||
interface = listbox.get(cur[0])
|
||||
self.name.set(interface)
|
||||
iface = listbox.get(cur[0])
|
||||
self.name.set(iface)
|
||||
|
|
|
|||
|
|
@ -259,8 +259,8 @@ class CanvasEdge(Edge):
|
|||
Create an instance of canvas edge object
|
||||
"""
|
||||
super().__init__(canvas, src)
|
||||
self.src_interface = None
|
||||
self.dst_interface = None
|
||||
self.src_iface = None
|
||||
self.dst_iface = None
|
||||
self.text_src = None
|
||||
self.text_dst = None
|
||||
self.link = None
|
||||
|
|
@ -283,25 +283,25 @@ class CanvasEdge(Edge):
|
|||
self.link = link
|
||||
self.draw_labels()
|
||||
|
||||
def interface_label(self, interface: core_pb2.Interface) -> str:
|
||||
def iface_label(self, iface: core_pb2.Interface) -> str:
|
||||
label = ""
|
||||
if interface.name and self.canvas.show_interface_names.get():
|
||||
label = f"{interface.name}"
|
||||
if interface.ip4 and self.canvas.show_ip4s.get():
|
||||
if iface.name and self.canvas.show_iface_names.get():
|
||||
label = f"{iface.name}"
|
||||
if iface.ip4 and self.canvas.show_ip4s.get():
|
||||
label = f"{label}\n" if label else ""
|
||||
label += f"{interface.ip4}/{interface.ip4mask}"
|
||||
if interface.ip6 and self.canvas.show_ip6s.get():
|
||||
label += f"{iface.ip4}/{iface.ip4mask}"
|
||||
if iface.ip6 and self.canvas.show_ip6s.get():
|
||||
label = f"{label}\n" if label else ""
|
||||
label += f"{interface.ip6}/{interface.ip6mask}"
|
||||
label += f"{iface.ip6}/{iface.ip6mask}"
|
||||
return label
|
||||
|
||||
def create_node_labels(self) -> Tuple[str, str]:
|
||||
label1 = None
|
||||
if self.link.HasField("interface1"):
|
||||
label1 = self.interface_label(self.link.interface1)
|
||||
if self.link.HasField("iface1"):
|
||||
label1 = self.iface_label(self.link.iface1)
|
||||
label2 = None
|
||||
if self.link.HasField("interface2"):
|
||||
label2 = self.interface_label(self.link.interface2)
|
||||
if self.link.HasField("iface2"):
|
||||
label2 = self.iface_label(self.link.iface2)
|
||||
return label1, label2
|
||||
|
||||
def draw_labels(self) -> None:
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ class CanvasGraph(tk.Canvas):
|
|||
self.show_link_labels = ShowVar(self, tags.LINK_LABEL, value=True)
|
||||
self.show_grid = ShowVar(self, tags.GRIDLINE, value=True)
|
||||
self.show_annotations = ShowVar(self, tags.ANNOTATION, value=True)
|
||||
self.show_interface_names = BooleanVar(value=False)
|
||||
self.show_iface_names = BooleanVar(value=False)
|
||||
self.show_ip4s = BooleanVar(value=True)
|
||||
self.show_ip6s = BooleanVar(value=True)
|
||||
|
||||
|
|
@ -136,7 +136,7 @@ class CanvasGraph(tk.Canvas):
|
|||
self.show_link_labels.set(True)
|
||||
self.show_grid.set(True)
|
||||
self.show_annotations.set(True)
|
||||
self.show_interface_names.set(False)
|
||||
self.show_iface_names.set(False)
|
||||
self.show_ip4s.set(True)
|
||||
self.show_ip6s.set(True)
|
||||
|
||||
|
|
@ -195,19 +195,19 @@ class CanvasGraph(tk.Canvas):
|
|||
return valid_topleft and valid_bottomright
|
||||
|
||||
def set_throughputs(self, throughputs_event: core_pb2.ThroughputsEvent):
|
||||
for interface_throughput in throughputs_event.interface_throughputs:
|
||||
node_id = interface_throughput.node_id
|
||||
interface_id = interface_throughput.interface_id
|
||||
throughput = interface_throughput.throughput
|
||||
interface_to_edge_id = (node_id, interface_id)
|
||||
token = self.core.interface_to_edge.get(interface_to_edge_id)
|
||||
for iface_throughput in throughputs_event.iface_throughputs:
|
||||
node_id = iface_throughput.node_id
|
||||
iface_id = iface_throughput.iface_id
|
||||
throughput = iface_throughput.throughput
|
||||
iface_to_edge_id = (node_id, iface_id)
|
||||
token = self.core.iface_to_edge.get(iface_to_edge_id)
|
||||
if not token:
|
||||
continue
|
||||
edge = self.edges.get(token)
|
||||
if edge:
|
||||
edge.set_throughput(throughput)
|
||||
else:
|
||||
del self.core.interface_to_edge[interface_to_edge_id]
|
||||
del self.core.iface_to_edge[iface_to_edge_id]
|
||||
|
||||
def draw_grid(self):
|
||||
"""
|
||||
|
|
@ -321,18 +321,16 @@ class CanvasGraph(tk.Canvas):
|
|||
canvas_node2.edges.add(edge)
|
||||
self.edges[edge.token] = edge
|
||||
self.core.links[edge.token] = edge
|
||||
if link.HasField("interface1"):
|
||||
interface1 = link.interface1
|
||||
self.core.interface_to_edge[(node1.id, interface1.id)] = token
|
||||
canvas_node1.interfaces[interface1.id] = interface1
|
||||
edge.src_interface = interface1
|
||||
if link.HasField("interface2"):
|
||||
interface2 = link.interface2
|
||||
self.core.interface_to_edge[
|
||||
(node2.id, interface2.id)
|
||||
] = edge.token
|
||||
canvas_node2.interfaces[interface2.id] = interface2
|
||||
edge.dst_interface = interface2
|
||||
if link.HasField("iface1"):
|
||||
iface1 = link.iface1
|
||||
self.core.iface_to_edge[(node1.id, iface1.id)] = token
|
||||
canvas_node1.ifaces[iface1.id] = iface1
|
||||
edge.src_iface = iface1
|
||||
if link.HasField("iface2"):
|
||||
iface2 = link.iface2
|
||||
self.core.iface_to_edge[(node2.id, iface2.id)] = edge.token
|
||||
canvas_node2.ifaces[iface2.id] = iface2
|
||||
edge.dst_iface = iface2
|
||||
elif link.options.unidirectional:
|
||||
edge = self.edges[token]
|
||||
edge.asymmetric_link = link
|
||||
|
|
@ -513,14 +511,14 @@ class CanvasGraph(tk.Canvas):
|
|||
edge.delete()
|
||||
# update node connected to edge being deleted
|
||||
other_id = edge.src
|
||||
other_interface = edge.src_interface
|
||||
other_iface = edge.src_iface
|
||||
if edge.src == object_id:
|
||||
other_id = edge.dst
|
||||
other_interface = edge.dst_interface
|
||||
other_iface = edge.dst_iface
|
||||
other_node = self.nodes[other_id]
|
||||
other_node.edges.remove(edge)
|
||||
if other_interface:
|
||||
del other_node.interfaces[other_interface.id]
|
||||
if other_iface:
|
||||
del other_node.ifaces[other_iface.id]
|
||||
if is_wireless:
|
||||
other_node.delete_antenna()
|
||||
|
||||
|
|
@ -538,12 +536,12 @@ class CanvasGraph(tk.Canvas):
|
|||
del self.edges[edge.token]
|
||||
src_node = self.nodes[edge.src]
|
||||
src_node.edges.discard(edge)
|
||||
if edge.src_interface:
|
||||
del src_node.interfaces[edge.src_interface.id]
|
||||
if edge.src_iface:
|
||||
del src_node.ifaces[edge.src_iface.id]
|
||||
dst_node = self.nodes[edge.dst]
|
||||
dst_node.edges.discard(edge)
|
||||
if edge.dst_interface:
|
||||
del dst_node.interfaces[edge.dst_interface.id]
|
||||
if edge.dst_iface:
|
||||
del dst_node.ifaces[edge.dst_iface.id]
|
||||
src_wireless = NodeUtils.is_wireless_node(src_node.core_node.type)
|
||||
if src_wireless:
|
||||
dst_node.delete_antenna()
|
||||
|
|
@ -963,26 +961,26 @@ class CanvasGraph(tk.Canvas):
|
|||
copy_link = copy_edge.link
|
||||
options = edge.link.options
|
||||
copy_link.options.CopyFrom(options)
|
||||
interface1_id = None
|
||||
if copy_link.HasField("interface1"):
|
||||
interface1_id = copy_link.interface1.id
|
||||
interface2_id = None
|
||||
if copy_link.HasField("interface2"):
|
||||
interface2_id = copy_link.interface2.id
|
||||
iface1_id = None
|
||||
if copy_link.HasField("iface1"):
|
||||
iface1_id = copy_link.iface1.id
|
||||
iface2_id = None
|
||||
if copy_link.HasField("iface2"):
|
||||
iface2_id = copy_link.iface2.id
|
||||
if not options.unidirectional:
|
||||
copy_edge.asymmetric_link = None
|
||||
else:
|
||||
asym_interface1 = None
|
||||
if interface1_id:
|
||||
asym_interface1 = core_pb2.Interface(id=interface1_id)
|
||||
asym_interface2 = None
|
||||
if interface2_id:
|
||||
asym_interface2 = core_pb2.Interface(id=interface2_id)
|
||||
asym_iface1 = None
|
||||
if iface1_id:
|
||||
asym_iface1 = core_pb2.Interface(id=iface1_id)
|
||||
asym_iface2 = None
|
||||
if iface2_id:
|
||||
asym_iface2 = core_pb2.Interface(id=iface2_id)
|
||||
copy_edge.asymmetric_link = core_pb2.Link(
|
||||
node1_id=copy_link.node2_id,
|
||||
node2_id=copy_link.node1_id,
|
||||
interface1=asym_interface1,
|
||||
interface2=asym_interface2,
|
||||
iface1=asym_iface1,
|
||||
iface2=asym_iface2,
|
||||
options=edge.asymmetric_link.options,
|
||||
)
|
||||
self.itemconfig(
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ class CanvasNode:
|
|||
)
|
||||
self.tooltip = CanvasTooltip(self.canvas)
|
||||
self.edges = set()
|
||||
self.interfaces = {}
|
||||
self.ifaces = {}
|
||||
self.wireless_edges = set()
|
||||
self.antennas = []
|
||||
self.antenna_images = {}
|
||||
|
|
@ -70,9 +70,9 @@ class CanvasNode:
|
|||
self.context = tk.Menu(self.canvas)
|
||||
themes.style_menu(self.context)
|
||||
|
||||
def next_interface_id(self) -> int:
|
||||
def next_iface_id(self) -> int:
|
||||
i = 0
|
||||
while i in self.interfaces:
|
||||
while i in self.ifaces:
|
||||
i += 1
|
||||
return i
|
||||
|
||||
|
|
@ -300,16 +300,16 @@ class CanvasNode:
|
|||
dialog = NodeConfigServiceDialog(self.app, self)
|
||||
dialog.show()
|
||||
|
||||
def has_emane_link(self, interface_id: int) -> core_pb2.Node:
|
||||
def has_emane_link(self, iface_id: int) -> core_pb2.Node:
|
||||
result = None
|
||||
for edge in self.edges:
|
||||
if self.id == edge.src:
|
||||
other_id = edge.dst
|
||||
edge_interface_id = edge.src_interface.id
|
||||
edge_iface_id = edge.src_iface.id
|
||||
else:
|
||||
other_id = edge.src
|
||||
edge_interface_id = edge.dst_interface.id
|
||||
if edge_interface_id != interface_id:
|
||||
edge_iface_id = edge.dst_iface.id
|
||||
if edge_iface_id != iface_id:
|
||||
continue
|
||||
other_node = self.canvas.nodes[other_id]
|
||||
if other_node.core_node.type == NodeType.EMANE:
|
||||
|
|
|
|||
|
|
@ -12,10 +12,10 @@ if TYPE_CHECKING:
|
|||
from core.gui.graph.node import CanvasNode
|
||||
|
||||
|
||||
def get_index(interface: "core_pb2.Interface") -> Optional[int]:
|
||||
if not interface.ip4:
|
||||
def get_index(iface: "core_pb2.Interface") -> Optional[int]:
|
||||
if not iface.ip4:
|
||||
return None
|
||||
net = netaddr.IPNetwork(f"{interface.ip4}/{interface.ip4mask}")
|
||||
net = netaddr.IPNetwork(f"{iface.ip4}/{iface.ip4mask}")
|
||||
ip_value = net.value
|
||||
cidr_value = net.cidr.value
|
||||
return ip_value - cidr_value
|
||||
|
|
@ -89,43 +89,43 @@ class InterfaceManager:
|
|||
remaining_subnets = set()
|
||||
for edge in self.app.core.links.values():
|
||||
link = edge.link
|
||||
if link.HasField("interface1"):
|
||||
subnets = self.get_subnets(link.interface1)
|
||||
if link.HasField("iface1"):
|
||||
subnets = self.get_subnets(link.iface1)
|
||||
remaining_subnets.add(subnets)
|
||||
if link.HasField("interface2"):
|
||||
subnets = self.get_subnets(link.interface2)
|
||||
if link.HasField("iface2"):
|
||||
subnets = self.get_subnets(link.iface2)
|
||||
remaining_subnets.add(subnets)
|
||||
|
||||
# remove all subnets from used subnets when no longer present
|
||||
# or remove used indexes from subnet
|
||||
interfaces = []
|
||||
ifaces = []
|
||||
for link in links:
|
||||
if link.HasField("interface1"):
|
||||
interfaces.append(link.interface1)
|
||||
if link.HasField("interface2"):
|
||||
interfaces.append(link.interface2)
|
||||
for interface in interfaces:
|
||||
subnets = self.get_subnets(interface)
|
||||
if link.HasField("iface1"):
|
||||
ifaces.append(link.iface1)
|
||||
if link.HasField("iface2"):
|
||||
ifaces.append(link.iface2)
|
||||
for iface in ifaces:
|
||||
subnets = self.get_subnets(iface)
|
||||
if subnets not in remaining_subnets:
|
||||
self.used_subnets.pop(subnets.key(), None)
|
||||
else:
|
||||
index = get_index(interface)
|
||||
index = get_index(iface)
|
||||
if index is not None:
|
||||
subnets.used_indexes.discard(index)
|
||||
self.current_subnets = None
|
||||
|
||||
def joined(self, links: List["core_pb2.Link"]) -> None:
|
||||
interfaces = []
|
||||
ifaces = []
|
||||
for link in links:
|
||||
if link.HasField("interface1"):
|
||||
interfaces.append(link.interface1)
|
||||
if link.HasField("interface2"):
|
||||
interfaces.append(link.interface2)
|
||||
if link.HasField("iface1"):
|
||||
ifaces.append(link.iface1)
|
||||
if link.HasField("iface2"):
|
||||
ifaces.append(link.iface2)
|
||||
|
||||
# add to used subnets and mark used indexes
|
||||
for interface in interfaces:
|
||||
subnets = self.get_subnets(interface)
|
||||
index = get_index(interface)
|
||||
for iface in ifaces:
|
||||
subnets = self.get_subnets(iface)
|
||||
index = get_index(iface)
|
||||
if index is None:
|
||||
continue
|
||||
subnets.used_indexes.add(index)
|
||||
|
|
@ -150,13 +150,13 @@ class InterfaceManager:
|
|||
ip6 = self.current_subnets.ip6[index]
|
||||
return str(ip4), str(ip6)
|
||||
|
||||
def get_subnets(self, interface: "core_pb2.Interface") -> Subnets:
|
||||
def get_subnets(self, iface: "core_pb2.Interface") -> Subnets:
|
||||
ip4_subnet = self.ip4_subnets
|
||||
if interface.ip4:
|
||||
ip4_subnet = IPNetwork(f"{interface.ip4}/{interface.ip4mask}").cidr
|
||||
if iface.ip4:
|
||||
ip4_subnet = IPNetwork(f"{iface.ip4}/{iface.ip4mask}").cidr
|
||||
ip6_subnet = self.ip6_subnets
|
||||
if interface.ip6:
|
||||
ip6_subnet = IPNetwork(f"{interface.ip6}/{interface.ip6mask}").cidr
|
||||
if iface.ip6:
|
||||
ip6_subnet = IPNetwork(f"{iface.ip6}/{iface.ip6mask}").cidr
|
||||
subnets = Subnets(ip4_subnet, ip6_subnet)
|
||||
return self.used_subnets.get(subnets.key(), subnets)
|
||||
|
||||
|
|
@ -196,16 +196,16 @@ class InterfaceManager:
|
|||
for edge in canvas_node.edges:
|
||||
src_node = canvas.nodes[edge.src]
|
||||
dst_node = canvas.nodes[edge.dst]
|
||||
interface = edge.src_interface
|
||||
iface = edge.src_iface
|
||||
check_node = src_node
|
||||
if src_node == canvas_node:
|
||||
interface = edge.dst_interface
|
||||
iface = edge.dst_iface
|
||||
check_node = dst_node
|
||||
if check_node.core_node.id in visited:
|
||||
continue
|
||||
visited.add(check_node.core_node.id)
|
||||
if interface:
|
||||
subnets = self.get_subnets(interface)
|
||||
if iface:
|
||||
subnets = self.get_subnets(iface)
|
||||
else:
|
||||
subnets = self.find_subnets(check_node, visited)
|
||||
if subnets:
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ class Menubar(tk.Menu):
|
|||
menu.add_checkbutton(
|
||||
label="Interface Names",
|
||||
command=self.click_edge_label_change,
|
||||
variable=self.canvas.show_interface_names,
|
||||
variable=self.canvas.show_iface_names,
|
||||
)
|
||||
menu.add_checkbutton(
|
||||
label="IPv4 Addresses",
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue