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

Merge pull request #470 from coreemu/cleanup/variable-names

Browse source 
refactor variables to use numbers instead of letters
This commit is contained in:
bharnden 2020-06-13 21:27:41 -07:00 committed by GitHub
commit 0bcf7c1d83
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
50 changed files with 1057 additions and 1213 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

94
daemon/core/api/grpc/client.py
View file

@ -609,30 +609,30 @@ class CoreGrpcClient:
def add_link(
self,
session_id: int,
node_one_id: int,
node_two_id: int,
interface_one: core_pb2.Interface = None,
interface_two: core_pb2.Interface = None,
node1_id: int,
node2_id: int,
interface1: core_pb2.Interface = None,
interface2: core_pb2.Interface = None,
options: core_pb2.LinkOptions = None,
) -> core_pb2.AddLinkResponse:
"""
Add a link between nodes.
:param session_id: session id
:param node_one_id: node one id
:param node_two_id: node two id
:param interface_one: node one interface data
:param interface_two: node two interface data
:param node1_id: node one id
:param node2_id: node two id
:param interface1: node one interface data
:param interface2: node two interface data
:param options: options for link (jitter, bandwidth, etc)
:return: response with result of success or failure
:raises grpc.RpcError: when session or one of the nodes don't exist
"""
link = core_pb2.Link(
node_one_id=node_one_id,
node_two_id=node_two_id,
node1_id=node1_id,
node2_id=node2_id,
type=core_pb2.LinkType.WIRED,
interface_one=interface_one,
interface_two=interface_two,
interface1=interface1,
interface2=interface2,
options=options,
)
request = core_pb2.AddLinkRequest(session_id=session_id, link=link)
@ -641,59 +641,59 @@ class CoreGrpcClient:
def edit_link(
self,
session_id: int,
node_one_id: int,
node_two_id: int,
node1_id: int,
node2_id: int,
options: core_pb2.LinkOptions,
interface_one_id: int = None,
interface_two_id: int = None,
interface1_id: int = None,
interface2_id: int = None,
) -> core_pb2.EditLinkResponse:
"""
Edit a link between nodes.
:param session_id: session id
:param node_one_id: node one id
:param node_two_id: node two id
:param node1_id: node one id
:param node2_id: node two id
:param options: options for link (jitter, bandwidth, etc)
:param interface_one_id: node one interface id
:param interface_two_id: node two interface id
:param interface1_id: node one interface id
:param interface2_id: node two interface id
:return: response with result of success or failure
:raises grpc.RpcError: when session or one of the nodes don't exist
"""
request = core_pb2.EditLinkRequest(
session_id=session_id,
node_one_id=node_one_id,
node_two_id=node_two_id,
node1_id=node1_id,
node2_id=node2_id,
options=options,
interface_one_id=interface_one_id,
interface_two_id=interface_two_id,
interface1_id=interface1_id,
interface2_id=interface2_id,
)
return self.stub.EditLink(request)
def delete_link(
self,
session_id: int,
node_one_id: int,
node_two_id: int,
interface_one_id: int = None,
interface_two_id: int = None,
node1_id: int,
node2_id: int,
interface1_id: int = None,
interface2_id: int = None,
) -> core_pb2.DeleteLinkResponse:
"""
Delete a link between nodes.
:param session_id: session id
:param node_one_id: node one id
:param node_two_id: node two id
:param interface_one_id: node one interface id
:param interface_two_id: node two interface id
:param node1_id: node one id
:param node2_id: node two id
:param interface1_id: node one interface id
:param interface2_id: node two interface id
:return: response with result of success or failure
:raises grpc.RpcError: when session doesn't exist
"""
request = core_pb2.DeleteLinkRequest(
session_id=session_id,
node_one_id=node_one_id,
node_two_id=node_two_id,
interface_one_id=interface_one_id,
interface_two_id=interface_two_id,
node1_id=node1_id,
node2_id=node2_id,
interface1_id=interface1_id,
interface2_id=interface2_id,
)
return self.stub.DeleteLink(request)
@ -1111,20 +1111,20 @@ class CoreGrpcClient:
return self.stub.OpenXml(request)
def emane_link(
self, session_id: int, nem_one: int, nem_two: int, linked: bool
self, session_id: int, nem1: int, nem2: int, linked: bool
) -> EmaneLinkResponse:
"""
Helps broadcast wireless link/unlink between EMANE nodes.
:param session_id: session to emane link
:param nem_one: first nem for emane link
:param nem_two: second nem for emane link
:param nem1: first nem for emane link
:param nem2: second nem for emane link
:param linked: True to link, False to unlink
:return: get emane link response
:raises grpc.RpcError: when session or nodes related to nems do not exist
"""
request = EmaneLinkRequest(
session_id=session_id, nem_one=nem_one, nem_two=nem_two, linked=linked
session_id=session_id, nem1=nem1, nem2=nem2, linked=linked
)
return self.stub.EmaneLink(request)
@ -1243,24 +1243,24 @@ class CoreGrpcClient:
return self.stub.ExecuteScript(request)
def wlan_link(
self, session_id: int, wlan: int, node_one: int, node_two: int, linked: bool
self, session_id: int, wlan_id: int, node1_id: int, node2_id: int, linked: bool
) -> WlanLinkResponse:
"""
Links/unlinks nodes on the same WLAN.
:param session_id: session id containing wlan and nodes
:param wlan: wlan nodes must belong to
:param node_one: first node of pair to link/unlink
:param node_two: second node of pair to link/unlin
:param wlan_id: wlan nodes must belong to
:param node1_id: first node of pair to link/unlink
:param node2_id: second node of pair to link/unlin
:param linked: True to link, False to unlink
:return: wlan link response
:raises grpc.RpcError: when session or one of the nodes do not exist
"""
request = WlanLinkRequest(
session_id=session_id,
wlan=wlan,
node_one=node_one,
node_two=node_two,
wlan=wlan_id,
node1_id=node1_id,
node2_id=node2_id,
linked=linked,
)
return self.stub.WlanLink(request)

44
daemon/core/api/grpc/grpcutils.py
View file

