def test_xml_emane_node_config(self, session: Session,
tmpdir: TemporaryFile,
ip_prefixes: IpPrefixes):
# create nodes
options = NodeOptions(model="mdr", x=50, y=50)
node1 = session.add_node(CoreNode, options=options)
iface1_data = ip_prefixes.create_iface(node1)
node2 = session.add_node(CoreNode, options=options)
iface2_data = ip_prefixes.create_iface(node2)
# create emane node
options = NodeOptions(model=None, emane=EmaneRfPipeModel.name)
emane_node = session.add_node(EmaneNet, options=options)
# create links
session.add_link(node1.id, emane_node.id, iface1_data)
session.add_link(node2.id, emane_node.id, iface2_data)
# set node specific config
datarate = "101"
session.emane.set_config(node1.id, EmaneRfPipeModel.name,
{"datarate": datarate})
# instantiate session
session.instantiate()
# save xml
xml_file = tmpdir.join("session.xml")
file_path = xml_file.strpath
session.save_xml(Path(file_path))
# verify xml file was created and can be parsed
assert xml_file.isfile()
assert ElementTree.parse(file_path)
# stop current session, clearing data
session.shutdown()
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(node1.id, CoreNode)
with pytest.raises(CoreError):
assert not session.get_node(node2.id, CoreNode)
with pytest.raises(CoreError):
assert not session.get_node(emane_node.id, EmaneNet)
# load saved xml
session.open_xml(Path(file_path), start=True)
# verify nodes have been recreated
assert session.get_node(node1.id, CoreNode)
assert session.get_node(node2.id, CoreNode)
assert session.get_node(emane_node.id, EmaneNet)
links = []
for node_id in session.nodes:
node = session.nodes[node_id]
links += node.links()
assert len(links) == 2
config = session.emane.get_config(node1.id, EmaneRfPipeModel.name)
assert config["datarate"] == datarate
def test_wlan_ping(self, session: Session, ip_prefixes: IpPrefixes):
"""
Test basic wlan network.
:param core.emulator.coreemu.EmuSession session: session for test
:param ip_prefixes: generates ip addresses for nodes
"""
# create wlan
wlan_node = session.add_node(WlanNode)
session.mobility.set_model(wlan_node, BasicRangeModel)
# create nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node1 = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode, options=options)
# link nodes
for node in [node1, node2]:
iface_id = ip_prefixes.create_iface(node)
session.add_link(node.id, wlan_node.id, iface1_data=iface_id)
# instantiate session
session.instantiate()
# ping node2 from node1 and assert success
status = ping(node1, node2, ip_prefixes)
assert not status
def main(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu({"distributed_address": args.address})
session = coreemu.create_session()
# initialize distributed
server_name = "core2"
session.distributed.add_server(server_name, args.server)
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create local node, switch, and remote nodes
options = NodeOptions()
node1 = session.add_node(CoreNode, options=options)
options.server = server_name
node2 = session.add_node(CoreNode, options=options)
# create node interfaces and link
interface1_data = prefixes.create_iface(node1)
interface2_data = prefixes.create_iface(node2)
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# instantiate session
session.instantiate()
# pause script for verification
input("press enter for shutdown")
# shutdown session
coreemu.shutdown()
def test_node_update(self, session: Session):
# given
node = session.add_node(CoreNode)
position_value = 100
update_options = NodeOptions()
update_options.set_position(x=position_value, y=position_value)
# when
session.edit_node(node.id, update_options)
# then
assert node.position.x == position_value
assert node.position.y == position_value
def add_node_data(
node_proto: core_pb2.Node) -> Tuple[NodeTypes, int, NodeOptions]:
"""
Convert node protobuf message to data for creating a node.
:param node_proto: node proto message
:return: node type, id, and options
"""
_id = node_proto.id
_type = NodeTypes(node_proto.type)
options = NodeOptions(
name=node_proto.name,
model=node_proto.model,
icon=node_proto.icon,
image=node_proto.image,
services=node_proto.services,
config_services=node_proto.config_services,
)
if node_proto.emane:
options.emane = node_proto.emane
if node_proto.server:
options.server = node_proto.server
position = node_proto.position
options.set_position(position.x, position.y)
if node_proto.HasField("geo"):
geo = node_proto.geo
options.set_location(geo.lat, geo.lon, geo.alt)
return _type, _id, options
def test_mobility(self, session: Session, ip_prefixes: IpPrefixes):
"""
Test basic wlan network.
:param core.emulator.coreemu.EmuSession session: session for test
:param ip_prefixes: generates ip addresses for nodes
"""
# create wlan
wlan_node = session.add_node(WlanNode)
session.mobility.set_model(wlan_node, BasicRangeModel)
# create nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node1 = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode, options=options)
# link nodes
for node in [node1, node2]:
iface_id = ip_prefixes.create_iface(node)
session.add_link(node.id, wlan_node.id, iface1_data=iface_id)
# configure mobility script for session
config = {
"file": _MOBILITY_FILE,
"refresh_ms": "50",
"loop": "1",
"autostart": "0.0",
"map": "",
"script_start": "",
"script_pause": "",
"script_stop": "",
}
session.mobility.set_model(wlan_node, Ns2ScriptedMobility, config)
# add handler for receiving node updates
event = threading.Event()
def node_update(_):
event.set()
session.node_handlers.append(node_update)
# instantiate session
session.instantiate()
# validate we receive a node message for updating its location
assert event.wait(5)
def test_set_emane_model_config(self, grpc_server: CoreGrpcServer):
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions(emane=EmaneIeee80211abgModel.name)
emane_network = session.add_node(EmaneNet, options=options)
session.emane.set_model(emane_network, EmaneIeee80211abgModel)
config_key = "bandwidth"
config_value = "900000"
# then
with client.context_connect():
response = client.set_emane_model_config(
session.id,
emane_network.id,
EmaneIeee80211abgModel.name,
{config_key: config_value},
)
# then
assert response.result is True
config = session.emane.get_model_config(
emane_network.id, EmaneIeee80211abgModel.name
)
assert config[config_key] == config_value
def test_set_emane_model_config(self, grpc_server: CoreGrpcServer):
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions(emane=EmaneIeee80211abgModel.name)
emane_network = session.add_node(EmaneNet, options=options)
session.emane.node_models[
emane_network.id] = EmaneIeee80211abgModel.name
config_key = "bandwidth"
config_value = "900000"
option = ConfigOption(
label=config_key,
name=config_key,
value=config_value,
type=ConfigOptionType.INT32,
group="Default",
)
config = EmaneModelConfig(emane_network.id,
EmaneIeee80211abgModel.name,
config={config_key: option})
# then
with client.context_connect():
result = client.set_emane_model_config(session.id, config)
# then
assert result is True
config = session.emane.get_config(emane_network.id,
EmaneIeee80211abgModel.name)
assert config[config_key] == config_value
def test_get_emane_model_configs(self, grpc_server: CoreGrpcServer):
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions(emane=EmaneIeee80211abgModel.name)
emane_network = session.add_node(EmaneNet, options=options)
session.emane.set_model(emane_network, EmaneIeee80211abgModel)
config_key = "platform_id_start"
config_value = "2"
session.emane.set_model_config(
emane_network.id, EmaneIeee80211abgModel.name, {config_key: config_value}
)
# then
with client.context_connect():
response = client.get_emane_model_configs(session.id)
# then
assert len(response.configs) == 1
model_config = response.configs[0]
assert emane_network.id == model_config.node_id
assert model_config.model == EmaneIeee80211abgModel.name
assert len(model_config.config) > 0
assert model_config.iface_id == -1
def test_models(self, session: Session, model: Type[EmaneModel],
ip_prefixes: IpPrefixes):
"""
Test emane models within a basic network.
:param core.emulator.coreemu.EmuSession session: session for test
:param model: emane model to test
:param ip_prefixes: generates ip addresses for nodes
"""
# create emane node for networking the core nodes
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions()
options.set_position(80, 50)
emane_network = session.add_node(EmaneNet, options=options)
session.emane.set_model(emane_network, model)
# configure tdma
if model == EmaneTdmaModel:
session.emane.set_model_config(
emane_network.id,
EmaneTdmaModel.name,
{
"schedule":
os.path.join(_DIR, "../../examples/tdma/schedule.xml")
},
)
# create nodes
options = NodeOptions(model="mdr")
options.set_position(150, 150)
node1 = session.add_node(CoreNode, options=options)
options.set_position(300, 150)
node2 = session.add_node(CoreNode, options=options)
for i, node in enumerate([node1, node2]):
node.setposition(x=150 * (i + 1), y=150)
iface_data = ip_prefixes.create_iface(node)
session.add_link(node.id, emane_network.id, iface1_data=iface_data)
# instantiate session
session.instantiate()
# ping node2 from node1 and assert success
status = ping(node1, node2, ip_prefixes, count=5)
assert not status
def read_network(self, network_element: etree.Element) -> None:
node_id = get_int(network_element, "id")
name = network_element.get("name")
node_type = NodeTypes[network_element.get("type")]
_class = self.session.get_node_class(node_type)
icon = network_element.get("icon")
server = network_element.get("server")
options = NodeOptions(name=name, icon=icon, server=server)
if node_type == NodeTypes.EMANE:
model = network_element.get("model")
options.emane = model
position_element = network_element.find("position")
if position_element is not None:
x = get_float(position_element, "x")
y = get_float(position_element, "y")
if all([x, y]):
options.set_position(x, y)
lat = get_float(position_element, "lat")
lon = get_float(position_element, "lon")
alt = get_float(position_element, "alt")
if all([lat, lon, alt]):
options.set_location(lat, lon, alt)
logging.info("reading node id(%s) node_type(%s) name(%s)", node_id,
node_type, name)
self.session.add_node(_class, node_id, options)
def create_nodes(session, num_nodes) -> (List[CoreNode], List[InterfaceData]):
node_options = NodeOptions(x=100, y=100)
nodes, ifaces = [], []
for i in range(num_nodes):
n = session.add_node(CoreNode, options=node_options)
iface = prefixes.create_iface(n)
nodes.append(n)
ifaces.append(iface)
return nodes, ifaces
def main(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu({
"controlnet":
"core1:172.16.1.0/24 core2:172.16.2.0/24 core3:172.16.3.0/24 "
"core4:172.16.4.0/24 core5:172.16.5.0/24",
"distributed_address":
args.address,
})
session = coreemu.create_session()
# initialize distributed
server_name = "core2"
session.distributed.add_server(server_name, args.server)
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create local node, switch, and remote nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node1 = session.add_node(CoreNode, options=options)
emane_net = session.add_node(EmaneNet)
session.emane.set_model(emane_net, EmaneIeee80211abgModel)
options.server = server_name
node2 = session.add_node(CoreNode, options=options)
# create node interfaces and link
interface1_data = prefixes.create_iface(node1)
interface2_data = prefixes.create_iface(node2)
session.add_link(node1.id, emane_net.id, iface1_data=interface1_data)
session.add_link(node2.id, emane_net.id, iface1_data=interface2_data)
# instantiate session
session.instantiate()
# pause script for verification
input("press enter for shutdown")
# shutdown session
coreemu.shutdown()
def test_node_add(self, session: Session, model: str):
# given
options = NodeOptions(model=model)
# when
node = session.add_node(CoreNode, options=options)
# then
assert node
assert node.alive()
assert node.up
def read_device(self, device_element: etree.Element) -> None:
node_id = get_int(device_element, "id")
name = device_element.get("name")
model = device_element.get("type")
icon = device_element.get("icon")
clazz = device_element.get("class")
image = device_element.get("image")
server = device_element.get("server")
options = NodeOptions(name=name,
model=model,
image=image,
icon=icon,
server=server)
node_type = NodeTypes.DEFAULT
if clazz == "docker":
node_type = NodeTypes.DOCKER
elif clazz == "lxc":
node_type = NodeTypes.LXC
_class = self.session.get_node_class(node_type)
service_elements = device_element.find("services")
if service_elements is not None:
options.services = [
x.get("name") for x in service_elements.iterchildren()
]
config_service_elements = device_element.find("configservices")
if config_service_elements is not None:
options.config_services = [
x.get("name") for x in config_service_elements.iterchildren()
]
position_element = device_element.find("position")
if position_element is not None:
x = get_float(position_element, "x")
y = get_float(position_element, "y")
if all([x, y]):
options.set_position(x, y)
lat = get_float(position_element, "lat")
lon = get_float(position_element, "lon")
alt = get_float(position_element, "alt")
if all([lat, lon, alt]):
options.set_location(lat, lon, alt)
logging.info("reading node id(%s) model(%s) name(%s)", node_id, model,
name)
self.session.add_node(_class, node_id, options)
def main():
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(WlanNode, _id=100)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes, must set a position for wlan basic range model
options = NodeOptions(model="mdr")
options.set_position(0, 0)
for _ in range(NODES):
node = session.add_node(CoreNode, options=options)
interface = prefixes.create_iface(node)
session.add_link(node.id, wlan.id, iface1_data=interface)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_node(1, CoreNode)
last_node = session.get_node(NODES, CoreNode)
address = prefixes.ip4_address(first_node.id)
logging.info("node %s pinging %s", last_node.name, address)
output = last_node.cmd(f"ping -c 3 {address}")
logging.info(output)
# shutdown session
coreemu.shutdown()
def test_remote_node(self, session: Session):
# given
server_name = "core2"
host = "127.0.0.1"
# when
session.distributed.add_server(server_name, host)
options = NodeOptions(server=server_name)
node = session.add_node(CoreNode, options=options)
session.instantiate()
# then
assert node.server is not None
assert node.server.name == server_name
assert node.server.host == host
def test_get_node_terminal(self, grpc_server: CoreGrpcServer):
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
session.set_state(EventTypes.CONFIGURATION_STATE)
options = NodeOptions(model="Host")
node = session.add_node(CoreNode, options=options)
session.instantiate()
# then
with client.context_connect():
response = client.get_node_terminal(session.id, node.id)
# then
assert response.terminal is not None
def test_service_action(self, grpc_server: CoreGrpcServer):
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
options = NodeOptions(legacy=True)
node = session.add_node(CoreNode, options=options)
service_name = "DefaultRoute"
# then
with client.context_connect():
result = client.service_action(session.id, node.id, service_name,
ServiceAction.STOP)
# then
assert result is True
def create_wlan(session, nodes, ifaces) -> WlanNode:
wlan = session.add_node(WlanNode, options=NodeOptions(x=100, y=100))
session.mobility.set_model_config(
wlan.id,
BasicRangeModel.name,
{
"range": "280",
"bandwidth": "55000000",
# "delay": "6000",
# "jitter": "5",
# "error": "5",
},
)
for n, i in zip(nodes, ifaces):
session.add_link(n.id, wlan.id, i)
return wlan
def test_get_emane_model_config(self, grpc_server: CoreGrpcServer):
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions(emane=EmaneIeee80211abgModel.name)
emane_network = session.add_node(EmaneNet, options=options)
session.emane.set_model(emane_network, EmaneIeee80211abgModel)
# then
with client.context_connect():
response = client.get_emane_model_config(
session.id, emane_network.id, EmaneIeee80211abgModel.name
)
# then
assert len(response.config) > 0
def test_node_command(self, request, grpc_server: CoreGrpcServer):
if request.config.getoption("mock"):
pytest.skip("mocking calls")
# given
client = CoreGrpcClient()
session = grpc_server.coreemu.create_session()
session.set_state(EventTypes.CONFIGURATION_STATE)
options = NodeOptions(model="Host")
node = session.add_node(CoreNode, options=options)
session.instantiate()
output = "hello world"
# then
command = f"echo {output}"
with client.context_connect():
response = client.node_command(session.id, node.id, command)
# then
assert response.output == output
def main():
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create emane network node, emane determines connectivity based on
# location, so the session and nodes must be configured to provide one
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions()
options.set_position(80, 50)
emane_network = session.add_node(EmaneNet, options=options, _id=100)
session.emane.set_model(emane_network, EmaneIeee80211abgModel)
# create nodes
options = NodeOptions(model="mdr")
for i in range(NODES):
node = session.add_node(CoreNode, options=options)
node.setposition(x=150 * (i + 1), y=150)
interface = prefixes.create_iface(node)
session.add_link(node.id, emane_network.id, iface1_data=interface)
# instantiate session
session.instantiate()
# OSPF MDR requires some time for routes to be created
logging.info("waiting %s seconds for OSPF MDR to create routes",
EMANE_DELAY)
time.sleep(EMANE_DELAY)
# get nodes to run example
first_node = session.get_node(1, CoreNode)
last_node = session.get_node(NODES, CoreNode)
address = prefixes.ip4_address(first_node.id)
logging.info("node %s pinging %s", last_node.name, address)
output = last_node.cmd(f"ping -c 3 {address}")
logging.info(output)
# shutdown session
coreemu.shutdown()
from core.emulator.coreemu import CoreEmu
from core.emulator.data import IpPrefixes, NodeOptions
from core.emulator.enumerations import EventTypes
from core.nodes.docker import DockerNode
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG)
coreemu = CoreEmu()
session = coreemu.create_session()
session.set_state(EventTypes.CONFIGURATION_STATE)
# create nodes and interfaces
try:
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
options = NodeOptions(model=None, image="ubuntu")
# create node one
node1 = session.add_node(DockerNode, options=options)
interface1_data = prefixes.create_iface(node1)
# create node two
node2 = session.add_node(DockerNode, options=options)
interface2_data = prefixes.create_iface(node2)
# add link
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# instantiate
session.instantiate()
finally:
from core.nodes.network import SwitchNode # ip nerator for example ip_prefixes = IpPrefixes(ip4_prefix="10.0.0.0/24") # create emulator instance for creating sessions and utility methods coreemu = CoreEmu() session = coreemu.create_session() print(session) # must be in configuration state for nodes to start, when using "node_add" below session.set_state(EventTypes.CONFIGURATION_STATE) # create switch options = NodeOptions(x=200, y=200) switch = session.add_node(SwitchNode, options=options) # create nodes options = NodeOptions(x=100, y=100) n1 = session.add_node(CoreNode, options=options) options = NodeOptions(x=300, y=100) n2 = session.add_node(CoreNode, options=options) # link nodes to switch iface1 = ip_prefixes.create_iface(n1) session.add_link(n1.id, switch.id, iface1) iface1 = ip_prefixes.create_iface(n2) session.add_link(n2.id, switch.id, iface1) # start session
"""
# ip nerator for example
ip_prefixes = IpPrefixes(ip4_prefix="10.0.0.0/24")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
ospf_service = session.service_manager.get_service("OSPFv2")
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan
options = NodeOptions(x=200, y=200)
wlan = session.add_node(WlanNode, options=options)
# create nodes
options = NodeOptions(model="router", x=100, y=100)
n1 = session.add_node(CoreNode, options=options)
n1.services.append(ospf_service)
options = NodeOptions(model="router", x=300, y=100)
n2 = session.add_node(CoreNode, options=options)
n1.services.append(ospf_service)
# configuring wlan
session.mobility.set_model_config(
wlan.id,
BasicRangeModel.name,
from core.emulator.coreemu import CoreEmu
from core.emulator.data import IpPrefixes, NodeOptions
from core.emulator.enumerations import EventTypes
from core.nodes.base import CoreNode
from core.nodes.lxd import LxcNode
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG)
coreemu = CoreEmu()
session = coreemu.create_session()
session.set_state(EventTypes.CONFIGURATION_STATE)
try:
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
options = NodeOptions(image="ubuntu")
# create node one
node1 = session.add_node(LxcNode, options=options)
interface1_data = prefixes.create_iface(node1)
# create node two
node2 = session.add_node(CoreNode)
interface2_data = prefixes.create_iface(node2)
# add link
session.add_link(node1.id, node2.id, interface1_data, interface2_data)
# instantiate
session.instantiate()
finally:
def test_xml_emane(
self, session: Session, tmpdir: TemporaryFile, ip_prefixes: IpPrefixes
):
"""
Test xml client methods for emane.
:param session: session for test
:param tmpdir: tmpdir to create data in
:param ip_prefixes: generates ip addresses for nodes
"""
# create emane node for networking the core nodes
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions()
options.set_position(80, 50)
emane_network = session.add_node(EmaneNet, options=options)
config_key = "txpower"
config_value = "10"
session.emane.set_model(
emane_network, EmaneIeee80211abgModel, {config_key: config_value}
)
# create nodes
options = NodeOptions(model="mdr")
options.set_position(150, 150)
node1 = session.add_node(CoreNode, options=options)
options.set_position(300, 150)
node2 = session.add_node(CoreNode, options=options)
for i, node in enumerate([node1, node2]):
node.setposition(x=150 * (i + 1), y=150)
iface_data = ip_prefixes.create_iface(node)
session.add_link(node.id, emane_network.id, iface1_data=iface_data)
# instantiate session
session.instantiate()
# get ids for nodes
emane_id = emane_network.id
node1_id = node1.id
node2_id = node2.id
# save xml
xml_file = tmpdir.join("session.xml")
file_path = xml_file.strpath
session.save_xml(file_path)
# verify xml file was created and can be parsed
assert xml_file.isfile()
assert ElementTree.parse(file_path)
# stop current session, clearing data
session.shutdown()
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(node1_id, CoreNode)
with pytest.raises(CoreError):
assert not session.get_node(node2_id, CoreNode)
# load saved xml
session.open_xml(file_path, start=True)
# retrieve configuration we set originally
value = str(
session.emane.get_config(config_key, emane_id, EmaneIeee80211abgModel.name)
)
# verify nodes and configuration were restored
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
def test_xml_mobility(self, session: Session, tmpdir: TemporaryFile,
ip_prefixes: IpPrefixes):
"""
Test xml client methods for mobility.
:param session: session for test
:param tmpdir: tmpdir to create data in
:param ip_prefixes: generates ip addresses for nodes
"""
# create wlan
wlan_node = session.add_node(WlanNode)
session.mobility.set_model(wlan_node, BasicRangeModel, {"test": "1"})
# create nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node1 = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode, options=options)
# link nodes
for node in [node1, node2]:
iface_data = ip_prefixes.create_iface(node)
session.add_link(node.id, wlan_node.id, iface1_data=iface_data)
# instantiate session
session.instantiate()
# get ids for nodes
wlan_id = wlan_node.id
node1_id = node1.id
node2_id = node2.id
# save xml
xml_file = tmpdir.join("session.xml")
file_path = Path(xml_file.strpath)
session.save_xml(file_path)
# verify xml file was created and can be parsed
assert xml_file.isfile()
assert ElementTree.parse(file_path)
# stop current session, clearing data
session.shutdown()
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(node1_id, CoreNode)
with pytest.raises(CoreError):
assert not session.get_node(node2_id, CoreNode)
# load saved xml
session.open_xml(file_path, start=True)
# retrieve configuration we set originally
value = str(
session.mobility.get_config("test", wlan_id, BasicRangeModel.name))
# verify nodes and configuration were restored
assert session.get_node(node1_id, CoreNode)
assert session.get_node(node2_id, CoreNode)
assert session.get_node(wlan_id, WlanNode)
assert value == "1"
def test_xml_ptp_services(self, session: Session, tmpdir: TemporaryFile,
ip_prefixes: IpPrefixes):
"""
Test xml client methods for a ptp neetwork.
:param session: session for test
:param tmpdir: tmpdir to create data in
:param ip_prefixes: generates ip addresses for nodes
"""
# create ptp
ptp_node = session.add_node(PtpNet)
# create nodes
options = NodeOptions(model="host")
node1 = session.add_node(CoreNode, options=options)
node2 = session.add_node(CoreNode)
# link nodes to ptp net
for node in [node1, node2]:
iface_data = ip_prefixes.create_iface(node)
session.add_link(node.id, ptp_node.id, iface1_data=iface_data)
# set custom values for node service
session.services.set_service(node1.id, SshService.name)
service_file = SshService.configs[0]
file_data = "# test"
session.services.set_service_file(node1.id, SshService.name,
service_file, file_data)
# instantiate session
session.instantiate()
# get ids for nodes
node1_id = node1.id
node2_id = node2.id
# save xml
xml_file = tmpdir.join("session.xml")
file_path = Path(xml_file.strpath)
session.save_xml(file_path)
# verify xml file was created and can be parsed
assert xml_file.isfile()
assert ElementTree.parse(file_path)
# stop current session, clearing data
session.shutdown()
# verify nodes have been removed from session
with pytest.raises(CoreError):
assert not session.get_node(node1_id, CoreNode)
with pytest.raises(CoreError):
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(node1.id, SshService.name)
# verify nodes have been recreated
assert session.get_node(node1_id, CoreNode)
assert session.get_node(node2_id, CoreNode)
assert service.config_data.get(service_file) == file_data
