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

modified session.add_node parameter node_options, to just be options

Browse source
This commit is contained in:
Blake Harnden 2019-10-22 15:31:50 -07:00
parent ce411a07d7
commit ab0abd65aa
21 changed files with 100 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
daemon/core/api/grpc/server.py
View file

@ -769,18 +769,18 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
node_type = NodeTypes.DEFAULT.value
node_type = NodeTypes(node_type)
node_options = NodeOptions(name=node_proto.name, model=node_proto.model)
node_options.icon = node_proto.icon
node_options.opaque = node_proto.opaque
node_options.image = node_proto.image
node_options.services = node_proto.services
options = NodeOptions(name=node_proto.name, model=node_proto.model)
options.icon = node_proto.icon
options.opaque = node_proto.opaque
options.image = node_proto.image
options.services = node_proto.services
if node_proto.server:
node_options.emulation_server = node_proto.server
options.emulation_server = node_proto.server
position = node_proto.position
node_options.set_position(position.x, position.y)
node_options.set_location(position.lat, position.lon, position.alt)
node = session.add_node(_type=node_type, _id=node_id, node_options=node_options)
options.set_position(position.x, position.y)
options.set_location(position.lat, position.lon, position.alt)
node = session.add_node(_type=node_type, _id=node_id, options=options)
# configure emane if provided
emane_model = node_proto.emane
@ -856,18 +856,18 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
logging.debug("edit node: %s", request)
session = self.get_session(request.session_id, context)
node = self.get_node(session, request.node_id, context)
node_options = NodeOptions()
node_options.icon = request.icon
options = NodeOptions()
options.icon = request.icon
x = request.position.x
y = request.position.y
node_options.set_position(x, y)
options.set_position(x, y)
lat = request.position.lat
lon = request.position.lon
alt = request.position.alt
node_options.set_location(lat, lon, alt)
options.set_location(lat, lon, alt)
result = True
try:
session.update_node(node.id, node_options)
session.update_node(node.id, options)
node_data = node.data(0)
session.broadcast_node(node_data)
except CoreError:

20
daemon/core/api/tlv/corehandlers.py
View file

