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

add emane configurations to my start_session()

Browse source
This commit is contained in:
Huy Pham 2019-11-06 14:34:41 -08:00
parent 6db4be4e13
commit 40e1bb0374
4 changed files with 175 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

122
coretk/coretk/coreclient.py
View file

@ -3,16 +3,16 @@ Incorporate grpc into python tkinter GUI
"""
import logging
import os
from collections import OrderedDict
from core.api.grpc import client, core_pb2
from coretk.coretocanvas import CoreToCanvasMapping
from coretk.dialogs.sessions import SessionsDialog
from coretk.emaneodelnodeconfig import EmaneModelNodeConfig
from coretk.interface import Interface, InterfaceManager
from coretk.mobilitynodeconfig import MobilityNodeConfig
from coretk.wlannodeconfig import WlanNodeConfig
link_layer_nodes = ["switch", "hub", "wlan", "rj45", "tunnel"]
link_layer_nodes = ["switch", "hub", "wlan", "rj45", "tunnel", "emane"]
network_layer_nodes = ["router", "host", "PC", "mdr", "prouter", "OVS"]
@ -95,6 +95,7 @@ class CoreClient:
self.core_mapping = CoreToCanvasMapping()
self.wlanconfig_management = WlanNodeConfig()
self.mobilityconfig_management = MobilityNodeConfig()
self.emaneconfig_management = EmaneModelNodeConfig(app)
self.emane_config = None
def handle_events(self, event):
@ -165,6 +166,8 @@ class CoreClient:
logging.info("emane config: %s", response)
self.emane_config = response.config
# get emane model config
# determine next node id and reusable nodes
max_id = 1
for node in session.nodes:
@ -332,6 +335,8 @@ class CoreClient:
hooks=list(self.hooks.values()),
wlan_configs=wlan_configs,
emane_config=emane_config,
emane_model_configs=emane_model_configs,
mobility_configs=mobility_configs,
)
logging.debug("Start session %s, result: %s", self.session_id, response.result)
@ -339,22 +344,22 @@ class CoreClient:
response = self.client.stop_session(session_id=self.session_id)
logging.debug("coregrpc.py Stop session, result: %s", response.result)
# TODO no need, might get rid of this
def add_link(self, id1, id2, type1, type2, edge):
"""
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
"""
if1 = self.create_interface(type1, edge.interface_1)
if2 = self.create_interface(type2, edge.interface_2)
response = self.client.add_link(self.session_id, id1, id2, if1, if2)
logging.info("created link: %s", response)
# # TODO no need, might get rid of this
# def add_link(self, id1, id2, type1, type2, edge):
# """
# 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
# """
# if1 = self.create_interface(type1, edge.interface_1)
# if2 = self.create_interface(type2, edge.interface_2)
# response = self.client.add_link(self.session_id, id1, id2, if1, if2)
# logging.info("created link: %s", response)
def launch_terminal(self, node_id):
response = self.client.get_node_terminal(self.session_id, node_id)
@ -417,22 +422,22 @@ class CoreClient:
else:
return self.reusable.pop(0)
def add_node(self, node_type, model, x, y, name, node_id):
position = core_pb2.Position(x=x, y=y)
node = core_pb2.Node(id=node_id, type=node_type, position=position, model=model)
self.node_ids.append(node_id)
response = self.client.add_node(self.session_id, node)
logging.info("created node: %s", response)
if node_type == core_pb2.NodeType.WIRELESS_LAN:
d = OrderedDict()
d["basic_range"] = "275"
d["bandwidth"] = "54000000"
d["jitter"] = "0"
d["delay"] = "20000"
d["error"] = "0"
r = self.client.set_wlan_config(self.session_id, node_id, d)
logging.debug("set wlan config %s", r)
return response.node_id
# def add_node(self, node_type, model, x, y, name, node_id):
# position = core_pb2.Position(x=x, y=y)
# node = core_pb2.Node(id=node_id, type=node_type, position=position, model=model)
# self.node_ids.append(node_id)
# response = self.client.add_node(self.session_id, node)
# logging.info("created node: %s", response)
# if node_type == core_pb2.NodeType.WIRELESS_LAN:
# d = OrderedDict()
# d["basic_range"] = "275"
# d["bandwidth"] = "54000000"
# d["jitter"] = "0"
# d["delay"] = "20000"
# d["error"] = "0"
# r = self.client.set_wlan_config(self.session_id, node_id, d)
# logging.debug("set wlan config %s", r)
# return response.node_id
def add_graph_node(self, session_id, canvas_id, x, y, name):
"""
@ -458,6 +463,8 @@ class CoreClient:
node_type = core_pb2.NodeType.RJ45
elif name == "tunnel":
node_type = core_pb2.NodeType.TUNNEL
elif name == "emane":
node_type = core_pb2.NodeType.EMANE
elif name in network_layer_nodes:
node_type = core_pb2.NodeType.DEFAULT
node_model = name
@ -468,9 +475,12 @@ class CoreClient:
# set default configuration for wireless node
self.wlanconfig_management.set_default_config(node_type, nid)
self.mobilityconfig_management.set_default_configuration(node_type, nid)
# set default emane configuration for emane node
if node_type == core_pb2.NodeType.EMANE:
self.emaneconfig_management.set_default_config(nid)
self.nodes[canvas_id] = create_node
self.core_mapping.map_core_id_to_canvas_id(nid, canvas_id)
# self.core_id_to_canvas_id[nid] = canvas_id
@ -628,44 +638,50 @@ class CoreClient:
:return: nothing
"""
node_one = self.nodes[canvas_id_1]
node_two = self.nodes[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,
node_one.node_id,
node_one.type,
node_two.node_id,
node_two.type,
)
self.edges[token] = edge
src_interface, dst_interface = self.create_edge_interface(
edge, canvas_id_1, canvas_id_2
)
node_one_id = self.nodes[canvas_id_1].node_id
node_two_id = self.nodes[canvas_id_2].node_id
node_one_id = node_one.node_id
node_two_id = node_two.node_id
# provide a way to get an edge from a core node and an interface id
if src_interface is not None:
self.core_mapping.map_node_and_interface_to_canvas_edge(
node_one_id, src_interface.id, token
)
logging.debug(
"map node id %s, interface_id %s to edge token %s",
node_one_id,
src_interface.id,
token,
)
if dst_interface is not None:
self.core_mapping.map_node_and_interface_to_canvas_edge(
node_two_id, dst_interface.id, token
)
logging.debug(
"map node id %s, interface_id %s to edge token %s",
node_two_id,
dst_interface.id,
token,
if (
node_one.type == core_pb2.NodeType.EMANE
and node_two.type == core_pb2.NodeType.DEFAULT
):
if node_two.model == "mdr":
self.emaneconfig_management.set_default_for_mdr(
node_one.node_id, node_two.node_id, dst_interface.id
)
elif (
node_two.type == core_pb2.NodeType.EMANE
and node_one.type == core_pb2.NodeType.DEFAULT
):
if node_one.model == "mdr":
self.emaneconfig_management.set_default_for_mdr(
node_two.node_id, node_one.node_id, src_interface.id
)
logging.debug("Adding edge to grpc manager...")
else:
logging.error("grpcmanagement.py INVALID CANVAS NODE ID")

31
coretk/coretk/coretoolbarhelp.py
View file

@ -34,14 +34,6 @@ class CoreToolbarHelp:
for edge in self.app.core.edges.values():
interface_one = self.app.core.create_interface(edge.type1, edge.interface_1)
interface_two = self.app.core.create_interface(edge.type2, edge.interface_2)
# TODO for now only consider the basic cases
# if (
# edge.type1 == core_pb2.NodeType.WIRELESS_LAN
# or edge.type2 == core_pb2.NodeType.WIRELESS_LAN
# ):
# link_type = core_pb2.LinkType.WIRELESS
# else:
# link_type = core_pb2.LinkType.WIRED
link = core_pb2.Link(
node_one_id=edge.id1,
node_two_id=edge.id2,
@ -80,20 +72,41 @@ class CoreToolbarHelp:
configs.append(cnf)
return configs
def get_emane_configuration_list(self):
"""
form a list of emane configuration for the nodes
:return: nothing
"""
configs = []
manager_configs = self.app.core.emaneconfig_management.configurations
for key, value in manager_configs.items():
config = {x: value[1][x].value for x in value[1]}
configs.append(
core_pb2.EmaneModelConfig(
node_id=key[0], interface_id=key[1], model=value[0], config=config
)
)
return configs
def gui_start_session(self):
nodes = self.get_node_list()
links = self.get_link_list()
wlan_configs = self.get_wlan_configuration_list()
mobility_configs = self.get_mobility_configuration_list()
# get emane config
# get emane config (global configuration)
pb_emane_config = self.app.core.emane_config
emane_config = {x: pb_emane_config[x].value for x in pb_emane_config}
# get emane configuration list
emane_model_configs = self.get_emane_configuration_list()
self.app.core.start_session(
nodes,
links,
wlan_configs=wlan_configs,
mobility_configs=mobility_configs,
emane_config=emane_config,
emane_model_configs=emane_model_configs,
)

5
coretk/coretk/dialogs/emaneconfig.py
View file

@ -126,6 +126,11 @@ class EmaneConfiguration(Dialog):
response,
)
# store the change locally
self.app.core.emaneconfig_management.set_custom_emane_cloud_config(
self.canvas_node.core_id, "emane_" + model_name
)
self.emane_model_dialog.destroy()
def draw_model_options(self):

78
coretk/coretk/emaneodelnodeconfig.py Normal file
View file

@ -0,0 +1,78 @@
"""
emane model configurations
"""
import logging
class EmaneModelNodeConfig:
def __init__(self, app):
"""
create an instance for EmaneModelNodeConfig
:param app: application
"""
# dict(tuple(node_id, interface_id, model) : config)
self.configurations = {}
# dict(int, list(int)) stores emane node maps to mdr nodes that are linked to that emane node
self.links = {}
self.app = app
def set_default_config(self, node_id):
"""
set a default emane configuration for a newly created emane
:param int node_id: node id
:return: nothing
"""
session_id = self.app.core.session_id
client = self.app.core.client
default_emane_model = client.get_emane_models(session_id).models[0]
response = client.get_emane_model_config(
session_id, node_id, default_emane_model
)
logging.info(
"emanemodelnodeconfig.py get emane model config (%s), result: %s",
node_id,
response,
)
self.configurations[tuple([node_id, None])] = tuple(
[default_emane_model, response.config]
)
self.links[node_id] = []
def set_default_for_mdr(self, emane_node_id, mdr_node_id, interface_id):
"""
set emane configuration of an mdr node on the correct interface
:param int emane_node_id: emane node id
:param int mdr_node_id: mdr node id
:param int interface_id: interface id
:return: nothing
"""
self.configurations[tuple([mdr_node_id, interface_id])] = self.configurations[
tuple([emane_node_id, None])
]
self.links[emane_node_id].append(tuple([mdr_node_id, interface_id]))
def set_custom_emane_cloud_config(self, emane_node_id, model_name):
"""
set custom configuration for an emane node, if model is changed, update the nodes connected to that emane node
:param int emane_node_id: emane node id
:param str model_name: model name
:return: nothing
"""
prev_model_name = self.configurations[tuple([emane_node_id, None])][0]
session_id = self.app.core.session_id
response = self.app.core.client.get_emane_model_config(
session_id, emane_node_id, model_name
)
self.configurations[tuple([emane_node_id, None])] = tuple(
[model_name, response.config]
)
if prev_model_name != model_name:
for k in self.links[emane_node_id]:
self.configurations[k] = tuple([model_name, response.config])