@ -59,13 +59,13 @@ def link_interface(interface_proto: core_pb2.Interface) -> InterfaceData:
:param interface_proto: interface proto
:return: interface data
"""
interface = None
interface_data = None
if interface_proto:
name = interface_proto.name if interface_proto.name else None
mac = interface_proto.mac if interface_proto.mac else None
ip4 = interface_proto.ip4 if interface_proto.ip4 else None
ip6 = interface_proto.ip6 if interface_proto.ip6 else None
interface = InterfaceData(
interface_data = InterfaceData(
id=interface_proto.id,
name=name,
mac=mac,
@ -74,7 +74,7 @@ def link_interface(interface_proto: core_pb2.Interface) -> InterfaceData:
ip6=ip6,
ip6_mask=interface_proto.ip6mask,
)
return interface
return interface_data
def add_link_data(
@ -86,8 +86,8 @@ def add_link_data(
:param link_proto: link proto
:return: link interfaces and options
"""
interface_one = link_interface(link_proto.interface_one)
interface_two = link_interface(link_proto.interface_two)
interface1_data = link_interface(link_proto.interface1)
interface2_data = link_interface(link_proto.interface2)
link_type = LinkTypes(link_proto.type)
options = LinkOptions(type=link_type)
options_data = link_proto.options
@ -103,7 +103,7 @@ def add_link_data(
options.unidirectional = options_data.unidirectional
options.key = options_data.key
options.opaque = options_data.opaque
return interface_one, interface_two, options
return interface1_data, interface2_data, options
def create_nodes(
@ -141,10 +141,10 @@ def create_links(
"""
funcs = []
for link_proto in link_protos:
node_one_id = link_proto.node_one_id
node_two_id = link_proto.node_two_id
interface_one, interface_two, options = add_link_data(link_proto)
args = (node_one_id, node_two_id, interface_one, interface_two, options)
node1_id = link_proto.node1_id
node2_id = link_proto.node2_id
interface1, interface2, options = add_link_data(link_proto)
args = (node1_id, node2_id, interface1, interface2, options)
funcs.append((session.add_link, args, {}))
start = time.monotonic()
results, exceptions = utils.threadpool(funcs)
@ -165,10 +165,10 @@ def edit_links(
"""
funcs = []
for link_proto in link_protos:
node_one_id = link_proto.node_one_id
node_two_id = link_proto.node_two_id
interface_one, interface_two, options = add_link_data(link_proto)
args = (node_one_id, node_two_id, interface_one.id, interface_two.id, options)
node1_id = link_proto.node1_id
node2_id = link_proto.node2_id
interface1, interface2, options = add_link_data(link_proto)
args = (node1_id, node2_id, interface1.id, interface2.id, options)
funcs.append((session.update_link, args, {}))
start = time.monotonic()
results, exceptions = utils.threadpool(funcs)
@ -315,9 +315,9 @@ def convert_link(link_data: LinkData) -> core_pb2.Link:
:param link_data: link to convert
:return: core protobuf Link
"""
interface_one = None
interface1 = None
if link_data.interface1_id is not None:
interface_one = core_pb2.Interface(
interface1 = core_pb2.Interface(
id=link_data.interface1_id,
name=link_data.interface1_name,
mac=convert_value(link_data.interface1_mac),
@ -326,9 +326,9 @@ def convert_link(link_data: LinkData) -> core_pb2.Link:
ip6=convert_value(link_data.interface1_ip6),
ip6mask=link_data.interface1_ip6_mask,
)
interface_two = None
interface2 = None
if link_data.interface2_id is not None:
interface_two = core_pb2.Interface(
interface2 = core_pb2.Interface(
id=link_data.interface2_id,
name=link_data.interface2_name,
mac=convert_value(link_data.interface2_mac),
@ -352,10 +352,10 @@ def convert_link(link_data: LinkData) -> core_pb2.Link:
)
return core_pb2.Link(
type=link_data.link_type.value,
node_one_id=link_data.node1_id,
node_two_id=link_data.node2_id,
interface_one=interface_one,
interface_two=interface_two,
node1_id=link_data.node1_id,
node2_id=link_data.node2_id,
interface1=interface1,
interface2=interface2,
options=options,
network_id=link_data.network_id,
label=link_data.label,

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

@ -845,27 +845,23 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:return: add-link response
"""
logging.debug("add link: %s", request)
# validate session and nodes
session = self.get_session(request.session_id, context)
self.get_node(session, request.link.node_one_id, context, NodeBase)
self.get_node(session, request.link.node_two_id, context, NodeBase)
node_one_id = request.link.node_one_id
node_two_id = request.link.node_two_id
interface_one, interface_two, options = grpcutils.add_link_data(request.link)
node_one_interface, node_two_interface = session.add_link(
node_one_id, node_two_id, interface_one, interface_two, options=options
node1_id = request.link.node1_id
node2_id = request.link.node2_id
self.get_node(session, node1_id, context, NodeBase)
self.get_node(session, node2_id, context, NodeBase)
interface1, interface2, options = grpcutils.add_link_data(request.link)
node1_interface, node2_interface = session.add_link(
node1_id, node2_id, interface1, interface2, options=options
)
interface_one_proto = None
interface_two_proto = None
if node_one_interface:
interface_one_proto = grpcutils.interface_to_proto(node_one_interface)
if node_two_interface:
interface_two_proto = grpcutils.interface_to_proto(node_two_interface)
interface1_proto = None
interface2_proto = None
if node1_interface:
interface1_proto = grpcutils.interface_to_proto(node1_interface)
if node2_interface:
interface2_proto = grpcutils.interface_to_proto(node2_interface)
return core_pb2.AddLinkResponse(
result=True,
interface_one=interface_one_proto,
interface_two=interface_two_proto,
result=True, interface1=interface1_proto, interface2=interface2_proto
)
def EditLink(
@ -880,10 +876,10 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
"""
logging.debug("edit link: %s", request)
session = self.get_session(request.session_id, context)
node_one_id = request.node_one_id
node_two_id = request.node_two_id
interface_one_id = request.interface_one_id
interface_two_id = request.interface_two_id
node1_id = request.node1_id
node2_id = request.node2_id
interface1_id = request.interface1_id
interface2_id = request.interface2_id
options_data = request.options
options = LinkOptions(
delay=options_data.delay,
@ -898,9 +894,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
key=options_data.key,
opaque=options_data.opaque,
)
session.update_link(
node_one_id, node_two_id, interface_one_id, interface_two_id, options
)
session.update_link(node1_id, node2_id, interface1_id, interface2_id, options)
return core_pb2.EditLinkResponse(result=True)
def DeleteLink(
@ -915,13 +909,11 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
"""
logging.debug("delete link: %s", request)
session = self.get_session(request.session_id, context)
node_one_id = request.node_one_id
node_two_id = request.node_two_id
interface_one_id = request.interface_one_id
interface_two_id = request.interface_two_id
session.delete_link(
node_one_id, node_two_id, interface_one_id, interface_two_id
)
node1_id = request.node1_id
node2_id = request.node2_id
interface1_id = request.interface1_id
interface2_id = request.interface2_id
session.delete_link(node1_id, node2_id, interface1_id, interface2_id)
return core_pb2.DeleteLinkResponse(result=True)
def GetHooks(
@ -937,8 +929,8 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
logging.debug("get hooks: %s", request)
session = self.get_session(request.session_id, context)
hooks = []
for state in session._hooks:
state_hooks = session._hooks[state]
for state in session.hooks:
state_hooks = session.hooks[state]
for file_name, file_data in state_hooks:
hook = core_pb2.Hook(state=state.value, file=file_name, data=file_data)
hooks.append(hook)
@ -1520,30 +1512,30 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
"""
logging.debug("emane link: %s", request)
session = self.get_session(request.session_id, context)
nem_one = request.nem_one
emane_one, netif = session.emane.nemlookup(nem_one)
if not emane_one or not netif:
context.abort(grpc.StatusCode.NOT_FOUND, f"nem one {nem_one} not found")
node_one = netif.node
nem1 = request.nem1
emane1, netif = session.emane.nemlookup(nem1)
if not emane1 or not netif:
context.abort(grpc.StatusCode.NOT_FOUND, f"nem one {nem1} not found")
node1 = netif.node
nem_two = request.nem_two
emane_two, netif = session.emane.nemlookup(nem_two)
if not emane_two or not netif:
context.abort(grpc.StatusCode.NOT_FOUND, f"nem two {nem_two} not found")
node_two = netif.node
nem2 = request.nem2
emane2, netif = session.emane.nemlookup(nem2)
if not emane2 or not netif:
context.abort(grpc.StatusCode.NOT_FOUND, f"nem two {nem2} not found")
node2 = netif.node
if emane_one.id == emane_two.id:
if emane1.id == emane2.id:
if request.linked:
flag = MessageFlags.ADD
else:
flag = MessageFlags.DELETE
color = session.get_link_color(emane_one.id)
color = session.get_link_color(emane1.id)
link = LinkData(
message_type=flag,
link_type=LinkTypes.WIRELESS,
node1_id=node_one.id,
node2_id=node_two.id,
network_id=emane_one.id,
node1_id=node1.id,
node2_id=node2.id,
network_id=emane1.id,
color=color,
)
session.broadcast_link(link)
@ -1740,21 +1732,23 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
grpc.StatusCode.NOT_FOUND,
f"wlan node {request.wlan} does not using BasicRangeModel",
)
n1 = self.get_node(session, request.node_one, context, CoreNode)
n2 = self.get_node(session, request.node_two, context, CoreNode)
n1_netif, n2_netif = None, None
for net, netif1, netif2 in n1.commonnets(n2):
node1 = self.get_node(session, request.node1_id, context, CoreNode)
node2 = self.get_node(session, request.node2_id, context, CoreNode)
node1_interface, node2_interface = None, None
for net, interface1, interface2 in node1.commonnets(node2):
if net == wlan:
n1_netif = netif1
n2_netif = netif2
node1_interface = interface1
node2_interface = interface2
break
result = False
if n1_netif and n2_netif:
if node1_interface and node2_interface:
if request.linked:
wlan.link(n1_netif, n2_netif)
wlan.link(node1_interface, node2_interface)
else:
wlan.unlink(n1_netif, n2_netif)
wlan.model.sendlinkmsg(n1_netif, n2_netif, unlink=not request.linked)
wlan.unlink(node1_interface, node2_interface)
wlan.model.sendlinkmsg(
node1_interface, node2_interface, unlink=not request.linked
)
result = True
return WlanLinkResponse(result=result)
@ -1765,9 +1759,9 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
) -> EmanePathlossesResponse:
for request in request_iterator:
session = self.get_session(request.session_id, context)
n1 = self.get_node(session, request.node_one, context, CoreNode)
nem1 = grpcutils.get_nem_id(n1, request.interface_one_id, context)
n2 = self.get_node(session, request.node_two, context, CoreNode)
nem2 = grpcutils.get_nem_id(n2, request.interface_two_id, context)
session.emane.publish_pathloss(nem1, nem2, request.rx_one, request.rx_two)
node1 = self.get_node(session, request.node1_id, context, CoreNode)
nem1 = grpcutils.get_nem_id(node1, request.interface1_id, context)
node2 = self.get_node(session, request.node2_id, context, CoreNode)
nem2 = grpcutils.get_nem_id(node2, request.interface2_id, context)
session.emane.publish_pathloss(nem1, nem2, request.rx1, request.rx2)
return EmanePathlossesResponse()

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

@ -12,6 +12,7 @@ import threading
import time
from itertools import repeat
from queue import Empty, Queue
from typing import Optional
from core import utils
from core.api.tlv import coreapi, dataconversion, structutils
@ -39,6 +40,7 @@ from core.emulator.enumerations import (
NodeTypes,
RegisterTlvs,
)
from core.emulator.session import Session
from core.errors import CoreCommandError, CoreError
from core.location.mobility import BasicRangeModel
from core.nodes.base import CoreNode, CoreNodeBase, NodeBase
@ -83,7 +85,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
thread.start()
self.handler_threads.append(thread)
self.session = None
self.session: Optional[Session] = None
self.coreemu = server.coreemu
utils.close_onexec(request.fileno())
socketserver.BaseRequestHandler.__init__(self, request, client_address, server)
@ -176,7 +178,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
node_count_list.append(str(session.get_node_count()))
date_list.append(time.ctime(session._state_time))
date_list.append(time.ctime(session.state_time))
thumb = session.thumbnail
if not thumb:
@ -745,10 +747,9 @@ class CoreHandler(socketserver.BaseRequestHandler):
:param core.api.tlv.coreapi.CoreLinkMessage message: link message to handle
:return: link message replies
"""
node_one_id = message.get_tlv(LinkTlvs.N1_NUMBER.value)
node_two_id = message.get_tlv(LinkTlvs.N2_NUMBER.value)
interface_one = InterfaceData(
node1_id = message.get_tlv(LinkTlvs.N1_NUMBER.value)
node2_id = message.get_tlv(LinkTlvs.N2_NUMBER.value)
interface1_data = InterfaceData(
id=message.get_tlv(LinkTlvs.INTERFACE1_NUMBER.value),
name=message.get_tlv(LinkTlvs.INTERFACE1_NAME.value),
mac=message.get_tlv(LinkTlvs.INTERFACE1_MAC.value),
@ -757,7 +758,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
ip6=message.get_tlv(LinkTlvs.INTERFACE1_IP6.value),
ip6_mask=message.get_tlv(LinkTlvs.INTERFACE1_IP6_MASK.value),
)
interface_two = InterfaceData(
interface2_data = InterfaceData(
id=message.get_tlv(LinkTlvs.INTERFACE2_NUMBER.value),
name=message.get_tlv(LinkTlvs.INTERFACE2_NAME.value),
mac=message.get_tlv(LinkTlvs.INTERFACE2_MAC.value),
@ -766,45 +767,39 @@ class CoreHandler(socketserver.BaseRequestHandler):
ip6=message.get_tlv(LinkTlvs.INTERFACE2_IP6.value),
ip6_mask=message.get_tlv(LinkTlvs.INTERFACE2_IP6_MASK.value),
)
link_type = LinkTypes.WIRED
link_type_value = message.get_tlv(LinkTlvs.TYPE.value)
if link_type_value is not None:
link_type = LinkTypes(link_type_value)
options = LinkOptions(type=link_type)
options.delay = message.get_tlv(LinkTlvs.DELAY.value)
options.bandwidth = message.get_tlv(LinkTlvs.BANDWIDTH.value)
options.session = message.get_tlv(LinkTlvs.SESSION.value)
options.loss = message.get_tlv(LinkTlvs.LOSS.value)
options.dup = message.get_tlv(LinkTlvs.DUP.value)
options.jitter = message.get_tlv(LinkTlvs.JITTER.value)
options.mer = message.get_tlv(LinkTlvs.MER.value)
options.burst = message.get_tlv(LinkTlvs.BURST.value)
options.mburst = message.get_tlv(LinkTlvs.MBURST.value)
options.gui_attributes = message.get_tlv(LinkTlvs.GUI_ATTRIBUTES.value)
options.unidirectional = message.get_tlv(LinkTlvs.UNIDIRECTIONAL.value)
options.emulation_id = message.get_tlv(LinkTlvs.EMULATION_ID.value)
options.network_id = message.get_tlv(LinkTlvs.NETWORK_ID.value)
options.key = message.get_tlv(LinkTlvs.KEY.value)
options.opaque = message.get_tlv(LinkTlvs.OPAQUE.value)
link_options = LinkOptions(type=link_type)
link_options.delay = message.get_tlv(LinkTlvs.DELAY.value)
link_options.bandwidth = message.get_tlv(LinkTlvs.BANDWIDTH.value)
link_options.session = message.get_tlv(LinkTlvs.SESSION.value)
link_options.loss = message.get_tlv(LinkTlvs.LOSS.value)
link_options.dup = message.get_tlv(LinkTlvs.DUP.value)
link_options.jitter = message.get_tlv(LinkTlvs.JITTER.value)
link_options.mer = message.get_tlv(LinkTlvs.MER.value)
link_options.burst = message.get_tlv(LinkTlvs.BURST.value)
link_options.mburst = message.get_tlv(LinkTlvs.MBURST.value)
link_options.gui_attributes = message.get_tlv(LinkTlvs.GUI_ATTRIBUTES.value)
link_options.unidirectional = message.get_tlv(LinkTlvs.UNIDIRECTIONAL.value)
link_options.emulation_id = message.get_tlv(LinkTlvs.EMULATION_ID.value)
link_options.network_id = message.get_tlv(LinkTlvs.NETWORK_ID.value)
link_options.key = message.get_tlv(LinkTlvs.KEY.value)
link_options.opaque = message.get_tlv(LinkTlvs.OPAQUE.value)
if message.flags & MessageFlags.ADD.value:
self.session.add_link(
node_one_id, node_two_id, interface_one, interface_two, link_options
node1_id, node2_id, interface1_data, interface2_data, options
)
elif message.flags & MessageFlags.DELETE.value:
self.session.delete_link(
node_one_id, node_two_id, interface_one.id, interface_two.id
node1_id, node2_id, interface1_data.id, interface2_data.id
)
else:
self.session.update_link(
node_one_id,
node_two_id,
interface_one.id,
interface_two.id,
link_options,
node1_id, node2_id, interface1_data.id, interface2_data.id, options
)
return ()
def handle_execute_message(self, message):
@ -1827,7 +1822,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
"""
# find all nodes and links
links_data = []
with self.session._nodes_lock:
with self.session.nodes_lock:
for node_id in self.session.nodes:
node = self.session.nodes[node_id]
self.session.broadcast_node(node, MessageFlags.ADD)
@ -1905,8 +1900,8 @@ class CoreHandler(socketserver.BaseRequestHandler):
# TODO: send location info
# send hook scripts
for state in sorted(self.session._hooks.keys()):
for file_name, config_data in self.session._hooks[state]:
for state in sorted(self.session.hooks.keys()):
for file_name, config_data in self.session.hooks[state]:
file_data = FileData(
message_type=MessageFlags.ADD,
name=str(file_name),

2
daemon/core/emane/emanemanager.py
View file

@ -279,7 +279,7 @@ class EmaneManager(ModelManager):
logging.debug("emane setup")
# TODO: drive this from the session object
with self.session._nodes_lock:
with self.session.nodes_lock:
for node_id in self.session.nodes:
node = self.session.nodes[node_id]
if isinstance(node, EmaneNet):

20
daemon/core/emane/linkmonitor.py
View file

@ -269,11 +269,11 @@ class EmaneLinkMonitor:
self.scheduler.enter(self.link_interval, 0, self.check_links)
def get_complete_id(self, link_id: Tuple[int, int]) -> Tuple[int, int]:
value_one, value_two = link_id
if value_one < value_two:
return value_one, value_two
value1, value2 = link_id
if value1 < value2:
return value1, value2
else:
return value_two, value_one
return value2, value1
def is_complete_link(self, link_id: Tuple[int, int]) -> bool:
reverse_id = link_id[1], link_id[0]
@ -287,8 +287,8 @@ class EmaneLinkMonitor:
return f"{source_link.sinr:.1f} / {dest_link.sinr:.1f}"
def send_link(self, message_type: MessageFlags, link_id: Tuple[int, int]) -> None:
nem_one, nem_two = link_id
link = self.emane_manager.get_nem_link(nem_one, nem_two, message_type)
nem1, nem2 = link_id
link = self.emane_manager.get_nem_link(nem1, nem2, message_type)
if link:
label = self.get_link_label(link_id)
link.label = label
@ -298,16 +298,16 @@ class EmaneLinkMonitor:
self,
message_type: MessageFlags,
label: str,
node_one: int,
node_two: int,
node1: int,
node2: int,
emane_id: int,
) -> None:
color = self.emane_manager.session.get_link_color(emane_id)
link_data = LinkData(
message_type=message_type,
label=label,
node1_id=node_one,
node2_id=node_two,
node1_id=node1,
node2_id=node2,
network_id=emane_id,
link_type=LinkTypes.WIRELESS,
color=color,

12
daemon/core/emulator/distributed.py
View file

@ -224,18 +224,20 @@ class DistributedController:
self.tunnels[key] = tunnel
return tunnel
def tunnel_key(self, n1_id: int, n2_id: int) -> int:
def tunnel_key(self, node1_id: int, node2_id: int) -> int:
"""
Compute a 32-bit key used to uniquely identify a GRE tunnel.
The hash(n1num), hash(n2num) values are used, so node numbers may be
None or string values (used for e.g. "ctrlnet").
:param n1_id: node one id
:param n2_id: node two id
:param node1_id: node one id
:param node2_id: node two id
:return: tunnel key for the node pair
"""
logging.debug("creating tunnel key for: %s, %s", n1_id, n2_id)
logging.debug("creating tunnel key for: %s, %s", node1_id, node2_id)
key = (
(self.session.id << 16) ^ utils.hashkey(n1_id) ^ (utils.hashkey(n2_id) << 8)
(self.session.id << 16)
^ utils.hashkey(node1_id)
^ (utils.hashkey(node2_id) << 8)
)
return key & 0xFFFFFFFF

6
daemon/core/emulator/emudata.py
View file

@ -201,6 +201,6 @@ class IpPrefixes:
generation
:return: new interface data for the provided node
"""
interface = self.gen_interface(node.id, name, mac)
interface.id = node.newifindex()
return interface
interface_data = self.gen_interface(node.id, name, mac)
interface_data.id = node.newifindex()
return interface_data

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

@ -6,7 +6,6 @@ that manages a CORE session.
import logging
import os
import pwd
import random
import shutil
import subprocess
import tempfile
@ -113,15 +112,13 @@ class Session:
# dict of nodes: all nodes and nets
self.nodes: Dict[int, NodeBase] = {}
self._nodes_lock = threading.Lock()
self.nodes_lock = threading.Lock()
# states and hooks handlers
self.state: EventTypes = EventTypes.DEFINITION_STATE
self._state_time: float = time.monotonic()
self._state_file: str = os.path.join(self.session_dir, "state")
# hooks handlers
self._hooks: Dict[EventTypes, Tuple[str, str]] = {}
self._state_hooks: Dict[EventTypes, Callable[[int], None]] = {}
self.state_time: float = time.monotonic()
self.hooks: Dict[EventTypes, Tuple[str, str]] = {}
self.state_hooks: Dict[EventTypes, List[Callable[[EventTypes], None]]] = {}
self.add_state_hook(
state=EventTypes.RUNTIME_STATE, hook=self.runtime_state_hook
)
@ -154,15 +151,6 @@ class Session:
self.emane: EmaneManager = EmaneManager(self)
self.sdt: Sdt = Sdt(self)
# initialize default node services
self.services.default_services = {
"mdr": ("zebra", "OSPFv3MDR", "IPForward"),
"PC": ("DefaultRoute",),
"prouter": (),
"router": ("zebra", "OSPFv2", "OSPFv3", "IPForward"),
"host": ("DefaultRoute", "SSH"),
}
# config services
self.service_manager: Optional[ConfigServiceManager] = None
@ -194,13 +182,13 @@ class Session:
return node_type
def _link_wireless(
self, node_one: CoreNodeBase, node_two: CoreNodeBase, connect: bool
self, node1: CoreNodeBase, node2: CoreNodeBase, connect: bool
) -> None:
"""
Objects to deal with when connecting/disconnecting wireless links.
:param node_one: node one for wireless link
:param node_two: node two for wireless link
:param node1: node one for wireless link
:param node2: node two for wireless link
:param connect: link interfaces if True, unlink otherwise
:return: nothing
:raises core.CoreError: when objects to link is less than 2, or no common
@ -208,14 +196,14 @@ class Session:
"""
logging.info(
"handling wireless linking node1(%s) node2(%s): %s",
node_one.name,
node_two.name,
node1.name,
node2.name,
connect,
)
common_networks = node_one.commonnets(node_one)
common_networks = node1.commonnets(node1)
if not common_networks:
raise CoreError("no common network found for wireless link/unlink")
for common_network, interface_one, interface_two in common_networks:
for common_network, interface1, interface2 in common_networks:
if not isinstance(common_network, (WlanNode, EmaneNet)):
logging.info(
"skipping common network that is not wireless/emane: %s",
@ -223,26 +211,26 @@ class Session:
)
continue
if connect:
common_network.link(interface_one, interface_two)
common_network.link(interface1, interface2)
else:
common_network.unlink(interface_one, interface_two)
common_network.unlink(interface1, interface2)
def add_link(
self,
node_one_id: int,
node_two_id: int,
interface_one: InterfaceData = None,
interface_two: InterfaceData = None,
node1_id: int,
node2_id: int,
interface1_data: InterfaceData = None,
interface2_data: InterfaceData = None,
options: LinkOptions = None,
) -> Tuple[CoreInterface, CoreInterface]:
"""
Add a link between nodes.
:param node_one_id: node one id
:param node_two_id: node two id
:param interface_one: node one interface
:param node1_id: node one id
:param node2_id: node two id
:param interface1_data: node one interface
data, defaults to none
:param interface_two: node two interface
:param interface2_data: node two interface
data, defaults to none
:param options: data for creating link,
defaults to no options
@ -250,10 +238,10 @@ class Session:
"""
if not options:
options = LinkOptions()
node1 = self.get_node(node_one_id, NodeBase)
node2 = self.get_node(node_two_id, NodeBase)
node1_interface = None
node2_interface = None
node1 = self.get_node(node1_id, NodeBase)
node2 = self.get_node(node2_id, NodeBase)
interface1 = None
interface2 = None
# wireless link
if options.type == LinkTypes.WIRELESS:
@ -270,22 +258,22 @@ class Session:
logging.info("linking ptp: %s - %s", node1.name, node2.name)
start = self.state.should_start()
ptp = self.create_node(PtpNet, start=start)
node1_interface = node1.newnetif(ptp, interface_one)
node2_interface = node2.newnetif(ptp, interface_two)
ptp.linkconfig(node1_interface, options)
interface1 = node1.newnetif(ptp, interface1_data)
interface2 = node2.newnetif(ptp, interface2_data)
ptp.linkconfig(interface1, options)
if not options.unidirectional:
ptp.linkconfig(node2_interface, options)
ptp.linkconfig(interface2, options)
# link node to net
elif isinstance(node1, CoreNodeBase) and isinstance(node2, CoreNetworkBase):
node1_interface = node1.newnetif(node2, interface_one)
interface1 = node1.newnetif(node2, interface1_data)
if not isinstance(node2, (EmaneNet, WlanNode)):
node2.linkconfig(node1_interface, options)
node2.linkconfig(interface1, options)
# link net to node
elif isinstance(node2, CoreNodeBase) and isinstance(node1, CoreNetworkBase):
node2_interface = node2.newnetif(node1, interface_two)
interface2 = node2.newnetif(node1, interface2_data)
wireless_net = isinstance(node1, (EmaneNet, WlanNode))
if not options.unidirectional and not wireless_net:
node1.linkconfig(node2_interface, options)
node1.linkconfig(interface2, options)
# network to network
elif isinstance(node1, CoreNetworkBase) and isinstance(
node2, CoreNetworkBase
@ -293,12 +281,12 @@ class Session:
logging.info(
"linking network to network: %s - %s", node1.name, node2.name
)
node1_interface = node1.linknet(node2)
node1.linkconfig(node1_interface, options)
interface1 = node1.linknet(node2)
node1.linkconfig(interface1, options)
if not options.unidirectional:
node1_interface.swapparams("_params_up")
node2.linkconfig(node1_interface, options)
node1_interface.swapparams("_params_up")
interface1.swapparams("_params_up")
node2.linkconfig(interface1, options)
interface1.swapparams("_params_up")
else:
raise CoreError(
f"cannot link node1({type(node1)}) node2({type(node2)})"
@ -308,41 +296,41 @@ class Session:
key = options.key
if isinstance(node1, TunnelNode):
logging.info("setting tunnel key for: %s", node1.name)
node1.setkey(key, interface_one)
node1.setkey(key, interface1_data)
if isinstance(node2, TunnelNode):
logging.info("setting tunnel key for: %s", node2.name)
node2.setkey(key, interface_two)
self.sdt.add_link(node_one_id, node_two_id)
return node1_interface, node2_interface
node2.setkey(key, interface2_data)
self.sdt.add_link(node1_id, node2_id)
return interface1, interface2
def delete_link(
self,
node_one_id: int,
node_two_id: int,
interface_one_id: int = None,
interface_two_id: int = None,
node1_id: int,
node2_id: int,
interface1_id: int = None,
interface2_id: int = None,
link_type: LinkTypes = LinkTypes.WIRED,
) -> None:
"""
Delete a link between nodes.
:param node_one_id: node one id
:param node_two_id: node two id
:param interface_one_id: interface id for node one
:param interface_two_id: interface id for node two
:param node1_id: node one id
:param node2_id: node two id
:param interface1_id: interface id for node one
:param interface2_id: interface id for node two
:param link_type: link type to delete
:return: nothing
:raises core.CoreError: when no common network is found for link being deleted
"""
node1 = self.get_node(node_one_id, NodeBase)
node2 = self.get_node(node_two_id, NodeBase)
node1 = self.get_node(node1_id, NodeBase)
node2 = self.get_node(node2_id, NodeBase)
logging.info(
"deleting link(%s) node(%s):interface(%s) node(%s):interface(%s)",
link_type.name,
node1.name,
interface_one_id,
interface1_id,
node2.name,
interface_two_id,
interface2_id,
)
# wireless link
@ -357,15 +345,15 @@ class Session:
# wired link
else:
if isinstance(node1, CoreNodeBase) and isinstance(node2, CoreNodeBase):
interface1 = node1.netif(interface_one_id)
interface2 = node2.netif(interface_two_id)
interface1 = node1.netif(interface1_id)
interface2 = node2.netif(interface2_id)
if not interface1:
raise CoreError(
f"node({node1.name}) missing interface({interface_one_id})"
f"node({node1.name}) missing interface({interface1_id})"
)
if not interface2:
raise CoreError(
f"node({node2.name}) missing interface({interface_two_id})"
f"node({node2.name}) missing interface({interface2_id})"
)
if interface1.net != interface2.net:
raise CoreError(
@ -373,30 +361,30 @@ class Session:
"not connected to same net"
)
ptp = interface1.net
node1.delnetif(interface_one_id)
node2.delnetif(interface_two_id)
node1.delnetif(interface1_id)
node2.delnetif(interface2_id)
self.delete_node(ptp.id)
elif isinstance(node1, CoreNodeBase) and isinstance(node2, CoreNetworkBase):
node1.delnetif(interface_one_id)
node1.delnetif(interface1_id)
elif isinstance(node2, CoreNodeBase) and isinstance(node1, CoreNetworkBase):
node2.delnetif(interface_two_id)
self.sdt.delete_link(node_one_id, node_two_id)
node2.delnetif(interface2_id)
self.sdt.delete_link(node1_id, node2_id)
def update_link(
self,
node_one_id: int,
node_two_id: int,
interface_one_id: int = None,
interface_two_id: int = None,
node1_id: int,
node2_id: int,
interface1_id: int = None,
interface2_id: int = None,
options: LinkOptions = None,
) -> None:
"""
Update link information between nodes.
:param node_one_id: node one id
:param node_two_id: node two id
:param interface_one_id: interface id for node one
:param interface_two_id: interface id for node two
:param node1_id: node one id
:param node2_id: node two id
:param interface1_id: interface id for node one
:param interface2_id: interface id for node two
:param options: data to update link with
:return: nothing
:raises core.CoreError: when updating a wireless type link, when there is a
@ -404,15 +392,15 @@ class Session:
"""
if not options:
options = LinkOptions()
node1 = self.get_node(node_one_id, NodeBase)
node2 = self.get_node(node_two_id, NodeBase)
node1 = self.get_node(node1_id, NodeBase)
node2 = self.get_node(node2_id, NodeBase)
logging.info(
"update link(%s) node(%s):interface(%s) node(%s):interface(%s)",
options.type.name,
node1.name,
interface_one_id,
interface1_id,
node2.name,
interface_two_id,
interface2_id,
)
# wireless link
@ -420,15 +408,15 @@ class Session:
raise CoreError("cannot update wireless link")
else:
if isinstance(node1, CoreNodeBase) and isinstance(node2, CoreNodeBase):
interface1 = node1.netif(interface_one_id)
interface2 = node2.netif(interface_two_id)
interface1 = node1.netif(interface1_id)
interface2 = node2.netif(interface2_id)
if not interface1:
raise CoreError(
f"node({node1.name}) missing interface({interface_one_id})"
f"node({node1.name}) missing interface({interface1_id})"
)
if not interface2:
raise CoreError(
f"node({node2.name}) missing interface({interface_two_id})"
f"node({node2.name}) missing interface({interface2_id})"
)
if interface1.net != interface2.net:
raise CoreError(
@ -440,10 +428,10 @@ class Session:
if not options.unidirectional:
ptp.linkconfig(interface2, options, interface1)
elif isinstance(node1, CoreNodeBase) and isinstance(node2, CoreNetworkBase):
interface = node1.netif(interface_one_id)
interface = node1.netif(interface1_id)
node2.linkconfig(interface, options)
elif isinstance(node2, CoreNodeBase) and isinstance(node1, CoreNetworkBase):
interface = node2.netif(interface_two_id)
interface = node2.netif(interface2_id)
node1.linkconfig(interface, options)
elif isinstance(node1, CoreNetworkBase) and isinstance(
node2, CoreNetworkBase
@ -473,7 +461,7 @@ class Session:
f"cannot update link node1({type(node1)}) node2({type(node2)})"
)
def _next_node_id(self) -> int:
def next_node_id(self) -> int:
"""
Find the next valid node id, starting from 1.
@ -506,7 +494,7 @@ class Session:
# determine node id
if not _id:
_id = self._next_node_id()
_id = self.next_node_id()
# generate name if not provided
if not options:
@ -692,7 +680,7 @@ class Session:
"setting state hook: %s - %s source(%s)", state, file_name, source_name
)
hook = file_name, data
state_hooks = self._hooks.setdefault(state, [])
state_hooks = self.hooks.setdefault(state, [])
state_hooks.append(hook)
# immediately run a hook if it is in the current state
@ -727,7 +715,7 @@ class Session:
self.emane.shutdown()
self.delete_nodes()
self.distributed.shutdown()
self.del_hooks()
self.hooks.clear()
self.emane.reset()
self.emane.config_reset()
self.location.reset()
@ -795,7 +783,6 @@ class Session:
:param event_data: event data to send out
:return: nothing
"""
for handler in self.event_handlers:
handler(event_data)
@ -806,7 +793,6 @@ class Session:
:param exception_data: exception data to send out
:return: nothing
"""
for handler in self.exception_handlers:
handler(exception_data)
@ -837,7 +823,6 @@ class Session:
:param file_data: file data to send out
:return: nothing
"""
for handler in self.file_handlers:
handler(file_data)
@ -848,7 +833,6 @@ class Session:
:param config_data: config data to send out
:return: nothing
"""
for handler in self.config_handlers:
handler(config_data)
@ -859,7 +843,6 @@ class Session:
:param link_data: link data to send out
:return: nothing
"""
for handler in self.link_handlers:
handler(link_data)
@ -871,22 +854,14 @@ class Session:
:param send_event: if true, generate core API event messages
:return: nothing
"""
state_name = state.name
if self.state == state:
logging.info(
"session(%s) is already in state: %s, skipping change",
self.id,
state_name,
)
return
self.state = state
self._state_time = time.monotonic()
logging.info("changing session(%s) to state %s", self.id, state_name)
self.state_time = time.monotonic()
logging.info("changing session(%s) to state %s", self.id, state.name)
self.write_state(state)
self.run_hooks(state)
self.run_state_hooks(state)
if send_event:
event_data = EventData(event_type=state, time=str(time.monotonic()))
self.broadcast_event(event_data)
@ -898,10 +873,10 @@ class Session:
:param state: state to write to file
:return: nothing
"""
state_file = os.path.join(self.session_dir, "state")
try:
state_file = open(self._state_file, "w")
state_file.write(f"{state.value} {state.name}\n")
state_file.close()
with open(state_file, "w") as f:
f.write(f"{state.value} {state.name}\n")
except IOError:
logging.exception("error writing state file: %s", state.name)
@ -913,61 +888,10 @@ class Session:
:param state: state to run hooks for
:return: nothing
"""
# check that state change hooks exist
if state not in self._hooks:
return
# retrieve all state hooks
hooks = self._hooks.get(state, [])
# execute all state hooks
if hooks:
for hook in hooks:
self.run_hook(hook)
else:
logging.info("no state hooks for %s", state)
def set_hook(
self, hook_type: str, file_name: str, source_name: str, data: str
) -> None:
"""
Store a hook from a received file message.
:param hook_type: hook type
:param file_name: file name for hook
:param source_name: source name
:param data: hook data
:return: nothing
"""
logging.info(
"setting state hook: %s - %s from %s", hook_type, file_name, source_name
)
_hook_id, state = hook_type.split(":")[:2]
if not state.isdigit():
logging.error("error setting hook having state '%s'", state)
return
state = int(state)
hook = file_name, data
# append hook to current state hooks
state_hooks = self._hooks.setdefault(state, [])
state_hooks.append(hook)
# immediately run a hook if it is in the current state
# (this allows hooks in the definition and configuration states)
if self.state == state:
logging.info("immediately running new state hook")
hooks = self.hooks.get(state, [])
for hook in hooks:
self.run_hook(hook)
def del_hooks(self) -> None:
"""
Clear the hook scripts dict.
"""
self._hooks.clear()
def run_hook(self, hook: Tuple[str, str]) -> None:
"""
Run a hook.
@ -977,37 +901,23 @@ class Session:
"""
file_name, data = hook
logging.info("running hook %s", file_name)
# write data to hook file
file_path = os.path.join(self.session_dir, file_name)
log_path = os.path.join(self.session_dir, f"{file_name}.log")
try:
hook_file = open(os.path.join(self.session_dir, file_name), "w")
hook_file.write(data)
hook_file.close()
except IOError:
logging.exception("error writing hook '%s'", file_name)
# setup hook stdout and stderr
try:
stdout = open(os.path.join(self.session_dir, file_name + ".log"), "w")
stderr = subprocess.STDOUT
except IOError:
logging.exception("error setting up hook stderr and stdout")
stdout = None
stderr = None
# execute hook file
try:
args = ["/bin/sh", file_name]
subprocess.check_call(
args,
stdout=stdout,
stderr=stderr,
close_fds=True,
cwd=self.session_dir,
env=self.get_environment(),
)
except (OSError, subprocess.CalledProcessError):
logging.exception("error running hook: %s", file_name)
with open(file_path, "w") as f:
f.write(data)
with open(log_path, "w") as f:
args = ["/bin/sh", file_name]
subprocess.check_call(
args,
stdout=f,
stderr=subprocess.STDOUT,
close_fds=True,
cwd=self.session_dir,
env=self.get_environment(),
)
except (IOError, subprocess.CalledProcessError):
logging.exception("error running hook: %s", file_path)
def run_state_hooks(self, state: EventTypes) -> None:
"""
@ -1016,17 +926,16 @@ class Session:
:param state: state to run hooks for
:return: nothing
"""
for hook in self._state_hooks.get(state, []):
try:
hook(state)
except Exception:
message = (
f"exception occured when running {state.name} state hook: {hook}"
)
logging.exception(message)
self.exception(
ExceptionLevels.ERROR, "Session.run_state_hooks", message
)
for hook in self.state_hooks.get(state, []):
self.run_state_hook(state, hook)
def run_state_hook(self, state: EventTypes, hook: Callable[[EventTypes], None]):
try:
hook(state)
except Exception:
message = f"exception occurred when running {state.name} state hook: {hook}"
logging.exception(message)
self.exception(ExceptionLevels.ERROR, "Session.run_state_hooks", message)
def add_state_hook(
self, state: EventTypes, hook: Callable[[EventTypes], None]
@ -1038,15 +947,16 @@ class Session:
:param hook: hook callback for the state
:return: nothing
"""
hooks = self._state_hooks.setdefault(state, [])
hooks = self.state_hooks.setdefault(state, [])
if hook in hooks:
raise CoreError("attempting to add duplicate state hook")
hooks.append(hook)
if self.state == state:
hook(state)
self.run_state_hook(state, hook)
def del_state_hook(self, state: int, hook: Callable[[int], None]) -> None:
def del_state_hook(
self, state: EventTypes, hook: Callable[[EventTypes], None]
) -> None:
"""
Delete a state hook.
@ -1054,24 +964,23 @@ class Session:
:param hook: hook to delete
:return: nothing
"""
hooks = self._state_hooks.setdefault(state, [])
hooks.remove(hook)
hooks = self.state_hooks.get(state, [])
if hook in hooks:
hooks.remove(hook)
def runtime_state_hook(self, state: EventTypes) -> None:
def runtime_state_hook(self, _state: EventTypes) -> None:
"""
Runtime state hook check.
:param state: state to check
:param _state: state to check
:return: nothing
"""
if state == EventTypes.RUNTIME_STATE:
self.emane.poststartup()
# create session deployed xml
xml_file_name = os.path.join(self.session_dir, "session-deployed.xml")
xml_writer = corexml.CoreXmlWriter(self)
corexmldeployment.CoreXmlDeployment(self, xml_writer.scenario)
xml_writer.write(xml_file_name)
self.emane.poststartup()
# create session deployed xml
xml_file_name = os.path.join(self.session_dir, "session-deployed.xml")
xml_writer = corexml.CoreXmlWriter(self)
corexmldeployment.CoreXmlDeployment(self, xml_writer.scenario)
xml_writer.write(xml_file_name)
def get_environment(self, state: bool = True) -> Dict[str, str]:
"""
@ -1090,10 +999,8 @@ class Session:
env["SESSION_FILENAME"] = str(self.file_name)
env["SESSION_USER"] = str(self.user)
env["SESSION_NODE_COUNT"] = str(self.get_node_count())
if state:
env["SESSION_STATE"] = str(self.state)
# attempt to read and add environment config file
environment_config_file = os.path.join(constants.CORE_CONF_DIR, "environment")
try:
@ -1104,7 +1011,6 @@ class Session:
"environment configuration file does not exist: %s",
environment_config_file,
)
# attempt to read and add user environment file
if self.user:
environment_user_file = os.path.join(
@ -1117,7 +1023,6 @@ class Session:
"user core environment settings file not present: %s",
environment_user_file,
)
return env
def set_thumbnail(self, thumb_file: str) -> None:
@ -1131,7 +1036,6 @@ class Session:
logging.error("thumbnail file to set does not exist: %s", thumb_file)
self.thumbnail = None
return
destination_file = os.path.join(self.session_dir, os.path.basename(thumb_file))
shutil.copy(thumb_file, destination_file)
self.thumbnail = destination_file
@ -1151,20 +1055,8 @@ class Session:
os.chown(self.session_dir, uid, gid)
except IOError:
logging.exception("failed to set permission on %s", self.session_dir)
self.user = user
def get_node_id(self) -> int:
"""
Return a unique, new node id.
"""
with self._nodes_lock:
while True:
node_id = random.randint(1, 0xFFFF)
if node_id not in self.nodes:
break
return node_id
def create_node(self, _class: Type[NT], *args: Any, **kwargs: Any) -> NT:
"""
Create an emulation node.
@ -1176,7 +1068,7 @@ class Session:
:raises core.CoreError: when id of the node to create already exists
"""
node = _class(self, *args, **kwargs)
with self._nodes_lock:
with self.nodes_lock:
if node.id in self.nodes:
node.shutdown()
raise CoreError(f"duplicate node id {node.id} for {node.name}")
@ -1192,9 +1084,9 @@ class Session:
:return: node for the given id
:raises core.CoreError: when node does not exist
"""
if _id not in self.nodes:
node = self.nodes.get(_id)
if node is None:
raise CoreError(f"unknown node id {_id}")
node = self.nodes[_id]
if not isinstance(node, _class):
actual = node.__class__.__name__
expected = _class.__name__
@ -1210,7 +1102,7 @@ class Session:
"""
# delete node and check for session shutdown if a node was removed
node = None
with self._nodes_lock:
with self.nodes_lock:
if _id in self.nodes:
node = self.nodes.pop(_id)
logging.info("deleted node(%s)", node.name)
@ -1224,7 +1116,7 @@ class Session:
"""
Clear the nodes dictionary, and call shutdown for each node.
"""
with self._nodes_lock:
with self.nodes_lock:
funcs = []
while self.nodes:
_, node = self.nodes.popitem()
@ -1237,29 +1129,15 @@ class Session:
Write nodes to a 'nodes' file in the session dir.
The 'nodes' file lists: number, name, api-type, class-type
"""
file_path = os.path.join(self.session_dir, "nodes")
try:
with self._nodes_lock:
file_path = os.path.join(self.session_dir, "nodes")
with self.nodes_lock:
with open(file_path, "w") as f:
for _id in self.nodes.keys():
node = self.nodes[_id]
for _id, node in self.nodes.items():
f.write(f"{_id} {node.name} {node.apitype} {type(node)}\n")
except IOError:
logging.exception("error writing nodes file")
def dump_session(self) -> None:
"""
Log information about the session in its current state.
"""
logging.info("session id=%s name=%s state=%s", self.id, self.name, self.state)
logging.info(
"file=%s thumbnail=%s node_count=%s/%s",
self.file_name,
self.thumbnail,
self.get_node_count(),
len(self.nodes),
)
def exception(
self, level: ExceptionLevels, source: str, text: str, node_id: int = None
) -> None:
@ -1327,17 +1205,15 @@ class Session:
:return: created node count
"""
with self._nodes_lock:
with self.nodes_lock:
count = 0
for node_id in self.nodes:
node = self.nodes[node_id]
for node in self.nodes.values():
is_p2p_ctrlnet = isinstance(node, (PtpNet, CtrlNet))
is_tap = isinstance(node, GreTapBridge) and not isinstance(
node, TunnelNode
)
if is_p2p_ctrlnet or is_tap:
continue
count += 1
return count
@ -1359,7 +1235,6 @@ class Session:
if self.state == EventTypes.RUNTIME_STATE:
logging.info("valid runtime state found, returning")
return
# start event loop and set to runtime
self.event_loop.run()
self.set_state(EventTypes.RUNTIME_STATE, send_event=True)
@ -1375,7 +1250,7 @@ class Session:
self.event_loop.stop()
# stop node services
with self._nodes_lock:
with self.nodes_lock:
funcs = []
for node_id in self.nodes:
node = self.nodes[node_id]
@ -1447,7 +1322,7 @@ class Session:
:return: service boot exceptions
"""
with self._nodes_lock:
with self.nodes_lock:
funcs = []
start = time.monotonic()
for _id in self.nodes:
@ -1545,7 +1420,6 @@ class Session:
else:
prefix_spec = CtrlNet.DEFAULT_PREFIX_LIST[net_index]
logging.debug("prefix spec: %s", prefix_spec)
server_interface = self.get_control_net_server_interfaces()[net_index]
# return any existing controlnet bridge
@ -1685,7 +1559,7 @@ class Session:
if not in runtime.
"""
if self.state == EventTypes.RUNTIME_STATE:
return time.monotonic() - self._state_time
return time.monotonic() - self.state_time
else:
return 0.0
@ -1708,7 +1582,6 @@ class Session:
"""
event_time = float(event_time)
current_time = self.runtime()
if current_time > 0:
if event_time <= current_time:
logging.warning(
@ -1718,11 +1591,9 @@ class Session:
)
return
event_time = event_time - current_time
self.event_loop.add_event(
event_time, self.run_event, node=node, name=name, data=data
)
if not name:
name = ""
logging.info(
@ -1732,8 +1603,6 @@ class Session:
data,
)
# TODO: if data is None, this blows up, but this ties into how event functions
# are ran, need to clean that up
def run_event(
self, node_id: int = None, name: str = None, data: str = None
) -> None:
@ -1745,10 +1614,12 @@ class Session:
:param data: event data
:return: nothing
"""
if data is None:
logging.warning("no data for event node(%s) name(%s)", node_id, name)
return
now = self.runtime()
if not name:
name = ""
logging.info("running event %s at time %s cmd=%s", name, now, data)
if not node_id:
utils.mute_detach(data)

58
daemon/core/gui/coreclient.py
View file

@ -164,25 +164,19 @@ class CoreClient:
def handle_link_event(self, event: core_pb2.LinkEvent):
logging.debug("Link event: %s", event)
node_one_id = event.link.node_one_id
node_two_id = event.link.node_two_id
if node_one_id == node_two_id:
node1_id = event.link.node1_id
node2_id = event.link.node2_id
if node1_id == node2_id:
logging.warning("ignoring links with loops: %s", event)
return
canvas_node_one = self.canvas_nodes[node_one_id]
canvas_node_two = self.canvas_nodes[node_two_id]
canvas_node1 = self.canvas_nodes[node1_id]
canvas_node2 = self.canvas_nodes[node2_id]
if event.message_type == core_pb2.MessageType.ADD:
self.app.canvas.add_wireless_edge(
canvas_node_one, canvas_node_two, event.link
)
self.app.canvas.add_wireless_edge(canvas_node1, canvas_node2, event.link)
elif event.message_type == core_pb2.MessageType.DELETE:
self.app.canvas.delete_wireless_edge(
canvas_node_one, canvas_node_two, event.link
)
self.app.canvas.delete_wireless_edge(canvas_node1, canvas_node2, event.link)
elif event.message_type == core_pb2.MessageType.NONE:
self.app.canvas.update_wireless_edge(
canvas_node_one, canvas_node_two, event.link
)
self.app.canvas.update_wireless_edge(canvas_node1, canvas_node2, event.link)
else:
logging.warning("unknown link event: %s", event)
@ -472,10 +466,10 @@ class CoreClient:
for edge in self.links.values():
link = core_pb2.Link()
link.CopyFrom(edge.link)
if link.HasField("interface_one") and not link.interface_one.mac:
link.interface_one.mac = self.interfaces_manager.next_mac()
if link.HasField("interface_two") and not link.interface_two.mac:
link.interface_two.mac = self.interfaces_manager.next_mac()
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()
links.append(link)
wlan_configs = self.get_wlan_configs_proto()
mobility_configs = self.get_mobility_configs_proto()
@ -693,10 +687,10 @@ class CoreClient:
for link_proto in link_protos:
response = self.client.add_link(
self.session_id,
link_proto.node_one_id,
link_proto.node_two_id,
link_proto.interface_one,
link_proto.interface_two,
link_proto.node1_id,
link_proto.node2_id,
link_proto.interface1,
link_proto.interface2,
link_proto.options,
)
logging.debug("create link: %s", response)
@ -881,20 +875,20 @@ class CoreClient:
link = core_pb2.Link(
type=core_pb2.LinkType.WIRED,
node_one_id=src_node.id,
node_two_id=dst_node.id,
interface_one=src_interface,
interface_two=dst_interface,
node1_id=src_node.id,
node2_id=dst_node.id,
interface1=src_interface,
interface2=dst_interface,
)
# assign after creating link proto, since interfaces are copied
if src_interface:
interface_one = link.interface_one
edge.src_interface = interface_one
canvas_src_node.interfaces[interface_one.id] = interface_one
interface1 = link.interface1
edge.src_interface = interface1
canvas_src_node.interfaces[interface1.id] = interface1
if dst_interface:
interface_two = link.interface_two
edge.dst_interface = interface_two
canvas_dst_node.interfaces[interface_two.id] = interface_two
interface2 = link.interface2
edge.dst_interface = interface2
canvas_dst_node.interfaces[interface2.id] = interface2
edge.set_link(link)
self.links[edge.token] = edge
logging.info("Add link between %s and %s", src_node.name, dst_node.name)

48
daemon/core/gui/dialogs/linkconfig.py
View file

@ -227,21 +227,21 @@ class LinkConfigurationDialog(Dialog):
)
link.options.CopyFrom(options)
interface_one = None
if link.HasField("interface_one"):
interface_one = link.interface_one.id
interface_two = None
if link.HasField("interface_two"):
interface_two = link.interface_two.id
interface1_id = None
if link.HasField("interface1"):
interface1_id = link.interface1.id
interface2_id = None
if link.HasField("interface2"):
interface2_id = link.interface2.id
if not self.is_symmetric:
link.options.unidirectional = True
asym_interface_one = None
if interface_one:
asym_interface_one = core_pb2.Interface(id=interface_one)
asym_interface_two = None
if interface_two:
asym_interface_two = core_pb2.Interface(id=interface_two)
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)
down_bandwidth = get_int(self.down_bandwidth)
down_jitter = get_int(self.down_jitter)
down_delay = get_int(self.down_delay)
@ -256,10 +256,10 @@ class LinkConfigurationDialog(Dialog):
unidirectional=True,
)
self.edge.asymmetric_link = core_pb2.Link(
node_one_id=link.node_two_id,
node_two_id=link.node_one_id,
interface_one=asym_interface_one,
interface_two=asym_interface_two,
node1_id=link.node2_id,
node2_id=link.node1_id,
interface1=asym_interface1,
interface2=asym_interface2,
options=options,
)
else:
@ -270,20 +270,20 @@ class LinkConfigurationDialog(Dialog):
session_id = self.app.core.session_id
self.app.core.client.edit_link(
session_id,
link.node_one_id,
link.node_two_id,
link.node1_id,
link.node2_id,
link.options,
interface_one,
interface_two,
interface1_id,
interface2_id,
)
if self.edge.asymmetric_link:
self.app.core.client.edit_link(
session_id,
link.node_two_id,
link.node_one_id,
link.node2_id,
link.node1_id,
self.edge.asymmetric_link.options,
interface_one,
interface_two,
interface1_id,
interface2_id,
)
self.destroy()

14
daemon/core/gui/graph/edges.py
View file

@ -296,13 +296,13 @@ class CanvasEdge(Edge):
return label
def create_node_labels(self) -> Tuple[str, str]:
label_one = None
if self.link.HasField("interface_one"):
label_one = self.interface_label(self.link.interface_one)
label_two = None
if self.link.HasField("interface_two"):
label_two = self.interface_label(self.link.interface_two)
return label_one, label_two
label1 = None
if self.link.HasField("interface1"):
label1 = self.interface_label(self.link.interface1)
label2 = None
if self.link.HasField("interface2"):
label2 = self.interface_label(self.link.interface2)
return label1, label2
def draw_labels(self) -> None:
src_text, dst_text = self.create_node_labels()

78
daemon/core/gui/graph/graph.py
View file

@ -300,41 +300,39 @@ class CanvasGraph(tk.Canvas):
# draw existing links
for link in session.links:
logging.debug("drawing link: %s", link)
canvas_node_one = self.core.canvas_nodes[link.node_one_id]
node_one = canvas_node_one.core_node
canvas_node_two = self.core.canvas_nodes[link.node_two_id]
node_two = canvas_node_two.core_node
token = create_edge_token(canvas_node_one.id, canvas_node_two.id)
canvas_node1 = self.core.canvas_nodes[link.node1_id]
node1 = canvas_node1.core_node
canvas_node2 = self.core.canvas_nodes[link.node2_id]
node2 = canvas_node2.core_node
token = create_edge_token(canvas_node1.id, canvas_node2.id)
if link.type == core_pb2.LinkType.WIRELESS:
self.add_wireless_edge(canvas_node_one, canvas_node_two, link)
self.add_wireless_edge(canvas_node1, canvas_node2, link)
else:
if token not in self.edges:
src_pos = (node_one.position.x, node_one.position.y)
dst_pos = (node_two.position.x, node_two.position.y)
edge = CanvasEdge(self, canvas_node_one.id, src_pos, dst_pos)
src_pos = (node1.position.x, node1.position.y)
dst_pos = (node2.position.x, node2.position.y)
edge = CanvasEdge(self, canvas_node1.id, src_pos, dst_pos)
edge.token = token
edge.dst = canvas_node_two.id
edge.dst = canvas_node2.id
edge.set_link(link)
edge.check_wireless()
canvas_node_one.edges.add(edge)
canvas_node_two.edges.add(edge)
canvas_node1.edges.add(edge)
canvas_node2.edges.add(edge)
self.edges[edge.token] = edge
self.core.links[edge.token] = edge
if link.HasField("interface_one"):
interface_one = link.interface_one
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[
(node_one.id, interface_one.id)
] = token
canvas_node_one.interfaces[interface_one.id] = interface_one
edge.src_interface = interface_one
if link.HasField("interface_two"):
interface_two = link.interface_two
self.core.interface_to_edge[
(node_two.id, interface_two.id)
(node2.id, interface2.id)
] = edge.token
canvas_node_two.interfaces[interface_two.id] = interface_two
edge.dst_interface = interface_two
canvas_node2.interfaces[interface2.id] = interface2
edge.dst_interface = interface2
elif link.options.unidirectional:
edge = self.edges[token]
edge.asymmetric_link = link
@ -965,26 +963,26 @@ class CanvasGraph(tk.Canvas):
copy_link = copy_edge.link
options = edge.link.options
copy_link.options.CopyFrom(options)
interface_one = None
if copy_link.HasField("interface_one"):
interface_one = copy_link.interface_one.id
interface_two = None
if copy_link.HasField("interface_two"):
interface_two = copy_link.interface_two.id
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
if not options.unidirectional:
copy_edge.asymmetric_link = None
else:
asym_interface_one = None
if interface_one:
asym_interface_one = core_pb2.Interface(id=interface_one)
asym_interface_two = None
if interface_two:
asym_interface_two = core_pb2.Interface(id=interface_two)
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)
copy_edge.asymmetric_link = core_pb2.Link(
node_one_id=copy_link.node_two_id,
node_two_id=copy_link.node_one_id,
interface_one=asym_interface_one,
interface_two=asym_interface_two,
node1_id=copy_link.node2_id,
node2_id=copy_link.node1_id,
interface1=asym_interface1,
interface2=asym_interface2,
options=edge.asymmetric_link.options,
)
self.itemconfig(

24
daemon/core/gui/interface.py
View file

@ -89,21 +89,21 @@ class InterfaceManager:
remaining_subnets = set()
for edge in self.app.core.links.values():
link = edge.link
if link.HasField("interface_one"):
subnets = self.get_subnets(link.interface_one)
if link.HasField("interface1"):
subnets = self.get_subnets(link.interface1)
remaining_subnets.add(subnets)
if link.HasField("interface_two"):
subnets = self.get_subnets(link.interface_two)
if link.HasField("interface2"):
subnets = self.get_subnets(link.interface2)
remaining_subnets.add(subnets)
# remove all subnets from used subnets when no longer present
# or remove used indexes from subnet
interfaces = []
for link in links:
if link.HasField("interface_one"):
interfaces.append(link.interface_one)
if link.HasField("interface_two"):
interfaces.append(link.interface_two)
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 subnets not in remaining_subnets:
@ -117,10 +117,10 @@ class InterfaceManager:
def joined(self, links: List["core_pb2.Link"]) -> None:
interfaces = []
for link in links:
if link.HasField("interface_one"):
interfaces.append(link.interface_one)
if link.HasField("interface_two"):
interfaces.append(link.interface_two)
if link.HasField("interface1"):
interfaces.append(link.interface1)
if link.HasField("interface2"):
interfaces.append(link.interface2)
# add to used subnets and mark used indexes
for interface in interfaces:

22
daemon/core/nodes/base.py
View file

@ -63,7 +63,7 @@ class NodeBase:
self.session: "Session" = session
if _id is None:
_id = session.get_node_id()
_id = session.next_node_id()
self.id: int = _id
if name is None:
name = f"o{self.id}"
@ -475,13 +475,13 @@ class CoreNodeBase(NodeBase):
raise NotImplementedError
def newnetif(
self, net: "CoreNetworkBase", interface: InterfaceData
self, net: "CoreNetworkBase", interface_data: InterfaceData
) -> CoreInterface:
"""
Create a new network interface.
:param net: network to associate with
:param interface: interface data for new interface
:param interface_data: interface data for new interface
:return: interface index
"""
raise NotImplementedError
@ -860,34 +860,34 @@ class CoreNode(CoreNodeBase):
self.node_net_client.device_up(interface_name)
def newnetif(
self, net: "CoreNetworkBase", interface: InterfaceData
self, net: "CoreNetworkBase", interface_data: InterfaceData
) -> CoreInterface:
"""
Create a new network interface.
:param net: network to associate with
:param interface: interface data for new interface
:param interface_data: interface data for new interface
:return: interface index
"""
addresses = interface.get_addresses()
addresses = interface_data.get_addresses()
with self.lock:
# TODO: emane specific code
if net.is_emane is True:
ifindex = self.newtuntap(interface.id, interface.name)
ifindex = self.newtuntap(interface_data.id, interface_data.name)
# TUN/TAP is not ready for addressing yet; the device may
# take some time to appear, and installing it into a
# namespace after it has been bound removes addressing;
# save addresses with the interface now
self.attachnet(ifindex, net)
netif = self.netif(ifindex)
netif.sethwaddr(interface.mac)
netif.sethwaddr(interface_data.mac)
for address in addresses:
netif.addaddr(address)
else:
ifindex = self.newveth(interface.id, interface.name)
ifindex = self.newveth(interface_data.id, interface_data.name)
self.attachnet(ifindex, net)
if interface.mac:
self.sethwaddr(ifindex, interface.mac)
if interface_data.mac:
self.sethwaddr(ifindex, interface_data.mac)
for address in addresses:
self.addaddr(ifindex, address)
self.ifup(ifindex)

24
daemon/core/nodes/physical.py
View file

@ -157,25 +157,27 @@ class PhysicalNode(CoreNodeBase):
self.ifindex += 1
return ifindex
def newnetif(self, net: CoreNetworkBase, interface: InterfaceData) -> CoreInterface:
def newnetif(
self, net: CoreNetworkBase, interface_data: InterfaceData
) -> CoreInterface:
logging.info("creating interface")
addresses = interface.get_addresses()
ifindex = interface.id
addresses = interface_data.get_addresses()
ifindex = interface_data.id
if ifindex is None:
ifindex = self.newifindex()
name = interface.name
name = interface_data.name
if name is None:
name = f"gt{ifindex}"
if self.up:
# this is reached when this node is linked to a network node
# tunnel to net not built yet, so build it now and adopt it
_, remote_tap = self.session.distributed.create_gre_tunnel(net, self.server)
self.adoptnetif(remote_tap, ifindex, interface.mac, addresses)
self.adoptnetif(remote_tap, ifindex, interface_data.mac, addresses)
return remote_tap
else:
# this is reached when configuring services (self.up=False)
netif = GreTap(node=self, name=name, session=self.session, start=False)
self.adoptnetif(netif, ifindex, interface.mac, addresses)
self.adoptnetif(netif, ifindex, interface_data.mac, addresses)
return netif
def privatedir(self, path: str) -> None:
@ -297,19 +299,21 @@ class Rj45Node(CoreNodeBase):
self.up = False
self.restorestate()
def newnetif(self, net: CoreNetworkBase, interface: InterfaceData) -> CoreInterface:
def newnetif(
self, net: CoreNetworkBase, interface_data: InterfaceData
) -> CoreInterface:
"""
This is called when linking with another node. Since this node
represents an interface, we do not create another object here,
but attach ourselves to the given network.
:param net: new network instance
:param interface: interface data for new interface
:param interface_data: interface data for new interface
:return: interface index
:raises ValueError: when an interface has already been created, one max
"""
with self.lock:
ifindex = interface.id
ifindex = interface_data.id
if ifindex is None:
ifindex = 0
if self.interface.net is not None:
@ -318,7 +322,7 @@ class Rj45Node(CoreNodeBase):
self.ifindex = ifindex
if net is not None:
self.interface.attachnet(net)
for addr in interface.get_addresses():
for addr in interface_data.get_addresses():
self.addaddr(addr)
return self.interface

58
daemon/core/plugins/sdt.py
View file

@ -21,8 +21,8 @@ if TYPE_CHECKING:
from core.emulator.session import Session
def get_link_id(node_one: int, node_two: int, network_id: int) -> str:
link_id = f"{node_one}-{node_two}"
def get_link_id(node1_id: int, node2_id: int, network_id: int) -> str:
link_id = f"{node1_id}-{node2_id}"
if network_id is not None:
link_id = f"{link_id}-{network_id}"
return link_id
@ -215,7 +215,7 @@ class Sdt:
for layer in CORE_LAYERS:
self.cmd(f"layer {layer}")
with self.session._nodes_lock:
with self.session.nodes_lock:
for node_id in self.session.nodes:
node = self.session.nodes[node_id]
if isinstance(node, CoreNetworkBase):
@ -351,27 +351,27 @@ class Sdt:
return result
def add_link(
self, node_one: int, node_two: int, network_id: int = None, label: str = None
self, node1_id: int, node2_id: int, network_id: int = None, label: str = None
) -> None:
"""
Handle adding a link in SDT.
:param node_one: node one id
:param node_two: node two id
:param node1_id: node one id
:param node2_id: node two id
:param network_id: network link is associated with, None otherwise
:param label: label for link
:return: nothing
"""
logging.debug("sdt add link: %s, %s, %s", node_one, node_two, network_id)
logging.debug("sdt add link: %s, %s, %s", node1_id, node2_id, network_id)
if not self.connect():
return
if self.wireless_net_check(node_one) or self.wireless_net_check(node_two):
if self.wireless_net_check(node1_id) or self.wireless_net_check(node2_id):
return
color = DEFAULT_LINK_COLOR
if network_id:
color = self.session.get_link_color(network_id)
line = f"{color},2"
link_id = get_link_id(node_one, node_two, network_id)
link_id = get_link_id(node1_id, node2_id, network_id)
layer = LINK_LAYER
if network_id:
node = self.session.nodes.get(network_id)
@ -383,47 +383,47 @@ class Sdt:
if label:
link_label = f'linklabel on,"{label}"'
self.cmd(
f"link {node_one},{node_two},{link_id} linkLayer {layer} line {line} "
f"link {node1_id},{node2_id},{link_id} linkLayer {layer} line {line} "
f"{link_label}"
)
def delete_link(self, node_one: int, node_two: int, network_id: int = None) -> None:
def delete_link(self, node1_id: int, node2_id: int, network_id: int = None) -> None:
"""
Handle deleting a link in SDT.
:param node_one: node one id
:param node_two: node two id
:param node1_id: node one id
:param node2_id: node two id
:param network_id: network link is associated with, None otherwise
:return: nothing
"""
logging.debug("sdt delete link: %s, %s, %s", node_one, node_two, network_id)
logging.debug("sdt delete link: %s, %s, %s", node1_id, node2_id, network_id)
if not self.connect():
return
if self.wireless_net_check(node_one) or self.wireless_net_check(node_two):
if self.wireless_net_check(node1_id) or self.wireless_net_check(node2_id):
return
link_id = get_link_id(node_one, node_two, network_id)
self.cmd(f"delete link,{node_one},{node_two},{link_id}")
link_id = get_link_id(node1_id, node2_id, network_id)
self.cmd(f"delete link,{node1_id},{node2_id},{link_id}")
def edit_link(
self, node_one: int, node_two: int, network_id: int, label: str
self, node1_id: int, node2_id: int, network_id: int, label: str
) -> None:
"""
Handle editing a link in SDT.
:param node_one: node one id
:param node_two: node two id
:param node1_id: node one id
:param node2_id: node two id
:param network_id: network link is associated with, None otherwise
:param label: label to update
:return: nothing
"""
logging.debug("sdt edit link: %s, %s, %s", node_one, node_two, network_id)
logging.debug("sdt edit link: %s, %s, %s", node1_id, node2_id, network_id)
if not self.connect():
return
if self.wireless_net_check(node_one) or self.wireless_net_check(node_two):
if self.wireless_net_check(node1_id) or self.wireless_net_check(node2_id):
return
link_id = get_link_id(node_one, node_two, network_id)
link_id = get_link_id(node1_id, node2_id, network_id)
link_label = f'linklabel on,"{label}"'
self.cmd(f"link {node_one},{node_two},{link_id} {link_label}")
self.cmd(f"link {node1_id},{node2_id},{link_id} {link_label}")
def handle_link_update(self, link_data: LinkData) -> None:
"""
@ -432,13 +432,13 @@ class Sdt:
:param link_data: link data to handle
:return: nothing
"""
node_one = link_data.node1_id
node_two = link_data.node2_id
node1_id = link_data.node1_id
node2_id = link_data.node2_id
network_id = link_data.network_id
label = link_data.label
if link_data.message_type == MessageFlags.ADD:
self.add_link(node_one, node_two, network_id, label)
self.add_link(node1_id, node2_id, network_id, label)
elif link_data.message_type == MessageFlags.DELETE:
self.delete_link(node_one, node_two, network_id)
self.delete_link(node1_id, node2_id, network_id)
elif link_data.message_type == MessageFlags.NONE and label:
self.edit_link(node_one, node_two, network_id, label)
self.edit_link(node1_id, node2_id, network_id, label)

8
daemon/core/services/coreservices.py
View file

@ -325,7 +325,13 @@ class CoreServices:
"""
self.session = session
# dict of default services tuples, key is node type
self.default_services = {}
self.default_services = {
"mdr": ("zebra", "OSPFv3MDR", "IPForward"),
"PC": ("DefaultRoute",),
"prouter": (),
"router": ("zebra", "OSPFv2", "OSPFv3", "IPForward"),
"host": ("DefaultRoute", "SSH"),
}
# dict of node ids to dict of custom services by name
self.custom_services = {}

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

@ -320,8 +320,8 @@ class CoreXmlWriter:
def write_session_hooks(self) -> None:
# hook scripts
hooks = etree.Element("session_hooks")
for state in sorted(self.session._hooks, key=lambda x: x.value):
for file_name, data in self.session._hooks[state]:
for state in sorted(self.session.hooks, key=lambda x: x.value):
for file_name, data in self.session.hooks[state]:
hook = etree.SubElement(hooks, "hook")
add_attribute(hook, "name", file_name)
add_attribute(hook, "state", state.value)
@ -534,7 +534,7 @@ class CoreXmlWriter:
# check for interface one
if link_data.interface1_id is not None:
interface_one = self.create_interface_element(
interface1 = self.create_interface_element(
"interface_one",
link_data.node1_id,
link_data.interface1_id,
@ -544,11 +544,11 @@ class CoreXmlWriter:
link_data.interface1_ip6,
link_data.interface1_ip6_mask,
)
link_element.append(interface_one)
link_element.append(interface1)
# check for interface two
if link_data.interface2_id is not None:
interface_two = self.create_interface_element(
interface2 = self.create_interface_element(
"interface_two",
link_data.node2_id,
link_data.interface2_id,
@ -558,14 +558,14 @@ class CoreXmlWriter:
link_data.interface2_ip6,
link_data.interface2_ip6_mask,
)
link_element.append(interface_two)
link_element.append(interface2)
# check for options, don't write for emane/wlan links
node_one = self.session.get_node(link_data.node1_id, NodeBase)
node_two = self.session.get_node(link_data.node2_id, NodeBase)
is_node_one_wireless = isinstance(node_one, (WlanNode, EmaneNet))
is_node_two_wireless = isinstance(node_two, (WlanNode, EmaneNet))
if not any([is_node_one_wireless, is_node_two_wireless]):
node1 = self.session.get_node(link_data.node1_id, NodeBase)
node2 = self.session.get_node(link_data.node2_id, NodeBase)
is_node1_wireless = isinstance(node1, (WlanNode, EmaneNet))
is_node2_wireless = isinstance(node2, (WlanNode, EmaneNet))
if not any([is_node1_wireless, is_node2_wireless]):
options = etree.Element("options")
add_attribute(options, "delay", link_data.delay)
add_attribute(options, "bandwidth", link_data.bandwidth)
@ -932,19 +932,19 @@ class CoreXmlReader:
node_sets = set()
for link_element in link_elements.iterchildren():
node_one = get_int(link_element, "node_one")
node_two = get_int(link_element, "node_two")
node_set = frozenset((node_one, node_two))
node1_id = get_int(link_element, "node_one")
node2_id = get_int(link_element, "node_two")
node_set = frozenset((node1_id, node2_id))
interface_one_element = link_element.find("interface_one")
interface_one = None
if interface_one_element is not None:
interface_one = create_interface_data(interface_one_element)
interface1_element = link_element.find("interface_one")
interface1_data = None
if interface1_element is not None:
interface1_data = create_interface_data(interface1_element)
interface_two_element = link_element.find("interface_two")
interface_two = None
if interface_two_element is not None:
interface_two = create_interface_data(interface_two_element)
interface2_element = link_element.find("interface_two")
interface2_data = None
if interface2_element is not None:
interface2_data = create_interface_data(interface2_element)
options_element = link_element.find("options")
options = LinkOptions()
@ -968,18 +968,14 @@ class CoreXmlReader:
options.gui_attributes = options_element.get("gui_attributes")
if options.unidirectional == 1 and node_set in node_sets:
logging.info(
"updating link node_one(%s) node_two(%s)", node_one, node_two
)
logging.info("updating link node1(%s) node2(%s)", node1_id, node2_id)
self.session.update_link(
node_one, node_two, interface_one.id, interface_two.id, options
node1_id, node2_id, interface1_data.id, interface2_data.id, options
)
else:
logging.info(
"adding link node_one(%s) node_two(%s)", node_one, node_two
)
logging.info("adding link node1(%s) node2(%s)", node1_id, node2_id)
self.session.add_link(
node_one, node_two, interface_one, interface_two, options
node1_id, node2_id, interface1_data, interface2_data, options
)
node_sets.add(node_set)

14
daemon/examples/configservices/testing.py
View file

@ -11,7 +11,7 @@ if __name__ == "__main__":
# setup basic network
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
options = NodeOptions(model="nothing")
options = NodeOptions(model=None)
coreemu = CoreEmu()
session = coreemu.create_session()
session.set_state(EventTypes.CONFIGURATION_STATE)
@ -19,14 +19,14 @@ if __name__ == "__main__":
# node one
options.config_services = ["DefaultRoute", "IPForward"]
node_one = session.add_node(CoreNode, options=options)
interface = prefixes.create_interface(node_one)
session.add_link(node_one.id, switch.id, interface_one=interface)
node1 = session.add_node(CoreNode, options=options)
interface = prefixes.create_interface(node1)
session.add_link(node1.id, switch.id, interface1_data=interface)
# node two
node_two = session.add_node(CoreNode, options=options)
interface = prefixes.create_interface(node_two)
session.add_link(node_two.id, switch.id, interface_one=interface)
node2 = session.add_node(CoreNode, options=options)
interface = prefixes.create_interface(node2)
session.add_link(node2.id, switch.id, interface1_data=interface)
# start session and run services
session.instantiate()

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

@ -17,15 +17,15 @@ if __name__ == "__main__":
options = NodeOptions(model=None, image="ubuntu")
# create node one
node_one = session.add_node(DockerNode, options=options)
interface_one = prefixes.create_interface(node_one)
node1 = session.add_node(DockerNode, options=options)
interface1_data = prefixes.create_interface(node1)
# create node two
node_two = session.add_node(CoreNode)
interface_two = prefixes.create_interface(node_two)
node2 = session.add_node(CoreNode)
interface2_data = prefixes.create_interface(node2)
# add link
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# instantiate
session.instantiate()

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

@ -18,15 +18,15 @@ if __name__ == "__main__":
options = NodeOptions(model=None, image="ubuntu")
# create node one
node_one = session.add_node(DockerNode, options=options)
interface_one = prefixes.create_interface(node_one)
node1 = session.add_node(DockerNode, options=options)
interface1_data = prefixes.create_interface(node1)
# create node two
node_two = session.add_node(DockerNode, options=options)
interface_two = prefixes.create_interface(node_two)
node2 = session.add_node(DockerNode, options=options)
interface2_data = prefixes.create_interface(node2)
# add link
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# instantiate
session.instantiate()

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

@ -22,20 +22,20 @@ if __name__ == "__main__":
switch = session.add_node(SwitchNode)
# node one
node_one = session.add_node(DockerNode, options=options)
interface_one = prefixes.create_interface(node_one)
node1 = session.add_node(DockerNode, options=options)
interface1_data = prefixes.create_interface(node1)
# node two
node_two = session.add_node(DockerNode, options=options)
interface_two = prefixes.create_interface(node_two)
node2 = session.add_node(DockerNode, options=options)
interface2_data = prefixes.create_interface(node2)
# node three
node_three = session.add_node(CoreNode)
interface_three = prefixes.create_interface(node_three)
# add links
session.add_link(node_one.id, switch.id, interface_one)
session.add_link(node_two.id, switch.id, interface_two)
session.add_link(node1.id, switch.id, interface1_data)
session.add_link(node2.id, switch.id, interface2_data)
session.add_link(node_three.id, switch.id, interface_three)
# instantiate

12
daemon/examples/grpc/distributed_switch.py
View file

@ -44,11 +44,11 @@ def main(args):
node = Node(position=position)
response = core.add_node(session_id, node)
logging.info("created node one: %s", response)
node_one_id = response.node_id
node1_id = response.node_id
# create link
interface_one = interface_helper.create_interface(node_one_id, 0)
response = core.add_link(session_id, node_one_id, switch_id, interface_one)
interface1 = interface_helper.create_interface(node1_id, 0)
response = core.add_link(session_id, node1_id, switch_id, interface1)
logging.info("created link from node one to switch: %s", response)
# create node two
@ -56,11 +56,11 @@ def main(args):
node = Node(position=position, server=server_name)
response = core.add_node(session_id, node)
logging.info("created node two: %s", response)
node_two_id = response.node_id
node2_id = response.node_id
# create link
interface_one = interface_helper.create_interface(node_two_id, 0)
response = core.add_link(session_id, node_two_id, switch_id, interface_one)
interface1 = interface_helper.create_interface(node2_id, 0)
response = core.add_link(session_id, node2_id, switch_id, interface1)
logging.info("created link from node two to switch: %s", response)
# change session state

8
daemon/examples/grpc/emane80211.py
View file

@ -57,11 +57,11 @@ def main():
node2_id = response.node_id
# links nodes to switch
interface_one = interface_helper.create_interface(node1_id, 0)
response = core.add_link(session_id, node1_id, emane_id, interface_one)
interface1 = interface_helper.create_interface(node1_id, 0)
response = core.add_link(session_id, node1_id, emane_id, interface1)
logging.info("created link: %s", response)
interface_one = interface_helper.create_interface(node2_id, 0)
response = core.add_link(session_id, node2_id, emane_id, interface_one)
interface1 = interface_helper.create_interface(node2_id, 0)
response = core.add_link(session_id, node2_id, emane_id, interface1)
logging.info("created link: %s", response)
# change session state

8
daemon/examples/grpc/switch.py
View file

@ -53,11 +53,11 @@ def main():
node2_id = response.node_id
# links nodes to switch
interface_one = interface_helper.create_interface(node1_id, 0)
response = core.add_link(session_id, node1_id, switch_id, interface_one)
interface1 = interface_helper.create_interface(node1_id, 0)
response = core.add_link(session_id, node1_id, switch_id, interface1)
logging.info("created link: %s", response)
interface_one = interface_helper.create_interface(node2_id, 0)
response = core.add_link(session_id, node2_id, switch_id, interface_one)
interface1 = interface_helper.create_interface(node2_id, 0)
response = core.add_link(session_id, node2_id, switch_id, interface1)
logging.info("created link: %s", response)
# change session state

8
daemon/examples/grpc/wlan.py
View file

@ -65,11 +65,11 @@ def main():
node2_id = response.node_id
# links nodes to switch
interface_one = interface_helper.create_interface(node1_id, 0)
response = core.add_link(session_id, node1_id, wlan_id, interface_one)
interface1 = interface_helper.create_interface(node1_id, 0)
response = core.add_link(session_id, node1_id, wlan_id, interface1)
logging.info("created link: %s", response)
interface_one = interface_helper.create_interface(node2_id, 0)
response = core.add_link(session_id, node2_id, wlan_id, interface_one)
interface1 = interface_helper.create_interface(node2_id, 0)
response = core.add_link(session_id, node2_id, wlan_id, interface1)
logging.info("created link: %s", response)
# change session state

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

@ -17,15 +17,15 @@ if __name__ == "__main__":
options = NodeOptions(image="ubuntu")
# create node one
node_one = session.add_node(LxcNode, options=options)
interface_one = prefixes.create_interface(node_one)
node1 = session.add_node(LxcNode, options=options)
interface1_data = prefixes.create_interface(node1)
# create node two
node_two = session.add_node(CoreNode)
interface_two = prefixes.create_interface(node_two)
node2 = session.add_node(CoreNode)
interface2_data = prefixes.create_interface(node2)
# add link
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# instantiate
session.instantiate()

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

@ -18,15 +18,15 @@ if __name__ == "__main__":
options = NodeOptions(image="ubuntu:18.04")
# create node one
node_one = session.add_node(LxcNode, options=options)
interface_one = prefixes.create_interface(node_one)
node1 = session.add_node(LxcNode, options=options)
interface1_data = prefixes.create_interface(node1)
# create node two
node_two = session.add_node(LxcNode, options=options)
interface_two = prefixes.create_interface(node_two)
node2 = session.add_node(LxcNode, options=options)
interface2_data = prefixes.create_interface(node2)
# add link
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# instantiate
session.instantiate()

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

@ -22,21 +22,21 @@ if __name__ == "__main__":
switch = session.add_node(SwitchNode)
# node one
node_one = session.add_node(LxcNode, options=options)
interface_one = prefixes.create_interface(node_one)
node1 = session.add_node(LxcNode, options=options)
interface1_data = prefixes.create_interface(node1)
# node two
node_two = session.add_node(LxcNode, options=options)
interface_two = prefixes.create_interface(node_two)
node2 = session.add_node(LxcNode, options=options)
interface2_data = prefixes.create_interface(node2)
# node three
node_three = session.add_node(CoreNode)
interface_three = prefixes.create_interface(node_three)
node3 = session.add_node(CoreNode)
interface3_data = prefixes.create_interface(node3)
# add links
session.add_link(node_one.id, switch.id, interface_one)
session.add_link(node_two.id, switch.id, interface_two)
session.add_link(node_three.id, switch.id, interface_three)
session.add_link(node1.id, switch.id, interface1_data)
session.add_link(node2.id, switch.id, interface2_data)
session.add_link(node3.id, switch.id, interface3_data)
# instantiate
session.instantiate()

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

@ -52,17 +52,17 @@ def main(args):
# create local node, switch, and remote nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node_one = session.add_node(CoreNode, options=options)
node1 = session.add_node(CoreNode, options=options)
emane_net = session.add_node(EmaneNet)
session.emane.set_model(emane_net, EmaneIeee80211abgModel)
options.server = server_name
node_two = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode, options=options)
# create node interfaces and link
interface_one = prefixes.create_interface(node_one)
interface_two = prefixes.create_interface(node_two)
session.add_link(node_one.id, emane_net.id, interface_one=interface_one)
session.add_link(node_two.id, emane_net.id, interface_one=interface_two)
interface1_data = prefixes.create_interface(node1)
interface2_data = prefixes.create_interface(node2)
session.add_link(node1.id, emane_net.id, interface1_data=interface1_data)
session.add_link(node2.id, emane_net.id, interface1_data=interface2_data)
# instantiate session
session.instantiate()

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

@ -43,14 +43,14 @@ def main(args):
# create local node, switch, and remote nodes
options = NodeOptions(image="ubuntu:18.04")
node_one = session.add_node(LxcNode, options=options)
node1 = session.add_node(LxcNode, options=options)
options.server = server_name
node_two = session.add_node(LxcNode, options=options)
node2 = session.add_node(LxcNode, options=options)
# create node interfaces and link
interface_one = prefixes.create_interface(node_one)
interface_two = prefixes.create_interface(node_two)
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
interface1_data = prefixes.create_interface(node1)
interface2_data = prefixes.create_interface(node2)
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# instantiate session
session.instantiate()

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

@ -43,14 +43,14 @@ def main(args):
# create local node, switch, and remote nodes
options = NodeOptions()
node_one = session.add_node(CoreNode, options=options)
node1 = session.add_node(CoreNode, options=options)
options.server = server_name
node_two = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode, options=options)
# create node interfaces and link
interface_one = prefixes.create_interface(node_one)
interface_two = prefixes.create_interface(node_two)
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
interface1_data = prefixes.create_interface(node1)
interface2_data = prefixes.create_interface(node2)
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# instantiate session
session.instantiate()

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

@ -45,17 +45,17 @@ def main(args):
session.set_state(EventTypes.CONFIGURATION_STATE)
# create local node, switch, and remote nodes
node_one = session.add_node(CoreNode)
node1 = session.add_node(CoreNode)
switch = session.add_node(SwitchNode)
options = NodeOptions()
options.server = server_name
node_two = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode, options=options)
# create node interfaces and link
interface_one = prefixes.create_interface(node_one)
interface_two = prefixes.create_interface(node_two)
session.add_link(node_one.id, switch.id, interface_one=interface_one)
session.add_link(node_two.id, switch.id, interface_one=interface_two)
interface1_data = prefixes.create_interface(node1)
interface2_data = prefixes.create_interface(node2)
session.add_link(node1.id, switch.id, interface1_data=interface1_data)
session.add_link(node2.id, switch.id, interface1_data=interface2_data)
# instantiate session
session.instantiate()

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

@ -43,7 +43,7 @@ def main():
node = session.add_node(CoreNode, 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)
session.add_link(node.id, emane_network.id, interface1_data=interface)
# instantiate session
session.instantiate()

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

@ -32,7 +32,7 @@ def main():
for _ in range(NODES):
node = session.add_node(CoreNode)
interface = prefixes.create_interface(node)
session.add_link(node.id, switch.id, interface_one=interface)
session.add_link(node.id, switch.id, interface1_data=interface)
# instantiate session
session.instantiate()

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

@ -34,7 +34,7 @@ def main():
for _ in range(NODES):
node = session.add_node(CoreNode)
interface = prefixes.create_interface(node)
session.add_link(node.id, switch.id, interface_one=interface)
session.add_link(node.id, switch.id, interface1_data=interface)
# instantiate session
session.instantiate()

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

@ -36,7 +36,7 @@ def main():
for _ in range(NODES):
node = session.add_node(CoreNode, options=options)
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
session.add_link(node.id, wlan.id, interface1_data=interface)
# instantiate session
session.instantiate()

28
daemon/proto/core/api/grpc/core.proto
View file

@ -492,16 +492,16 @@ message AddLinkRequest {
message AddLinkResponse {
bool result = 1;
Interface interface_one = 2;
Interface interface_two = 3;
Interface interface1 = 2;
Interface interface2 = 3;
}
message EditLinkRequest {
int32 session_id = 1;
int32 node_one_id = 2;
int32 node_two_id = 3;
int32 interface_one_id = 4;
int32 interface_two_id = 5;
int32 node1_id = 2;
int32 node2_id = 3;
int32 interface1_id = 4;
int32 interface2_id = 5;
LinkOptions options = 6;
}
@ -511,10 +511,10 @@ message EditLinkResponse {
message DeleteLinkRequest {
int32 session_id = 1;
int32 node_one_id = 2;
int32 node_two_id = 3;
int32 interface_one_id = 4;
int32 interface_two_id = 5;
int32 node1_id = 2;
int32 node2_id = 3;
int32 interface1_id = 4;
int32 interface2_id = 5;
}
message DeleteLinkResponse {
@ -702,11 +702,11 @@ message Node {
}
message Link {
int32 node_one_id = 1;
int32 node_two_id = 2;
int32 node1_id = 1;
int32 node2_id = 2;
LinkType.Enum type = 3;
Interface interface_one = 4;
Interface interface_two = 5;
Interface interface1 = 4;
Interface interface2 = 5;
LinkOptions options = 6;
int32 network_id = 7;
string label = 8;

16
daemon/proto/core/api/grpc/emane.proto
View file

@ -75,8 +75,8 @@ message GetEmaneEventChannelResponse {
message EmaneLinkRequest {
int32 session_id = 1;
int32 nem_one = 2;
int32 nem_two = 3;
int32 nem1 = 2;
int32 nem2 = 3;
bool linked = 4;
}
@ -93,12 +93,12 @@ message EmaneModelConfig {
message EmanePathlossesRequest {
int32 session_id = 1;
int32 node_one = 2;
float rx_one = 3;
int32 interface_one_id = 4;
int32 node_two = 5;
float rx_two = 6;
int32 interface_two_id = 7;
int32 node1_id = 2;
float rx1 = 3;
int32 interface1_id = 4;
int32 node2_id = 5;
float rx2 = 6;
int32 interface2_id = 7;
}
message EmanePathlossesResponse {

4
daemon/proto/core/api/grpc/wlan.proto
View file

@ -38,8 +38,8 @@ message SetWlanConfigResponse {
message WlanLinkRequest {
int32 session_id = 1;
int32 wlan = 2;
int32 node_one = 3;
int32 node_two = 4;
int32 node1_id = 3;
int32 node2_id = 4;
bool linked = 5;
}

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

@ -3,6 +3,7 @@ Unit tests for testing CORE EMANE networks.
"""
import os
from tempfile import TemporaryFile
from typing import Type
from xml.etree import ElementTree
import pytest
@ -43,7 +44,9 @@ def ping(
class TestEmane:
@pytest.mark.parametrize("model", _EMANE_MODELS)
def test_models(self, session: Session, model: EmaneModel, ip_prefixes: IpPrefixes):
def test_models(
self, session: Session, model: Type[EmaneModel], ip_prefixes: IpPrefixes
):
"""
Test emane models within a basic network.
@ -70,20 +73,20 @@ class TestEmane:
# create nodes
options = NodeOptions(model="mdr")
options.set_position(150, 150)
node_one = session.add_node(CoreNode, options=options)
node1 = session.add_node(CoreNode, options=options)
options.set_position(300, 150)
node_two = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode, options=options)
for i, node in enumerate([node_one, node_two]):
for i, node in enumerate([node1, node2]):
node.setposition(x=150 * (i + 1), y=150)
interface = ip_prefixes.create_interface(node)
session.add_link(node.id, emane_network.id, interface_one=interface)
session.add_link(node.id, emane_network.id, interface1_data=interface)
# instantiate session
session.instantiate()
# ping n2 from n1 and assert success
status = ping(node_one, node_two, ip_prefixes, count=5)
# ping node2 from node1 and assert success
status = ping(node1, node2, ip_prefixes, count=5)
assert not status
def test_xml_emane(
@ -110,22 +113,22 @@ class TestEmane:
# create nodes
options = NodeOptions(model="mdr")
options.set_position(150, 150)
node_one = session.add_node(CoreNode, options=options)
node1 = session.add_node(CoreNode, options=options)
options.set_position(300, 150)
node_two = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode, options=options)
for i, node in enumerate([node_one, node_two]):
for i, node in enumerate([node1, node2]):
node.setposition(x=150 * (i + 1), y=150)
interface = ip_prefixes.create_interface(node)
session.add_link(node.id, emane_network.id, interface_one=interface)
session.add_link(node.id, emane_network.id, interface1_data=interface)
# instantiate session
session.instantiate()
# get ids for nodes
emane_id = emane_network.id
n1_id = node_one.id
n2_id = node_two.id
node1_id = node1.id
node2_id = node2.id
# save xml
xml_file = tmpdir.join("session.xml")
@ -141,9 +144,9 @@ class TestEmane:
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(n1_id, CoreNode)
assert not session.get_node(node1_id, CoreNode)
with pytest.raises(CoreError):
assert not session.get_node(n2_id, CoreNode)
assert not session.get_node(node2_id, CoreNode)
# load saved xml
session.open_xml(file_path, start=True)
@ -154,7 +157,7 @@ class TestEmane:
)
# verify nodes and configuration were restored
assert session.get_node(n1_id, CoreNode)
assert session.get_node(n2_id, CoreNode)
assert session.get_node(node1_id, CoreNode)
assert session.get_node(node2_id, CoreNode)
assert session.get_node(emane_id, EmaneNet)
assert value == config_value

16
daemon/tests/test_conf.py
View file

@ -14,11 +14,11 @@ from core.nodes.network import WlanNode
class TestConfigurableOptions(ConfigurableOptions):
name_one = "value1"
name_two = "value2"
name1 = "value1"
name2 = "value2"
options = [
Configuration(_id=name_one, _type=ConfigDataTypes.STRING, label=name_one),
Configuration(_id=name_two, _type=ConfigDataTypes.STRING, label=name_two),
Configuration(_id=name1, _type=ConfigDataTypes.STRING, label=name1),
Configuration(_id=name2, _type=ConfigDataTypes.STRING, label=name2),
]
@ -33,11 +33,11 @@ class TestConf:
# then
assert len(default_values) == 2
assert TestConfigurableOptions.name_one in default_values
assert TestConfigurableOptions.name_two in default_values
assert TestConfigurableOptions.name1 in default_values
assert TestConfigurableOptions.name2 in default_values
assert len(instance_default_values) == 2
assert TestConfigurableOptions.name_one in instance_default_values
assert TestConfigurableOptions.name_two in instance_default_values
assert TestConfigurableOptions.name1 in instance_default_values
assert TestConfigurableOptions.name2 in instance_default_values
def test_nodes(self):
# given

64
daemon/tests/test_core.py
View file

@ -48,19 +48,19 @@ class TestCore:
net_node = session.add_node(net_type)
# create nodes
node_one = session.add_node(CoreNode)
node_two = session.add_node(CoreNode)
node1 = session.add_node(CoreNode)
node2 = session.add_node(CoreNode)
# link nodes to net node
for node in [node_one, node_two]:
for node in [node1, node2]:
interface = ip_prefixes.create_interface(node)
session.add_link(node.id, net_node.id, interface_one=interface)
session.add_link(node.id, net_node.id, interface1_data=interface)
# instantiate session
session.instantiate()
# ping n2 from n1 and assert success
status = ping(node_one, node_two, ip_prefixes)
# ping node2 from node1 and assert success
status = ping(node1, node2, ip_prefixes)
assert not status
def test_vnode_client(self, request, session: Session, ip_prefixes: IpPrefixes):
@ -75,16 +75,16 @@ class TestCore:
ptp_node = session.add_node(PtpNet)
# create nodes
node_one = session.add_node(CoreNode)
node_two = session.add_node(CoreNode)
node1 = session.add_node(CoreNode)
node2 = session.add_node(CoreNode)
# link nodes to ptp net
for node in [node_one, node_two]:
for node in [node1, node2]:
interface = ip_prefixes.create_interface(node)
session.add_link(node.id, ptp_node.id, interface_one=interface)
session.add_link(node.id, ptp_node.id, interface1_data=interface)
# get node client for testing
client = node_one.client
client = node1.client
# instantiate session
session.instantiate()
@ -108,13 +108,13 @@ class TestCore:
ptp_node = session.add_node(PtpNet)
# create nodes
node_one = session.add_node(CoreNode)
node_two = session.add_node(CoreNode)
node1 = session.add_node(CoreNode)
node2 = session.add_node(CoreNode)
# link nodes to ptp net
for node in [node_one, node_two]:
for node in [node1, node2]:
interface = ip_prefixes.create_interface(node)
session.add_link(node.id, ptp_node.id, interface_one=interface)
session.add_link(node.id, ptp_node.id, interface1_data=interface)
# instantiate session
session.instantiate()
@ -123,22 +123,22 @@ class TestCore:
assert ptp_node.all_link_data(MessageFlags.ADD)
# check common nets exist between linked nodes
assert node_one.commonnets(node_two)
assert node_two.commonnets(node_one)
assert node1.commonnets(node2)
assert node2.commonnets(node1)
# check we can retrieve netif index
assert node_one.ifname(0)
assert node_two.ifname(0)
assert node1.ifname(0)
assert node2.ifname(0)
# check interface parameters
interface = node_one.netif(0)
interface = node1.netif(0)
interface.setparam("test", 1)
assert interface.getparam("test") == 1
assert interface.getparams()
# delete netif and test that if no longer exists
node_one.delnetif(0)
assert not node_one.netif(0)
node1.delnetif(0)
assert not node1.netif(0)
def test_wlan_ping(self, session: Session, ip_prefixes: IpPrefixes):
"""
@ -155,19 +155,19 @@ class TestCore:
# create nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node_one = session.add_node(CoreNode, options=options)
node_two = session.add_node(CoreNode, options=options)
node1 = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode, options=options)
# link nodes
for node in [node_one, node_two]:
for node in [node1, node2]:
interface = ip_prefixes.create_interface(node)
session.add_link(node.id, wlan_node.id, interface_one=interface)
session.add_link(node.id, wlan_node.id, interface1_data=interface)
# instantiate session
session.instantiate()
# ping n2 from n1 and assert success
status = ping(node_one, node_two, ip_prefixes)
# ping node2 from node1 and assert success
status = ping(node1, node2, ip_prefixes)
assert not status
def test_mobility(self, session: Session, ip_prefixes: IpPrefixes):
@ -185,13 +185,13 @@ class TestCore:
# create nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node_one = session.add_node(CoreNode, options=options)
node_two = session.add_node(CoreNode, options=options)
node1 = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode, options=options)
# link nodes
for node in [node_one, node_two]:
for node in [node1, node2]:
interface = ip_prefixes.create_interface(node)
session.add_link(node.id, wlan_node.id, interface_one=interface)
session.add_link(node.id, wlan_node.id, interface1_data=interface)
# configure mobility script for session
config = {

56
daemon/tests/test_grpc.py
View file

@ -34,23 +34,23 @@ class TestGrpc:
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
position = core_pb2.Position(x=50, y=100)
node_one = core_pb2.Node(id=1, position=position, model="PC")
node1 = core_pb2.Node(id=1, position=position, model="PC")
position = core_pb2.Position(x=100, y=100)
node_two = core_pb2.Node(id=2, position=position, model="PC")
node2 = core_pb2.Node(id=2, position=position, model="PC")
position = core_pb2.Position(x=200, y=200)
wlan_node = core_pb2.Node(
id=3, type=NodeTypes.WIRELESS_LAN.value, position=position
)
nodes = [node_one, node_two, wlan_node]
nodes = [node1, node2, wlan_node]
interface_helper = InterfaceHelper(ip4_prefix="10.83.0.0/16")
interface_one = interface_helper.create_interface(node_one.id, 0)
interface_two = interface_helper.create_interface(node_two.id, 0)
interface1 = interface_helper.create_interface(node1.id, 0)
interface2 = interface_helper.create_interface(node2.id, 0)
link = core_pb2.Link(
type=core_pb2.LinkType.WIRED,
node_one_id=node_one.id,
node_two_id=node_two.id,
interface_one=interface_one,
interface_two=interface_two,
node1_id=node1.id,
node2_id=node2.id,
interface1=interface1,
interface2=interface2,
)
links = [link]
hook = core_pb2.Hook(
@ -99,11 +99,11 @@ class TestGrpc:
)
mobility_configs = [mobility_config]
service_config = ServiceConfig(
node_id=node_one.id, service="DefaultRoute", validate=["echo hello"]
node_id=node1.id, service="DefaultRoute", validate=["echo hello"]
)
service_configs = [service_config]
service_file_config = ServiceFileConfig(
node_id=node_one.id,
node_id=node1.id,
service="DefaultRoute",
file="defaultroute.sh",
data="echo hello",
@ -128,12 +128,12 @@ class TestGrpc:
)
# then
assert node_one.id in session.nodes
assert node_two.id in session.nodes
assert node1.id in session.nodes
assert node2.id in session.nodes
assert wlan_node.id in session.nodes
assert session.nodes[node_one.id].netif(0) is not None
assert session.nodes[node_two.id].netif(0) is not None
hook_file, hook_data = session._hooks[EventTypes.RUNTIME_STATE][0]
assert session.nodes[node1.id].netif(0) is not None
assert session.nodes[node2.id].netif(0) is not None
hook_file, hook_data = session.hooks[EventTypes.RUNTIME_STATE][0]
assert hook_file == hook.file
assert hook_data == hook.data
assert session.location.refxyz == (location_x, location_y, location_z)
@ -153,11 +153,11 @@ class TestGrpc:
)
assert set_model_config[model_config_key] == model_config_value
service = session.services.get_service(
node_one.id, service_config.service, default_service=True
node1.id, service_config.service, default_service=True
)
assert service.validate == tuple(service_config.validate)
service_file = session.services.get_service_file(
node_one, service_file_config.service, service_file_config.file
node1, service_file_config.service, service_file_config.file
)
assert service_file.data == service_file_config.data
@ -596,7 +596,7 @@ class TestGrpc:
# then
with client.context_connect():
response = client.edit_link(
session.id, node.id, switch.id, options, interface_one_id=interface.id
session.id, node.id, switch.id, options, interface1_id=interface.id
)
# then
@ -608,28 +608,28 @@ class TestGrpc:
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
node_one = session.add_node(CoreNode)
interface_one = ip_prefixes.create_interface(node_one)
node_two = session.add_node(CoreNode)
interface_two = ip_prefixes.create_interface(node_two)
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
node1 = session.add_node(CoreNode)
interface1 = ip_prefixes.create_interface(node1)
node2 = session.add_node(CoreNode)
interface2 = ip_prefixes.create_interface(node2)
session.add_link(node1.id, node2.id, interface1, interface2)
link_node = None
for node_id in session.nodes:
node = session.nodes[node_id]
if node.id not in {node_one.id, node_two.id}:
if node.id not in {node1.id, node2.id}:
link_node = node
break
assert len(link_node.all_link_data(0)) == 1
assert len(link_node.all_link_data()) == 1
# then
with client.context_connect():
response = client.delete_link(
session.id, node_one.id, node_two.id, interface_one.id, interface_two.id
session.id, node1.id, node2.id, interface1.id, interface2.id
)
# then
assert response.result is True
assert len(link_node.all_link_data(0)) == 0
assert len(link_node.all_link_data()) == 0
def test_get_wlan_config(self, grpc_server: CoreGrpcServer):
# given

163
daemon/tests/test_gui.py
View file

@ -50,12 +50,13 @@ class TestGui:
self, coretlv: CoreHandler, node_type: NodeTypes, model: Optional[str]
):
node_id = 1
name = "node1"
message = coreapi.CoreNodeMessage.create(
MessageFlags.ADD.value,
[
(NodeTlvs.NUMBER, node_id),
(NodeTlvs.TYPE, node_type.value),
(NodeTlvs.NAME, "n1"),
(NodeTlvs.NAME, name),
(NodeTlvs.X_POSITION, 0),
(NodeTlvs.Y_POSITION, 0),
(NodeTlvs.MODEL, model),
@ -63,7 +64,9 @@ class TestGui:
)
coretlv.handle_message(message)
assert coretlv.session.get_node(node_id, NodeBase) is not None
node = coretlv.session.get_node(node_id, NodeBase)
assert node
assert node.name == name
def test_node_update(self, coretlv: CoreHandler):
node_id = 1
@ -99,71 +102,71 @@ class TestGui:
coretlv.session.get_node(node_id, NodeBase)
def test_link_add_node_to_net(self, coretlv: CoreHandler):
node_one = 1
coretlv.session.add_node(CoreNode, _id=node_one)
switch = 2
coretlv.session.add_node(SwitchNode, _id=switch)
node1_id = 1
coretlv.session.add_node(CoreNode, _id=node1_id)
switch_id = 2
coretlv.session.add_node(SwitchNode, _id=switch_id)
ip_prefix = netaddr.IPNetwork("10.0.0.0/24")
interface_one = str(ip_prefix[node_one])
interface1_ip4 = str(ip_prefix[node1_id])
message = coreapi.CoreLinkMessage.create(
MessageFlags.ADD.value,
[
(LinkTlvs.N1_NUMBER, node_one),
(LinkTlvs.N2_NUMBER, switch),
(LinkTlvs.N1_NUMBER, node1_id),
(LinkTlvs.N2_NUMBER, switch_id),
(LinkTlvs.INTERFACE1_NUMBER, 0),
(LinkTlvs.INTERFACE1_IP4, interface_one),
(LinkTlvs.INTERFACE1_IP4, interface1_ip4),
(LinkTlvs.INTERFACE1_IP4_MASK, 24),
],
)
coretlv.handle_message(message)
switch_node = coretlv.session.get_node(switch, SwitchNode)
switch_node = coretlv.session.get_node(switch_id, SwitchNode)
all_links = switch_node.all_link_data()
assert len(all_links) == 1
def test_link_add_net_to_node(self, coretlv: CoreHandler):
node_one = 1
coretlv.session.add_node(CoreNode, _id=node_one)
switch = 2
coretlv.session.add_node(SwitchNode, _id=switch)
node1_id = 1
coretlv.session.add_node(CoreNode, _id=node1_id)
switch_id = 2
coretlv.session.add_node(SwitchNode, _id=switch_id)
ip_prefix = netaddr.IPNetwork("10.0.0.0/24")
interface_one = str(ip_prefix[node_one])
interface2_ip4 = str(ip_prefix[node1_id])
message = coreapi.CoreLinkMessage.create(
MessageFlags.ADD.value,
[
(LinkTlvs.N1_NUMBER, switch),
(LinkTlvs.N2_NUMBER, node_one),
(LinkTlvs.N1_NUMBER, switch_id),
(LinkTlvs.N2_NUMBER, node1_id),
(LinkTlvs.INTERFACE2_NUMBER, 0),
(LinkTlvs.INTERFACE2_IP4, interface_one),
(LinkTlvs.INTERFACE2_IP4, interface2_ip4),
(LinkTlvs.INTERFACE2_IP4_MASK, 24),
],
)
coretlv.handle_message(message)
switch_node = coretlv.session.get_node(switch, SwitchNode)
switch_node = coretlv.session.get_node(switch_id, SwitchNode)
all_links = switch_node.all_link_data()
assert len(all_links) == 1
def test_link_add_node_to_node(self, coretlv: CoreHandler):
node_one = 1
coretlv.session.add_node(CoreNode, _id=node_one)
node_two = 2
coretlv.session.add_node(CoreNode, _id=node_two)
node1_id = 1
coretlv.session.add_node(CoreNode, _id=node1_id)
node2_id = 2
coretlv.session.add_node(CoreNode, _id=node2_id)
ip_prefix = netaddr.IPNetwork("10.0.0.0/24")
interface_one = str(ip_prefix[node_one])
interface_two = str(ip_prefix[node_two])
interface1_ip4 = str(ip_prefix[node1_id])
interface2_ip4 = str(ip_prefix[node2_id])
message = coreapi.CoreLinkMessage.create(
MessageFlags.ADD.value,
[
(LinkTlvs.N1_NUMBER, node_one),
(LinkTlvs.N2_NUMBER, node_two),
(LinkTlvs.N1_NUMBER, node1_id),
(LinkTlvs.N2_NUMBER, node2_id),
(LinkTlvs.INTERFACE1_NUMBER, 0),
(LinkTlvs.INTERFACE1_IP4, interface_one),
(LinkTlvs.INTERFACE1_IP4, interface1_ip4),
(LinkTlvs.INTERFACE1_IP4_MASK, 24),
(LinkTlvs.INTERFACE2_NUMBER, 0),
(LinkTlvs.INTERFACE2_IP4, interface_two),
(LinkTlvs.INTERFACE2_IP4, interface2_ip4),
(LinkTlvs.INTERFACE2_IP4_MASK, 24),
],
)
@ -177,24 +180,24 @@ class TestGui:
assert len(all_links) == 1
def test_link_update(self, coretlv: CoreHandler):
node_one = 1
coretlv.session.add_node(CoreNode, _id=node_one)
switch = 2
coretlv.session.add_node(SwitchNode, _id=switch)
node1_id = 1
coretlv.session.add_node(CoreNode, _id=node1_id)
switch_id = 2
coretlv.session.add_node(SwitchNode, _id=switch_id)
ip_prefix = netaddr.IPNetwork("10.0.0.0/24")
interface_one = str(ip_prefix[node_one])
interface1_ip4 = str(ip_prefix[node1_id])
message = coreapi.CoreLinkMessage.create(
MessageFlags.ADD.value,
[
(LinkTlvs.N1_NUMBER, node_one),
(LinkTlvs.N2_NUMBER, switch),
(LinkTlvs.N1_NUMBER, node1_id),
(LinkTlvs.N2_NUMBER, switch_id),
(LinkTlvs.INTERFACE1_NUMBER, 0),
(LinkTlvs.INTERFACE1_IP4, interface_one),
(LinkTlvs.INTERFACE1_IP4, interface1_ip4),
(LinkTlvs.INTERFACE1_IP4_MASK, 24),
],
)
coretlv.handle_message(message)
switch_node = coretlv.session.get_node(switch, SwitchNode)
switch_node = coretlv.session.get_node(switch_id, SwitchNode)
all_links = switch_node.all_link_data()
assert len(all_links) == 1
link = all_links[0]
@ -204,37 +207,37 @@ class TestGui:
message = coreapi.CoreLinkMessage.create(
0,
[
(LinkTlvs.N1_NUMBER, node_one),
(LinkTlvs.N2_NUMBER, switch),
(LinkTlvs.N1_NUMBER, node1_id),
(LinkTlvs.N2_NUMBER, switch_id),
(LinkTlvs.INTERFACE1_NUMBER, 0),
(LinkTlvs.BANDWIDTH, bandwidth),
],
)
coretlv.handle_message(message)
switch_node = coretlv.session.get_node(switch, SwitchNode)
switch_node = coretlv.session.get_node(switch_id, SwitchNode)
all_links = switch_node.all_link_data()
assert len(all_links) == 1
link = all_links[0]
assert link.bandwidth == bandwidth
def test_link_delete_node_to_node(self, coretlv: CoreHandler):
node_one = 1
coretlv.session.add_node(CoreNode, _id=node_one)
node_two = 2
coretlv.session.add_node(CoreNode, _id=node_two)
node1_id = 1
coretlv.session.add_node(CoreNode, _id=node1_id)
node2_id = 2
coretlv.session.add_node(CoreNode, _id=node2_id)
ip_prefix = netaddr.IPNetwork("10.0.0.0/24")
interface_one = str(ip_prefix[node_one])
interface_two = str(ip_prefix[node_two])
interface1_ip4 = str(ip_prefix[node1_id])
interface2_ip4 = str(ip_prefix[node2_id])
message = coreapi.CoreLinkMessage.create(
MessageFlags.ADD.value,
[
(LinkTlvs.N1_NUMBER, node_one),
(LinkTlvs.N2_NUMBER, node_two),
(LinkTlvs.N1_NUMBER, node1_id),
(LinkTlvs.N2_NUMBER, node2_id),
(LinkTlvs.INTERFACE1_NUMBER, 0),
(LinkTlvs.INTERFACE1_IP4, interface_one),
(LinkTlvs.INTERFACE1_IP4, interface1_ip4),
(LinkTlvs.INTERFACE1_IP4_MASK, 24),
(LinkTlvs.INTERFACE2_IP4, interface_two),
(LinkTlvs.INTERFACE2_IP4, interface2_ip4),
(LinkTlvs.INTERFACE2_IP4_MASK, 24),
],
)
@ -248,8 +251,8 @@ class TestGui:
message = coreapi.CoreLinkMessage.create(
MessageFlags.DELETE.value,
[
(LinkTlvs.N1_NUMBER, node_one),
(LinkTlvs.N2_NUMBER, node_two),
(LinkTlvs.N1_NUMBER, node1_id),
(LinkTlvs.N2_NUMBER, node2_id),
(LinkTlvs.INTERFACE1_NUMBER, 0),
(LinkTlvs.INTERFACE2_NUMBER, 0),
],
@ -263,74 +266,74 @@ class TestGui:
assert len(all_links) == 0
def test_link_delete_node_to_net(self, coretlv: CoreHandler):
node_one = 1
coretlv.session.add_node(CoreNode, _id=node_one)
switch = 2
coretlv.session.add_node(SwitchNode, _id=switch)
node1_id = 1
coretlv.session.add_node(CoreNode, _id=node1_id)
switch_id = 2
coretlv.session.add_node(SwitchNode, _id=switch_id)
ip_prefix = netaddr.IPNetwork("10.0.0.0/24")
interface_one = str(ip_prefix[node_one])
interface1_ip4 = str(ip_prefix[node1_id])
message = coreapi.CoreLinkMessage.create(
MessageFlags.ADD.value,
[
(LinkTlvs.N1_NUMBER, node_one),
(LinkTlvs.N2_NUMBER, switch),
(LinkTlvs.N1_NUMBER, node1_id),
(LinkTlvs.N2_NUMBER, switch_id),
(LinkTlvs.INTERFACE1_NUMBER, 0),
(LinkTlvs.INTERFACE1_IP4, interface_one),
(LinkTlvs.INTERFACE1_IP4, interface1_ip4),
(LinkTlvs.INTERFACE1_IP4_MASK, 24),
],
)
coretlv.handle_message(message)
switch_node = coretlv.session.get_node(switch, SwitchNode)
switch_node = coretlv.session.get_node(switch_id, SwitchNode)
all_links = switch_node.all_link_data()
assert len(all_links) == 1
message = coreapi.CoreLinkMessage.create(
MessageFlags.DELETE.value,
[
(LinkTlvs.N1_NUMBER, node_one),
(LinkTlvs.N2_NUMBER, switch),
(LinkTlvs.N1_NUMBER, node1_id),
(LinkTlvs.N2_NUMBER, switch_id),
(LinkTlvs.INTERFACE1_NUMBER, 0),
],
)
coretlv.handle_message(message)
switch_node = coretlv.session.get_node(switch, SwitchNode)
switch_node = coretlv.session.get_node(switch_id, SwitchNode)
all_links = switch_node.all_link_data()
assert len(all_links) == 0
def test_link_delete_net_to_node(self, coretlv: CoreHandler):
node_one = 1
coretlv.session.add_node(CoreNode, _id=node_one)
switch = 2
coretlv.session.add_node(SwitchNode, _id=switch)
node1_id = 1
coretlv.session.add_node(CoreNode, _id=node1_id)
switch_id = 2
coretlv.session.add_node(SwitchNode, _id=switch_id)
ip_prefix = netaddr.IPNetwork("10.0.0.0/24")
interface_one = str(ip_prefix[node_one])
interface1_ip4 = str(ip_prefix[node1_id])
message = coreapi.CoreLinkMessage.create(
MessageFlags.ADD.value,
[
(LinkTlvs.N1_NUMBER, node_one),
(LinkTlvs.N2_NUMBER, switch),
(LinkTlvs.N1_NUMBER, node1_id),
(LinkTlvs.N2_NUMBER, switch_id),
(LinkTlvs.INTERFACE1_NUMBER, 0),
(LinkTlvs.INTERFACE1_IP4, interface_one),
(LinkTlvs.INTERFACE1_IP4, interface1_ip4),
(LinkTlvs.INTERFACE1_IP4_MASK, 24),
],
)
coretlv.handle_message(message)
switch_node = coretlv.session.get_node(switch, SwitchNode)
switch_node = coretlv.session.get_node(switch_id, SwitchNode)
all_links = switch_node.all_link_data()
assert len(all_links) == 1
message = coreapi.CoreLinkMessage.create(
MessageFlags.DELETE.value,
[
(LinkTlvs.N1_NUMBER, switch),
(LinkTlvs.N2_NUMBER, node_one),
(LinkTlvs.N1_NUMBER, switch_id),
(LinkTlvs.N2_NUMBER, node1_id),
(LinkTlvs.INTERFACE2_NUMBER, 0),
],
)
coretlv.handle_message(message)
switch_node = coretlv.session.get_node(switch, SwitchNode)
switch_node = coretlv.session.get_node(switch_id, SwitchNode)
all_links = switch_node.all_link_data()
assert len(all_links) == 0
@ -379,7 +382,7 @@ class TestGui:
def test_file_hook_add(self, coretlv: CoreHandler):
state = EventTypes.DATACOLLECT_STATE
assert coretlv.session._hooks.get(state) is None
assert coretlv.session.hooks.get(state) is None
file_name = "test.sh"
file_data = "echo hello"
message = coreapi.CoreFileMessage.create(
@ -393,7 +396,7 @@ class TestGui:
coretlv.handle_message(message)
hooks = coretlv.session._hooks.get(state)
hooks = coretlv.session.hooks.get(state)
assert len(hooks) == 1
name, data = hooks[0]
assert file_name == name

246
daemon/tests/test_links.py
View file

@ -10,71 +10,71 @@ def create_ptp_network(
session: Session, ip_prefixes: IpPrefixes
) -> Tuple[CoreNode, CoreNode]:
# create nodes
node_one = session.add_node(CoreNode)
node_two = session.add_node(CoreNode)
node1 = session.add_node(CoreNode)
node2 = session.add_node(CoreNode)
# link nodes to net node
interface_one = ip_prefixes.create_interface(node_one)
interface_two = ip_prefixes.create_interface(node_two)
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
interface1_data = ip_prefixes.create_interface(node1)
interface2_data = ip_prefixes.create_interface(node2)
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# instantiate session
session.instantiate()
return node_one, node_two
return node1, node2
class TestLinks:
def test_add_ptp(self, session: Session, ip_prefixes: IpPrefixes):
# given
node_one = session.add_node(CoreNode)
node_two = session.add_node(CoreNode)
interface_one = ip_prefixes.create_interface(node_one)
interface_two = ip_prefixes.create_interface(node_two)
node1 = session.add_node(CoreNode)
node2 = session.add_node(CoreNode)
interface1_data = ip_prefixes.create_interface(node1)
interface2_data = ip_prefixes.create_interface(node2)
# when
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# then
assert node_one.netif(interface_one.id)
assert node_two.netif(interface_two.id)
assert node1.netif(interface1_data.id)
assert node2.netif(interface2_data.id)
def test_add_node_to_net(self, session: Session, ip_prefixes: IpPrefixes):
# given
node_one = session.add_node(CoreNode)
node_two = session.add_node(SwitchNode)
interface_one = ip_prefixes.create_interface(node_one)
node1 = session.add_node(CoreNode)
node2 = session.add_node(SwitchNode)
interface1_data = ip_prefixes.create_interface(node1)
# when
session.add_link(node_one.id, node_two.id, interface_one=interface_one)
session.add_link(node1.id, node2.id, interface1_data=interface1_data)
# then
assert node_two.all_link_data()
assert node_one.netif(interface_one.id)
assert node2.all_link_data()
assert node1.netif(interface1_data.id)
def test_add_net_to_node(self, session: Session, ip_prefixes: IpPrefixes):
# given
node_one = session.add_node(SwitchNode)
node_two = session.add_node(CoreNode)
interface_two = ip_prefixes.create_interface(node_two)
node1 = session.add_node(SwitchNode)
node2 = session.add_node(CoreNode)
interface2_data = ip_prefixes.create_interface(node2)
# when
session.add_link(node_one.id, node_two.id, interface_two=interface_two)
session.add_link(node1.id, node2.id, interface2_data=interface2_data)
# then
assert node_one.all_link_data()
assert node_two.netif(interface_two.id)
assert node1.all_link_data()
assert node2.netif(interface2_data.id)
def test_add_net_to_net(self, session):
# given
node_one = session.add_node(SwitchNode)
node_two = session.add_node(SwitchNode)
node1 = session.add_node(SwitchNode)
node2 = session.add_node(SwitchNode)
# when
session.add_link(node_one.id, node_two.id)
session.add_link(node1.id, node2.id)
# then
assert node_one.all_link_data()
assert node1.all_link_data()
def test_update_node_to_net(self, session: Session, ip_prefixes: IpPrefixes):
# given
@ -83,34 +83,31 @@ class TestLinks:
loss = 25
dup = 25
jitter = 10
node_one = session.add_node(CoreNode)
node_two = session.add_node(SwitchNode)
interface_one_data = ip_prefixes.create_interface(node_one)
session.add_link(node_one.id, node_two.id, interface_one_data)
interface_one = node_one.netif(interface_one_data.id)
assert interface_one.getparam("delay") != delay
assert interface_one.getparam("bw") != bandwidth
assert interface_one.getparam("loss") != loss
assert interface_one.getparam("duplicate") != dup
assert interface_one.getparam("jitter") != jitter
node1 = session.add_node(CoreNode)
node2 = session.add_node(SwitchNode)
interface1_data = ip_prefixes.create_interface(node1)
session.add_link(node1.id, node2.id, interface1_data)
interface1 = node1.netif(interface1_data.id)
assert interface1.getparam("delay") != delay
assert interface1.getparam("bw") != bandwidth
assert interface1.getparam("loss") != loss
assert interface1.getparam("duplicate") != dup
assert interface1.getparam("jitter") != jitter
# when
link_options = LinkOptions(
options = LinkOptions(
delay=delay, bandwidth=bandwidth, loss=loss, dup=dup, jitter=jitter
)
session.update_link(
node_one.id,
node_two.id,
interface_one_id=interface_one_data.id,
options=link_options,
node1.id, node2.id, interface1_id=interface1_data.id, options=options
)
# then
assert interface_one.getparam("delay") == delay
assert interface_one.getparam("bw") == bandwidth
assert interface_one.getparam("loss") == loss
assert interface_one.getparam("duplicate") == dup
assert interface_one.getparam("jitter") == jitter
assert interface1.getparam("delay") == delay
assert interface1.getparam("bw") == bandwidth
assert interface1.getparam("loss") == loss
assert interface1.getparam("duplicate") == dup
assert interface1.getparam("jitter") == jitter
def test_update_net_to_node(self, session: Session, ip_prefixes: IpPrefixes):
# given
@ -119,34 +116,31 @@ class TestLinks:
loss = 25
dup = 25
jitter = 10
node_one = session.add_node(SwitchNode)
node_two = session.add_node(CoreNode)
interface_two_data = ip_prefixes.create_interface(node_two)
session.add_link(node_one.id, node_two.id, interface_two=interface_two_data)
interface_two = node_two.netif(interface_two_data.id)
assert interface_two.getparam("delay") != delay
assert interface_two.getparam("bw") != bandwidth
assert interface_two.getparam("loss") != loss
assert interface_two.getparam("duplicate") != dup
assert interface_two.getparam("jitter") != jitter
node1 = session.add_node(SwitchNode)
node2 = session.add_node(CoreNode)
interface2_data = ip_prefixes.create_interface(node2)
session.add_link(node1.id, node2.id, interface2_data=interface2_data)
interface2 = node2.netif(interface2_data.id)
assert interface2.getparam("delay") != delay
assert interface2.getparam("bw") != bandwidth
assert interface2.getparam("loss") != loss
assert interface2.getparam("duplicate") != dup
assert interface2.getparam("jitter") != jitter
# when
link_options = LinkOptions(
options = LinkOptions(
delay=delay, bandwidth=bandwidth, loss=loss, dup=dup, jitter=jitter
)
session.update_link(
node_one.id,
node_two.id,
interface_two_id=interface_two_data.id,
options=link_options,
node1.id, node2.id, interface2_id=interface2_data.id, options=options
)
# then
assert interface_two.getparam("delay") == delay
assert interface_two.getparam("bw") == bandwidth
assert interface_two.getparam("loss") == loss
assert interface_two.getparam("duplicate") == dup
assert interface_two.getparam("jitter") == jitter
assert interface2.getparam("delay") == delay
assert interface2.getparam("bw") == bandwidth
assert interface2.getparam("loss") == loss
assert interface2.getparam("duplicate") == dup
assert interface2.getparam("jitter") == jitter
def test_update_ptp(self, session: Session, ip_prefixes: IpPrefixes):
# given
@ -155,93 +149,85 @@ class TestLinks:
loss = 25
dup = 25
jitter = 10
node_one = session.add_node(CoreNode)
node_two = session.add_node(CoreNode)
interface_one_data = ip_prefixes.create_interface(node_one)
interface_two_data = ip_prefixes.create_interface(node_two)
session.add_link(
node_one.id, node_two.id, interface_one_data, interface_two_data
)
interface_one = node_one.netif(interface_one_data.id)
interface_two = node_two.netif(interface_two_data.id)
assert interface_one.getparam("delay") != delay
assert interface_one.getparam("bw") != bandwidth
assert interface_one.getparam("loss") != loss
assert interface_one.getparam("duplicate") != dup
assert interface_one.getparam("jitter") != jitter
assert interface_two.getparam("delay") != delay
assert interface_two.getparam("bw") != bandwidth
assert interface_two.getparam("loss") != loss
assert interface_two.getparam("duplicate") != dup
assert interface_two.getparam("jitter") != jitter
node1 = session.add_node(CoreNode)
node2 = session.add_node(CoreNode)
interface1_data = ip_prefixes.create_interface(node1)
interface2_data = ip_prefixes.create_interface(node2)
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
interface1 = node1.netif(interface1_data.id)
interface2 = node2.netif(interface2_data.id)
assert interface1.getparam("delay") != delay
assert interface1.getparam("bw") != bandwidth
assert interface1.getparam("loss") != loss
assert interface1.getparam("duplicate") != dup
assert interface1.getparam("jitter") != jitter
assert interface2.getparam("delay") != delay
assert interface2.getparam("bw") != bandwidth
assert interface2.getparam("loss") != loss
assert interface2.getparam("duplicate") != dup
assert interface2.getparam("jitter") != jitter
# when
link_options = LinkOptions(
options = LinkOptions(
delay=delay, bandwidth=bandwidth, loss=loss, dup=dup, jitter=jitter
)
session.update_link(
node_one.id,
node_two.id,
interface_one_data.id,
interface_two_data.id,
link_options,
node1.id, node2.id, interface1_data.id, interface2_data.id, options
)
# then
assert interface_one.getparam("delay") == delay
assert interface_one.getparam("bw") == bandwidth
assert interface_one.getparam("loss") == loss
assert interface_one.getparam("duplicate") == dup
assert interface_one.getparam("jitter") == jitter
assert interface_two.getparam("delay") == delay
assert interface_two.getparam("bw") == bandwidth
assert interface_two.getparam("loss") == loss
assert interface_two.getparam("duplicate") == dup
assert interface_two.getparam("jitter") == jitter
assert interface1.getparam("delay") == delay
assert interface1.getparam("bw") == bandwidth
assert interface1.getparam("loss") == loss
assert interface1.getparam("duplicate") == dup
assert interface1.getparam("jitter") == jitter
assert interface2.getparam("delay") == delay
assert interface2.getparam("bw") == bandwidth
assert interface2.getparam("loss") == loss
assert interface2.getparam("duplicate") == dup
assert interface2.getparam("jitter") == jitter
def test_delete_ptp(self, session: Session, ip_prefixes: IpPrefixes):
# given
node_one = session.add_node(CoreNode)
node_two = session.add_node(CoreNode)
interface_one = ip_prefixes.create_interface(node_one)
interface_two = ip_prefixes.create_interface(node_two)
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
assert node_one.netif(interface_one.id)
assert node_two.netif(interface_two.id)
node1 = session.add_node(CoreNode)
node2 = session.add_node(CoreNode)
interface1_data = ip_prefixes.create_interface(node1)
interface2_data = ip_prefixes.create_interface(node2)
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
assert node1.netif(interface1_data.id)
assert node2.netif(interface2_data.id)
# when
session.delete_link(
node_one.id, node_two.id, interface_one.id, interface_two.id
)
session.delete_link(node1.id, node2.id, interface1_data.id, interface2_data.id)
# then
assert not node_one.netif(interface_one.id)
assert not node_two.netif(interface_two.id)
assert not node1.netif(interface1_data.id)
assert not node2.netif(interface2_data.id)
def test_delete_node_to_net(self, session: Session, ip_prefixes: IpPrefixes):
# given
node_one = session.add_node(CoreNode)
node_two = session.add_node(SwitchNode)
interface_one = ip_prefixes.create_interface(node_one)
session.add_link(node_one.id, node_two.id, interface_one)
assert node_one.netif(interface_one.id)
node1 = session.add_node(CoreNode)
node2 = session.add_node(SwitchNode)
interface1_data = ip_prefixes.create_interface(node1)
session.add_link(node1.id, node2.id, interface1_data)
assert node1.netif(interface1_data.id)
# when
session.delete_link(node_one.id, node_two.id, interface_one_id=interface_one.id)
session.delete_link(node1.id, node2.id, interface1_id=interface1_data.id)
# then
assert not node_one.netif(interface_one.id)
assert not node1.netif(interface1_data.id)
def test_delete_net_to_node(self, session: Session, ip_prefixes: IpPrefixes):
# given
node_one = session.add_node(SwitchNode)
node_two = session.add_node(CoreNode)
interface_two = ip_prefixes.create_interface(node_two)
session.add_link(node_one.id, node_two.id, interface_two=interface_two)
assert node_two.netif(interface_two.id)
node1 = session.add_node(SwitchNode)
node2 = session.add_node(CoreNode)
interface2_data = ip_prefixes.create_interface(node2)
session.add_link(node1.id, node2.id, interface2_data=interface2_data)
assert node2.netif(interface2_data.id)
# when
session.delete_link(node_one.id, node_two.id, interface_two_id=interface_two.id)
session.delete_link(node1.id, node2.id, interface2_id=interface2_data.id)
# then
assert not node_two.netif(interface_two.id)
assert not node2.netif(interface2_data.id)

20
daemon/tests/test_services.py
View file

@ -206,23 +206,23 @@ class TestServices:
# given
ServiceManager.add_services(_SERVICES_PATH)
my_service = ServiceManager.get(SERVICE_ONE)
node_one = session.add_node(CoreNode)
node_two = session.add_node(CoreNode)
node1 = session.add_node(CoreNode)
node2 = session.add_node(CoreNode)
file_name = my_service.configs[0]
file_data_one = "# custom file one"
file_data_two = "# custom file two"
file_data1 = "# custom file one"
file_data2 = "# custom file two"
session.services.set_service_file(
node_one.id, my_service.name, file_name, file_data_one
node1.id, my_service.name, file_name, file_data1
)
session.services.set_service_file(
node_two.id, my_service.name, file_name, file_data_two
node2.id, my_service.name, file_name, file_data2
)
# when
custom_service_one = session.services.get_service(node_one.id, my_service.name)
session.services.create_service_files(node_one, custom_service_one)
custom_service_two = session.services.get_service(node_two.id, my_service.name)
session.services.create_service_files(node_two, custom_service_two)
custom_service1 = session.services.get_service(node1.id, my_service.name)
session.services.create_service_files(node1, custom_service1)
custom_service2 = session.services.get_service(node2.id, my_service.name)
session.services.create_service_files(node2, custom_service2)
def test_service_import(self):
"""

260
daemon/tests/test_xml.py
View file

@ -48,7 +48,7 @@ class TestXml:
session.open_xml(file_path, start=True)
# verify nodes have been recreated
runtime_hooks = session._hooks.get(state)
runtime_hooks = session.hooks.get(state)
assert runtime_hooks
runtime_hook = runtime_hooks[0]
assert file_name == runtime_hook[0]
@ -68,20 +68,20 @@ class TestXml:
ptp_node = session.add_node(PtpNet)
# create nodes
node_one = session.add_node(CoreNode)
node_two = session.add_node(CoreNode)
node1 = session.add_node(CoreNode)
node2 = session.add_node(CoreNode)
# link nodes to ptp net
for node in [node_one, node_two]:
for node in [node1, node2]:
interface = ip_prefixes.create_interface(node)
session.add_link(node.id, ptp_node.id, interface_one=interface)
session.add_link(node.id, ptp_node.id, interface1_data=interface)
# instantiate session
session.instantiate()
# get ids for nodes
n1_id = node_one.id
n2_id = node_two.id
node1_id = node1.id
node2_id = node2.id
# save xml
xml_file = tmpdir.join("session.xml")
@ -97,16 +97,16 @@ class TestXml:
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(n1_id, CoreNode)
assert not session.get_node(node1_id, CoreNode)
with pytest.raises(CoreError):
assert not session.get_node(n2_id, CoreNode)
assert not session.get_node(node2_id, CoreNode)
# load saved xml
session.open_xml(file_path, start=True)
# verify nodes have been recreated
assert session.get_node(n1_id, CoreNode)
assert session.get_node(n2_id, CoreNode)
assert session.get_node(node1_id, CoreNode)
assert session.get_node(node2_id, CoreNode)
def test_xml_ptp_services(
self, session: Session, tmpdir: TemporaryFile, ip_prefixes: IpPrefixes
@ -123,28 +123,28 @@ class TestXml:
# create nodes
options = NodeOptions(model="host")
node_one = session.add_node(CoreNode, options=options)
node_two = session.add_node(CoreNode)
node1 = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode)
# link nodes to ptp net
for node in [node_one, node_two]:
for node in [node1, node2]:
interface = ip_prefixes.create_interface(node)
session.add_link(node.id, ptp_node.id, interface_one=interface)
session.add_link(node.id, ptp_node.id, interface1_data=interface)
# set custom values for node service
session.services.set_service(node_one.id, SshService.name)
session.services.set_service(node1.id, SshService.name)
service_file = SshService.configs[0]
file_data = "# test"
session.services.set_service_file(
node_one.id, SshService.name, service_file, file_data
node1.id, SshService.name, service_file, file_data
)
# instantiate session
session.instantiate()
# get ids for nodes
n1_id = node_one.id
n2_id = node_two.id
node1_id = node1.id
node2_id = node2.id
# save xml
xml_file = tmpdir.join("session.xml")
@ -160,19 +160,19 @@ class TestXml:
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(n1_id, CoreNode)
assert not session.get_node(node1_id, CoreNode)
with pytest.raises(CoreError):
assert not session.get_node(n2_id, CoreNode)
assert not session.get_node(node2_id, CoreNode)
# load saved xml
session.open_xml(file_path, start=True)
# retrieve custom service
service = session.services.get_service(node_one.id, SshService.name)
service = session.services.get_service(node1.id, SshService.name)
# verify nodes have been recreated
assert session.get_node(n1_id, CoreNode)
assert session.get_node(n2_id, CoreNode)
assert session.get_node(node1_id, CoreNode)
assert session.get_node(node2_id, CoreNode)
assert service.config_data.get(service_file) == file_data
def test_xml_mobility(
@ -192,21 +192,21 @@ class TestXml:
# create nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node_one = session.add_node(CoreNode, options=options)
node_two = session.add_node(CoreNode, options=options)
node1 = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode, options=options)
# link nodes
for node in [node_one, node_two]:
for node in [node1, node2]:
interface = ip_prefixes.create_interface(node)
session.add_link(node.id, wlan_node.id, interface_one=interface)
session.add_link(node.id, wlan_node.id, interface1_data=interface)
# instantiate session
session.instantiate()
# get ids for nodes
wlan_id = wlan_node.id
n1_id = node_one.id
n2_id = node_two.id
node1_id = node1.id
node2_id = node2.id
# save xml
xml_file = tmpdir.join("session.xml")
@ -222,9 +222,9 @@ class TestXml:
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(n1_id, CoreNode)
assert not session.get_node(node1_id, CoreNode)
with pytest.raises(CoreError):
assert not session.get_node(n2_id, CoreNode)
assert not session.get_node(node2_id, CoreNode)
# load saved xml
session.open_xml(file_path, start=True)
@ -233,8 +233,8 @@ class TestXml:
value = str(session.mobility.get_config("test", wlan_id, BasicRangeModel.name))
# verify nodes and configuration were restored
assert session.get_node(n1_id, CoreNode)
assert session.get_node(n2_id, CoreNode)
assert session.get_node(node1_id, CoreNode)
assert session.get_node(node2_id, CoreNode)
assert session.get_node(wlan_id, WlanNode)
assert value == "1"
@ -246,18 +246,18 @@ class TestXml:
:param tmpdir: tmpdir to create data in
"""
# create nodes
switch_one = session.add_node(SwitchNode)
switch_two = session.add_node(SwitchNode)
switch1 = session.add_node(SwitchNode)
switch2 = session.add_node(SwitchNode)
# link nodes
session.add_link(switch_one.id, switch_two.id)
session.add_link(switch1.id, switch2.id)
# instantiate session
session.instantiate()
# get ids for nodes
n1_id = switch_one.id
n2_id = switch_two.id
node1_id = switch1.id
node2_id = switch2.id
# save xml
xml_file = tmpdir.join("session.xml")
@ -273,19 +273,19 @@ class TestXml:
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(n1_id, SwitchNode)
assert not session.get_node(node1_id, SwitchNode)
with pytest.raises(CoreError):
assert not session.get_node(n2_id, SwitchNode)
assert not session.get_node(node2_id, SwitchNode)
# load saved xml
session.open_xml(file_path, start=True)
# verify nodes have been recreated
switch_one = session.get_node(n1_id, SwitchNode)
switch_two = session.get_node(n2_id, SwitchNode)
assert switch_one
assert switch_two
assert len(switch_one.all_link_data() + switch_two.all_link_data()) == 1
switch1 = session.get_node(node1_id, SwitchNode)
switch2 = session.get_node(node2_id, SwitchNode)
assert switch1
assert switch2
assert len(switch1.all_link_data() + switch2.all_link_data()) == 1
def test_link_options(
self, session: Session, tmpdir: TemporaryFile, ip_prefixes: IpPrefixes
@ -298,25 +298,25 @@ class TestXml:
:param ip_prefixes: generates ip addresses for nodes
"""
# create nodes
node_one = session.add_node(CoreNode)
interface_one = ip_prefixes.create_interface(node_one)
node1 = session.add_node(CoreNode)
interface1_data = ip_prefixes.create_interface(node1)
switch = session.add_node(SwitchNode)
# create link
link_options = LinkOptions()
link_options.loss = 10.5
link_options.bandwidth = 50000
link_options.jitter = 10
link_options.delay = 30
link_options.dup = 5
session.add_link(node_one.id, switch.id, interface_one, options=link_options)
options = LinkOptions()
options.loss = 10.5
options.bandwidth = 50000
options.jitter = 10
options.delay = 30
options.dup = 5
session.add_link(node1.id, switch.id, interface1_data, options=options)
# instantiate session
session.instantiate()
# get ids for nodes
n1_id = node_one.id
n2_id = switch.id
node1_id = node1.id
node2_id = switch.id
# save xml
xml_file = tmpdir.join("session.xml")
@ -332,26 +332,26 @@ class TestXml:
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(n1_id, CoreNode)
assert not session.get_node(node1_id, CoreNode)
with pytest.raises(CoreError):
assert not session.get_node(n2_id, SwitchNode)
assert not session.get_node(node2_id, SwitchNode)
# load saved xml
session.open_xml(file_path, start=True)
# verify nodes have been recreated
assert session.get_node(n1_id, CoreNode)
assert session.get_node(n2_id, SwitchNode)
assert session.get_node(node1_id, CoreNode)
assert session.get_node(node2_id, SwitchNode)
links = []
for node_id in session.nodes:
node = session.nodes[node_id]
links += node.all_link_data()
link = links[0]
assert link_options.loss == link.loss
assert link_options.bandwidth == link.bandwidth
assert link_options.jitter == link.jitter
assert link_options.delay == link.delay
assert link_options.dup == link.dup
assert options.loss == link.loss
assert options.bandwidth == link.bandwidth
assert options.jitter == link.jitter
assert options.delay == link.delay
assert options.dup == link.dup
def test_link_options_ptp(
self, session: Session, tmpdir: TemporaryFile, ip_prefixes: IpPrefixes
@ -364,28 +364,26 @@ class TestXml:
:param ip_prefixes: generates ip addresses for nodes
"""
# create nodes
node_one = session.add_node(CoreNode)
interface_one = ip_prefixes.create_interface(node_one)
node_two = session.add_node(CoreNode)
interface_two = ip_prefixes.create_interface(node_two)
node1 = session.add_node(CoreNode)
interface1_data = ip_prefixes.create_interface(node1)
node2 = session.add_node(CoreNode)
interface2_data = ip_prefixes.create_interface(node2)
# create link
link_options = LinkOptions()
link_options.loss = 10.5
link_options.bandwidth = 50000
link_options.jitter = 10
link_options.delay = 30
link_options.dup = 5
session.add_link(
node_one.id, node_two.id, interface_one, interface_two, link_options
)
options = LinkOptions()
options.loss = 10.5
options.bandwidth = 50000
options.jitter = 10
options.delay = 30
options.dup = 5
session.add_link(node1.id, node2.id, interface1_data, interface2_data, options)
# instantiate session
session.instantiate()
# get ids for nodes
n1_id = node_one.id
n2_id = node_two.id
node1_id = node1.id
node2_id = node2.id
# save xml
xml_file = tmpdir.join("session.xml")
@ -401,26 +399,26 @@ class TestXml:
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(n1_id, CoreNode)
assert not session.get_node(node1_id, CoreNode)
with pytest.raises(CoreError):
assert not session.get_node(n2_id, CoreNode)
assert not session.get_node(node2_id, CoreNode)
# load saved xml
session.open_xml(file_path, start=True)
# verify nodes have been recreated
assert session.get_node(n1_id, CoreNode)
assert session.get_node(n2_id, CoreNode)
assert session.get_node(node1_id, CoreNode)
assert session.get_node(node2_id, CoreNode)
links = []
for node_id in session.nodes:
node = session.nodes[node_id]
links += node.all_link_data()
link = links[0]
assert link_options.loss == link.loss
assert link_options.bandwidth == link.bandwidth
assert link_options.jitter == link.jitter
assert link_options.delay == link.delay
assert link_options.dup == link.dup
assert options.loss == link.loss
assert options.bandwidth == link.bandwidth
assert options.jitter == link.jitter
assert options.delay == link.delay
assert options.dup == link.dup
def test_link_options_bidirectional(
self, session: Session, tmpdir: TemporaryFile, ip_prefixes: IpPrefixes
@ -433,43 +431,37 @@ class TestXml:
:param ip_prefixes: generates ip addresses for nodes
"""
# create nodes
node_one = session.add_node(CoreNode)
interface_one = ip_prefixes.create_interface(node_one)
node_two = session.add_node(CoreNode)
interface_two = ip_prefixes.create_interface(node_two)
node1 = session.add_node(CoreNode)
interface1_data = ip_prefixes.create_interface(node1)
node2 = session.add_node(CoreNode)
interface2_data = ip_prefixes.create_interface(node2)
# create link
link_options_one = LinkOptions()
link_options_one.unidirectional = 1
link_options_one.bandwidth = 5000
link_options_one.delay = 10
link_options_one.loss = 10.5
link_options_one.dup = 5
link_options_one.jitter = 5
session.add_link(
node_one.id, node_two.id, interface_one, interface_two, link_options_one
)
link_options_two = LinkOptions()
link_options_two.unidirectional = 1
link_options_two.bandwidth = 10000
link_options_two.delay = 20
link_options_two.loss = 10
link_options_two.dup = 10
link_options_two.jitter = 10
options1 = LinkOptions()
options1.unidirectional = 1
options1.bandwidth = 5000
options1.delay = 10
options1.loss = 10.5
options1.dup = 5
options1.jitter = 5
session.add_link(node1.id, node2.id, interface1_data, interface2_data, options1)
options2 = LinkOptions()
options2.unidirectional = 1
options2.bandwidth = 10000
options2.delay = 20
options2.loss = 10
options2.dup = 10
options2.jitter = 10
session.update_link(
node_two.id,
node_one.id,
interface_two.id,
interface_one.id,
link_options_two,
node2.id, node1.id, interface2_data.id, interface1_data.id, options2
)
# instantiate session
session.instantiate()
# get ids for nodes
n1_id = node_one.id
n2_id = node_two.id
node1_id = node1.id
node2_id = node2.id
# save xml
xml_file = tmpdir.join("session.xml")
@ -485,30 +477,30 @@ class TestXml:
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(n1_id, CoreNode)
assert not session.get_node(node1_id, CoreNode)
with pytest.raises(CoreError):
assert not session.get_node(n2_id, CoreNode)
assert not session.get_node(node2_id, CoreNode)
# load saved xml
session.open_xml(file_path, start=True)
# verify nodes have been recreated
assert session.get_node(n1_id, CoreNode)
assert session.get_node(n2_id, CoreNode)
assert session.get_node(node1_id, CoreNode)
assert session.get_node(node2_id, CoreNode)
links = []
for node_id in session.nodes:
node = session.nodes[node_id]
links += node.all_link_data()
assert len(links) == 2
link_one = links[0]
link_two = links[1]
assert link_options_one.bandwidth == link_one.bandwidth
assert link_options_one.delay == link_one.delay
assert link_options_one.loss == link_one.loss
assert link_options_one.dup == link_one.dup
assert link_options_one.jitter == link_one.jitter
assert link_options_two.bandwidth == link_two.bandwidth
assert link_options_two.delay == link_two.delay
assert link_options_two.loss == link_two.loss
assert link_options_two.dup == link_two.dup
assert link_options_two.jitter == link_two.jitter
link1 = links[0]
link2 = links[1]
assert options1.bandwidth == link1.bandwidth
assert options1.delay == link1.delay
assert options1.loss == link1.loss
assert options1.dup == link1.dup
assert options1.jitter == link1.jitter
assert options2.bandwidth == link2.bandwidth
assert options2.delay == link2.delay
assert options2.loss == link2.loss
assert options2.dup == link2.dup
assert options2.jitter == link2.jitter

2
docs/scripting.md
View file

@ -62,7 +62,7 @@ def main():
for _ in range(NODES):
node = session.add_node(CoreNode)
interface = prefixes.create_interface(node)
session.add_link(node.id, switch.id, interface_one=interface)
session.add_link(node.id, switch.id, interface1_data=interface)
# instantiate session
session.instantiate()