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