@ -698,12 +698,12 @@ class CoreHandler(socketserver.BaseRequestHandler):
node_id = message.get_tlv(NodeTlvs.NUMBER.value)
node_options = NodeOptions(
options = NodeOptions(
name=message.get_tlv(NodeTlvs.NAME.value),
model=message.get_tlv(NodeTlvs.MODEL.value),
)
node_options.set_position(
options.set_position(
x=message.get_tlv(NodeTlvs.X_POSITION.value),
y=message.get_tlv(NodeTlvs.Y_POSITION.value),
)
@ -717,19 +717,19 @@ class CoreHandler(socketserver.BaseRequestHandler):
alt = message.get_tlv(NodeTlvs.ALTITUDE.value)
if alt is not None:
alt = float(alt)
node_options.set_location(lat=lat, lon=lon, alt=alt)
options.set_location(lat=lat, lon=lon, alt=alt)
node_options.icon = message.get_tlv(NodeTlvs.ICON.value)
node_options.canvas = message.get_tlv(NodeTlvs.CANVAS.value)
node_options.opaque = message.get_tlv(NodeTlvs.OPAQUE.value)
node_options.emulation_server = message.get_tlv(NodeTlvs.EMULATION_SERVER.value)
options.icon = message.get_tlv(NodeTlvs.ICON.value)
options.canvas = message.get_tlv(NodeTlvs.CANVAS.value)
options.opaque = message.get_tlv(NodeTlvs.OPAQUE.value)
options.emulation_server = message.get_tlv(NodeTlvs.EMULATION_SERVER.value)
services = message.get_tlv(NodeTlvs.SERVICES.value)
if services:
node_options.services = services.split("|")
options.services = services.split("|")
if message.flags & MessageFlags.ADD.value:
node = self.session.add_node(node_type, node_id, node_options)
node = self.session.add_node(node_type, node_id, options)
if node:
if message.flags & MessageFlags.STRING.value:
self.node_status_request[node.id] = True
@ -748,7 +748,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
replies.append(coreapi.CoreNodeMessage.pack(flags, tlvdata))
# node update
else:
self.session.update_node(node_id, node_options)
self.session.update_node(node_id, options)
return replies

67
daemon/core/emulator/session.py
View file

@ -634,13 +634,13 @@ class Session(object):
if node_two:
node_two.lock.release()
def add_node(self, _type=NodeTypes.DEFAULT, _id=None, node_options=None, _cls=None):
def add_node(self, _type=NodeTypes.DEFAULT, _id=None, options=None, _cls=None):
"""
Add a node to the session, based on the provided node data.
:param core.emulator.enumerations.NodeTypes _type: type of node to create
:param int _id: id for node, defaults to None for generated id
:param core.emulator.emudata.NodeOptions node_options: data to create node with
:param core.emulator.emudata.NodeOptions options: data to create node with
:param class _cls: optional custom class to use for a created node
:return: created node
:raises core.CoreError: when an invalid node type is given
@ -666,18 +666,16 @@ class Session(object):
break
# generate name if not provided
if not node_options:
node_options = NodeOptions()
name = node_options.name
if not options:
options = NodeOptions()
name = options.name
if not name:
name = f"{node_class.__name__}{_id}"
# verify distributed server
server = self.distributed.servers.get(node_options.emulation_server)
if node_options.emulation_server is not None and server is None:
raise CoreError(
f"invalid distributed server: {node_options.emulation_server}"
)
server = self.distributed.servers.get(options.emulation_server)
if options.emulation_server is not None and server is None:
raise CoreError(f"invalid distributed server: {options.emulation_server}")
# create node
logging.info(
@ -693,7 +691,7 @@ class Session(object):
_id=_id,
name=name,
start=start,
image=node_options.image,
image=options.image,
server=server,
)
else:
@ -702,18 +700,18 @@ class Session(object):
)
# set node attributes
node.icon = node_options.icon
node.canvas = node_options.canvas
node.opaque = node_options.opaque
node.icon = options.icon
node.canvas = options.canvas
node.opaque = options.opaque
# set node position and broadcast it
self.set_node_position(node, node_options)
self.set_node_position(node, options)
# add services to needed nodes
if isinstance(node, (CoreNode, PhysicalNode, DockerNode, LxcNode)):
node.type = node_options.model
node.type = options.model
logging.debug("set node type: %s", node.type)
self.services.add_services(node, node.type, node_options.services)
self.services.add_services(node, node.type, options.services)
# boot nodes if created after runtime, CoreNodes, Physical, and RJ45 are all nodes
is_boot_node = isinstance(node, CoreNodeBase) and not isinstance(node, Rj45Node)
@ -724,12 +722,12 @@ class Session(object):
return node
def update_node(self, node_id, node_options):
def update_node(self, node_id, options):
"""
Update node information.
:param int node_id: id of node to update
:param core.emulator.emudata.NodeOptions node_options: data to update node with
:param core.emulator.emudata.NodeOptions options: data to update node with
:return: True if node updated, False otherwise
:rtype: bool
:raises core.CoreError: when node to update does not exist
@ -738,26 +736,26 @@ class Session(object):
node = self.get_node(node_id)
# set node position and broadcast it
self.set_node_position(node, node_options)
self.set_node_position(node, options)
# update attributes
node.canvas = node_options.canvas
node.icon = node_options.icon
node.canvas = options.canvas
node.icon = options.icon
def set_node_position(self, node, node_options):
def set_node_position(self, node, options):
"""
Set position for a node, use lat/lon/alt if needed.
:param node: node to set position for
:param core.emulator.emudata.NodeOptions node_options: data for node
:param core.emulator.emudata.NodeOptions options: data for node
:return: nothing
"""
# extract location values
x = node_options.x
y = node_options.y
lat = node_options.lat
lon = node_options.lon
alt = node_options.alt
x = options.x
y = options.y
lat = options.lat
lon = options.lon
alt = options.alt
# check if we need to generate position from lat/lon/alt
has_empty_position = all(i is None for i in [x, y])
@ -909,12 +907,7 @@ class Session(object):
self.mobility.handleevent(event_data)
def create_emane_network(
self,
model,
geo_reference,
geo_scale=None,
node_options=NodeOptions(),
config=None,
self, model, geo_reference, geo_scale=None, options=NodeOptions(), config=None
):
"""
Convenience method for creating an emane network.
@ -922,7 +915,7 @@ class Session(object):
:param model: emane model to use for emane network
:param geo_reference: geo reference point to use for emane node locations
:param geo_scale: geo scale to use for emane node locations, defaults to 1.0
:param core.emulator.emudata.NodeOptions node_options: options for emane node being created
:param core.emulator.emudata.NodeOptions options: options for emane node being created
:param dict config: emane model configuration
:return: create emane network
"""
@ -932,7 +925,7 @@ class Session(object):
self.location.refscale = geo_scale
# create and return network
emane_network = self.add_node(_type=NodeTypes.EMANE, node_options=node_options)
emane_network = self.add_node(_type=NodeTypes.EMANE, options=options)
self.emane.set_model(emane_network, model, config)
return emane_network

20
daemon/core/xml/corexml.py
View file

@ -737,53 +737,51 @@ class CoreXmlReader(object):
node_id = get_int(device_element, "id")
name = device_element.get("name")
model = device_element.get("type")
node_options = NodeOptions(name, model)
options = NodeOptions(name, model)
service_elements = device_element.find("services")
if service_elements is not None:
node_options.services = [
x.get("name") for x in service_elements.iterchildren()
]
options.services = [x.get("name") for x in service_elements.iterchildren()]
position_element = device_element.find("position")
if position_element is not None:
x = get_int(position_element, "x")
y = get_int(position_element, "y")
if all([x, y]):
node_options.set_position(x, y)
options.set_position(x, y)
lat = get_float(position_element, "lat")
lon = get_float(position_element, "lon")
alt = get_float(position_element, "alt")
if all([lat, lon, alt]):
node_options.set_location(lat, lon, alt)
options.set_location(lat, lon, alt)
logging.info("reading node id(%s) model(%s) name(%s)", node_id, model, name)
self.session.add_node(_id=node_id, node_options=node_options)
self.session.add_node(_id=node_id, options=options)
def read_network(self, network_element):
node_id = get_int(network_element, "id")
name = network_element.get("name")
node_type = NodeTypes[network_element.get("type")]
node_options = NodeOptions(name)
options = NodeOptions(name)
position_element = network_element.find("position")
if position_element is not None:
x = get_int(position_element, "x")
y = get_int(position_element, "y")
if all([x, y]):
node_options.set_position(x, y)
options.set_position(x, y)
lat = get_float(position_element, "lat")
lon = get_float(position_element, "lon")
alt = get_float(position_element, "alt")
if all([lat, lon, alt]):
node_options.set_location(lat, lon, alt)
options.set_location(lat, lon, alt)
logging.info(
"reading node id(%s) node_type(%s) name(%s)", node_id, node_type, name
)
self.session.add_node(_type=node_type, _id=node_id, node_options=node_options)
self.session.add_node(_type=node_type, _id=node_id, options=options)
def read_links(self):
link_elements = self.scenario.find("links")

2
daemon/examples/docker/docker2core.py
View file

@ -15,7 +15,7 @@ if __name__ == "__main__":
options = NodeOptions(model=None, image="ubuntu")
# create node one
node_one = session.add_node(_type=NodeTypes.DOCKER, node_options=options)
node_one = session.add_node(_type=NodeTypes.DOCKER, options=options)
interface_one = prefixes.create_interface(node_one)
# create node two

4
daemon/examples/docker/docker2docker.py
View file

@ -17,11 +17,11 @@ if __name__ == "__main__":
options = NodeOptions(model=None, image="ubuntu")
# create node one
node_one = session.add_node(_type=NodeTypes.DOCKER, node_options=options)
node_one = session.add_node(_type=NodeTypes.DOCKER, options=options)
interface_one = prefixes.create_interface(node_one)
# create node two
node_two = session.add_node(_type=NodeTypes.DOCKER, node_options=options)
node_two = session.add_node(_type=NodeTypes.DOCKER, options=options)
interface_two = prefixes.create_interface(node_two)
# add link

4
daemon/examples/docker/switch.py
View file

@ -19,11 +19,11 @@ if __name__ == "__main__":
switch = session.add_node(_type=NodeTypes.SWITCH)
# node one
node_one = session.add_node(_type=NodeTypes.DOCKER, node_options=options)
node_one = session.add_node(_type=NodeTypes.DOCKER, options=options)
interface_one = prefixes.create_interface(node_one)
# node two
node_two = session.add_node(_type=NodeTypes.DOCKER, node_options=options)
node_two = session.add_node(_type=NodeTypes.DOCKER, options=options)
interface_two = prefixes.create_interface(node_two)
# node three

2
daemon/examples/lxd/lxd2core.py
View file

@ -15,7 +15,7 @@ if __name__ == "__main__":
options = NodeOptions(image="ubuntu")
# create node one
node_one = session.add_node(_type=NodeTypes.LXC, node_options=options)
node_one = session.add_node(_type=NodeTypes.LXC, options=options)
interface_one = prefixes.create_interface(node_one)
# create node two

4
daemon/examples/lxd/lxd2lxd.py
View file

@ -17,11 +17,11 @@ if __name__ == "__main__":
options = NodeOptions(image="ubuntu:18.04")
# create node one
node_one = session.add_node(_type=NodeTypes.LXC, node_options=options)
node_one = session.add_node(_type=NodeTypes.LXC, options=options)
interface_one = prefixes.create_interface(node_one)
# create node two
node_two = session.add_node(_type=NodeTypes.LXC, node_options=options)
node_two = session.add_node(_type=NodeTypes.LXC, options=options)
interface_two = prefixes.create_interface(node_two)
# add link

4
daemon/examples/lxd/switch.py
View file

@ -19,11 +19,11 @@ if __name__ == "__main__":
switch = session.add_node(_type=NodeTypes.SWITCH)
# node one
node_one = session.add_node(_type=NodeTypes.LXC, node_options=options)
node_one = session.add_node(_type=NodeTypes.LXC, options=options)
interface_one = prefixes.create_interface(node_one)
# node two
node_two = session.add_node(_type=NodeTypes.LXC, node_options=options)
node_two = session.add_node(_type=NodeTypes.LXC, options=options)
interface_two = prefixes.create_interface(node_two)
# node three

4
daemon/examples/python/distributed_emane.py
View file

@ -31,11 +31,11 @@ def main(args):
# create local node, switch, and remote nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node_one = session.add_node(node_options=options)
node_one = session.add_node(options=options)
emane_net = session.add_node(_type=NodeTypes.EMANE)
session.emane.set_model(emane_net, EmaneIeee80211abgModel)
options.emulation_server = server_name
node_two = session.add_node(node_options=options)
node_two = session.add_node(options=options)
# create node interfaces and link
interface_one = prefixes.create_interface(node_one)

4
daemon/examples/python/distributed_lxd.py
View file

@ -23,9 +23,9 @@ def main(args):
# create local node, switch, and remote nodes
options = NodeOptions(image="ubuntu:18.04")
node_one = session.add_node(_type=NodeTypes.LXC, node_options=options)
node_one = session.add_node(_type=NodeTypes.LXC, options=options)
options.emulation_server = server_name
node_two = session.add_node(_type=NodeTypes.LXC, node_options=options)
node_two = session.add_node(_type=NodeTypes.LXC, options=options)
# create node interfaces and link
interface_one = prefixes.create_interface(node_one)

4
daemon/examples/python/distributed_ptp.py
View file

@ -23,9 +23,9 @@ def main(args):
# create local node, switch, and remote nodes
options = NodeOptions()
node_one = session.add_node(node_options=options)
node_one = session.add_node(options=options)
options.emulation_server = server_name
node_two = session.add_node(node_options=options)
node_two = session.add_node(options=options)
# create node interfaces and link
interface_one = prefixes.create_interface(node_one)

2
daemon/examples/python/distributed_switch.py
View file

@ -28,7 +28,7 @@ def main(args):
switch = session.add_node(_type=NodeTypes.SWITCH)
options = NodeOptions()
options.emulation_server = server_name
node_two = session.add_node(node_options=options)
node_two = session.add_node(options=options)
# create node interfaces and link
interface_one = prefixes.create_interface(node_one)

2
daemon/examples/python/emane80211.py
View file

@ -28,7 +28,7 @@ def example(args):
# create nodes
options = NodeOptions(model="mdr")
for i in range(args.nodes):
node = session.add_node(node_options=options)
node = session.add_node(options=options)
node.setposition(x=150 * (i + 1), y=150)
interface = prefixes.create_interface(node)
session.add_link(node.id, emane_network.id, interface_one=interface)

2
daemon/examples/python/wlan.py
View file

@ -27,7 +27,7 @@ def example(args):
options = NodeOptions(model="mdr")
options.set_position(0, 0)
for _ in range(args.nodes):
node = session.add_node(node_options=options)
node = session.add_node(options=options)
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)

8
daemon/tests/emane/test_emane.py
View file

@ -62,9 +62,9 @@ class TestEmane:
# create nodes
options = NodeOptions(model="mdr")
options.set_position(150, 150)
node_one = session.add_node(node_options=options)
node_one = session.add_node(options=options)
options.set_position(300, 150)
node_two = session.add_node(node_options=options)
node_two = session.add_node(options=options)
for i, node in enumerate([node_one, node_two]):
node.setposition(x=150 * (i + 1), y=150)
@ -97,9 +97,9 @@ class TestEmane:
# create nodes
options = NodeOptions(model="mdr")
options.set_position(150, 150)
node_one = session.add_node(node_options=options)
node_one = session.add_node(options=options)
options.set_position(300, 150)
node_two = session.add_node(node_options=options)
node_two = session.add_node(options=options)
for i, node in enumerate([node_one, node_two]):
node.setposition(x=150 * (i + 1), y=150)

8
daemon/tests/test_core.py
View file

@ -148,8 +148,8 @@ class TestCore:
# create nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node_one = session.add_node(node_options=options)
node_two = session.add_node(node_options=options)
node_one = session.add_node(options=options)
node_two = session.add_node(options=options)
# link nodes
for node in [node_one, node_two]:
@ -178,8 +178,8 @@ class TestCore:
# create nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node_one = session.add_node(node_options=options)
node_two = session.add_node(node_options=options)
node_one = session.add_node(options=options)
node_two = session.add_node(options=options)
# link nodes
for node in [node_one, node_two]:

8
daemon/tests/test_grpc.py
View file

@ -245,8 +245,8 @@ class TestGrpc:
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
session.set_state(EventTypes.CONFIGURATION_STATE)
node_options = NodeOptions(model="Host")
node = session.add_node(node_options=node_options)
options = NodeOptions(model="Host")
node = session.add_node(options=options)
session.instantiate()
output = "hello world"
@ -263,8 +263,8 @@ class TestGrpc:
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
session.set_state(EventTypes.CONFIGURATION_STATE)
node_options = NodeOptions(model="Host")
node = session.add_node(node_options=node_options)
options = NodeOptions(model="Host")
node = session.add_node(options=options)
session.instantiate()
# then

4
daemon/tests/test_nodes.py
View file

@ -17,10 +17,10 @@ class TestNodes:
@pytest.mark.parametrize("model", MODELS)
def test_node_add(self, session, model):
# given
node_options = NodeOptions(model=model)
options = NodeOptions(model=model)
# when
node = session.add_node(node_options=node_options)
node = session.add_node(options=options)
# give time for node services to boot
time.sleep(1)

8
daemon/tests/test_xml.py
View file

@ -108,8 +108,8 @@ class TestXml:
ptp_node = session.add_node(_type=NodeTypes.PEER_TO_PEER)
# create nodes
node_options = NodeOptions(model="host")
node_one = session.add_node(node_options=node_options)
options = NodeOptions(model="host")
node_one = session.add_node(options=options)
node_two = session.add_node()
# link nodes to ptp net
@ -176,8 +176,8 @@ class TestXml:
# create nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node_one = session.add_node(node_options=options)
node_two = session.add_node(node_options=options)
node_one = session.add_node(options=options)
node_two = session.add_node(options=options)
# link nodes
for node in [node_one, node_two]: