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 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_delete_link(self, grpc_server: CoreGrpcServer, ip_prefixes: IpPrefixes): # given client = CoreGrpcClient() session = grpc_server.coreemu.create_session() node1 = session.add_node(CoreNode) iface1 = ip_prefixes.create_iface(node1) node2 = session.add_node(CoreNode) iface2 = ip_prefixes.create_iface(node2) session.add_link(node1.id, node2.id, iface1, iface2) link_node = None for node_id in session.nodes: node = session.nodes[node_id] if node.id not in {node1.id, node2.id}: link_node = node break assert len(link_node.links()) == 1 # then with client.context_connect(): response = client.delete_link( session.id, node1.id, node2.id, iface1.id, iface2.id ) # then assert response.result is True assert len(link_node.links()) == 0
def test_vnode_client(self, request, session: Session, ip_prefixes: IpPrefixes): """ Test vnode client methods. :param request: pytest request :param session: session for test :param ip_prefixes: generates ip addresses for nodes """ # create ptp ptp_node = session.add_node(PtpNet) # create nodes node1 = session.add_node(CoreNode) 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) # get node client for testing client = node1.client # instantiate session session.instantiate() # check we are connected assert client.connected() # validate command if not request.config.getoption("mock"): assert client.check_cmd("echo hello") == "hello"
def test_wired_ping(self, session: Session, net_type: Type[NodeBase], ip_prefixes: IpPrefixes): """ Test ptp node network. :param session: session for test :param core.enumerations.NodeTypes net_type: type of net node to create :param ip_prefixes: generates ip addresses for nodes """ # create net node net_node = session.add_node(net_type) # create nodes node1 = session.add_node(CoreNode) node2 = session.add_node(CoreNode) # link nodes to net node for node in [node1, node2]: iface_data = ip_prefixes.create_iface(node) session.add_link(node.id, net_node.id, iface1_data=iface_data) # instantiate session session.instantiate() # ping node2 from node1 and assert success status = ping(node1, node2, ip_prefixes) assert not status
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 test_edit_link(self, grpc_server: CoreGrpcServer, ip_prefixes: IpPrefixes): # given client = CoreGrpcClient() session = grpc_server.coreemu.create_session() switch = session.add_node(SwitchNode) node = session.add_node(CoreNode) iface = ip_prefixes.create_iface(node) session.add_link(node.id, switch.id, iface) options = LinkOptions(bandwidth=30000) link = switch.links()[0] assert options.bandwidth != link.options.bandwidth link = Link(node.id, switch.id, iface1=Interface(id=iface.id), options=options) # then with client.context_connect(): result = client.edit_link(session.id, link) # then assert result is True link = switch.links()[0] assert options.bandwidth == link.options.bandwidth
def test_link_events(self, grpc_server: CoreGrpcServer, ip_prefixes: IpPrefixes): # given client = CoreGrpcClient() session = grpc_server.coreemu.create_session() wlan = session.add_node(WlanNode) node = session.add_node(CoreNode) iface = ip_prefixes.create_iface(node) session.add_link(node.id, wlan.id, iface) link_data = wlan.links()[0] queue = Queue() def handle_event(event: Event) -> None: assert event.session_id == session.id assert event.link_event is not None queue.put(event) # then with client.context_connect(): client.events(session.id, handle_event) time.sleep(0.1) session.broadcast_link(link_data) # then queue.get(timeout=5)
def ping(from_node: CoreNode, to_node: CoreNode, ip_prefixes: IpPrefixes): address = ip_prefixes.ip4_address(to_node.id) try: from_node.cmd(f"ping -c 1 {address}") status = 0 except CoreCommandError as e: status = e.returncode return status
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()
def __init__(self, ip4_prefix: str = None, ip6_prefix: str = None) -> None: """ Creates an InterfaceHelper object. :param ip4_prefix: ip4 prefix to use for generation :param ip6_prefix: ip6 prefix to use for generation :raises ValueError: when both ip4 and ip6 prefixes have not been provided """ self.prefixes: IpPrefixes = IpPrefixes(ip4_prefix, ip6_prefix)
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_add_net_to_node(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(SwitchNode) node2 = session.add_node(CoreNode) iface2_data = ip_prefixes.create_iface(node2) # when session.add_link(node1.id, node2.id, iface2_data=iface2_data) # then assert node1.links() assert node2.get_iface(iface2_data.id)
def test_xml_ptp( self, session: Session, tmpdir: TemporaryFile, ip_prefixes: IpPrefixes ): """ Test xml client methods for a ptp network. :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 node1 = session.add_node(CoreNode) 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) # 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 = 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) # verify nodes have been recreated assert session.get_node(node1_id, CoreNode) assert session.get_node(node2_id, CoreNode)
def test_update_ptp(self, session: Session, ip_prefixes: IpPrefixes): # given delay = 50 bandwidth = 5000000 loss = 25 dup = 25 jitter = 10 buffer = 100 node1 = session.add_node(CoreNode) node2 = session.add_node(CoreNode) iface1_data = ip_prefixes.create_iface(node1) iface2_data = ip_prefixes.create_iface(node2) session.add_link(node1.id, node2.id, iface1_data, iface2_data) iface1 = node1.get_iface(iface1_data.id) iface2 = node2.get_iface(iface2_data.id) assert iface1.getparam("delay") != delay assert iface1.getparam("bw") != bandwidth assert iface1.getparam("loss") != loss assert iface1.getparam("duplicate") != dup assert iface1.getparam("jitter") != jitter assert iface1.getparam("buffer") != buffer assert iface2.getparam("delay") != delay assert iface2.getparam("bw") != bandwidth assert iface2.getparam("loss") != loss assert iface2.getparam("duplicate") != dup assert iface2.getparam("jitter") != jitter assert iface2.getparam("buffer") != buffer # when options = LinkOptions( delay=delay, bandwidth=bandwidth, loss=loss, dup=dup, jitter=jitter, buffer=buffer, ) session.update_link(node1.id, node2.id, iface1_data.id, iface2_data.id, options) # then assert iface1.getparam("delay") == delay assert iface1.getparam("bw") == bandwidth assert iface1.getparam("loss") == loss assert iface1.getparam("duplicate") == dup assert iface1.getparam("jitter") == jitter assert iface1.getparam("buffer") == buffer assert iface2.getparam("delay") == delay assert iface2.getparam("bw") == bandwidth assert iface2.getparam("loss") == loss assert iface2.getparam("duplicate") == dup assert iface2.getparam("jitter") == jitter assert iface2.getparam("buffer") == buffer
def test_delete_node_to_net_error(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(CoreNode) node2 = session.add_node(SwitchNode) node3 = session.add_node(SwitchNode) iface1_data = ip_prefixes.create_iface(node1) iface1, _ = session.add_link(node1.id, node2.id, iface1_data) assert iface1 # when with pytest.raises(CoreError): session.delete_link(node1.id, node3.id)
def test_delete_node_to_net(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(CoreNode) node2 = session.add_node(SwitchNode) iface1_data = ip_prefixes.create_iface(node1) session.add_link(node1.id, node2.id, iface1_data) assert node1.get_iface(iface1_data.id) # when session.delete_link(node1.id, node2.id, iface1_id=iface1_data.id) # then assert iface1_data.id not in node1.ifaces
def main(): # ip generator for example prefixes = IpPrefixes("10.83.0.0/16") # create emulator instance for creating sessions and utility methods coreemu: CoreEmu = globals()["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 switch network node switch = session.add_node(SwitchNode) # create nodes for _ in range(NODES): node = session.add_node(CoreNode) interface = prefixes.create_iface(node) session.add_link(node.id, switch.id, iface1_data=interface) # instantiate session session.instantiate()
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 create_ptp_network(session: Session, ip_prefixes: IpPrefixes) -> Tuple[CoreNode, CoreNode]: # create nodes node1 = session.add_node(CoreNode) node2 = session.add_node(CoreNode) # link nodes to net node iface1_data = ip_prefixes.create_iface(node1) iface2_data = ip_prefixes.create_iface(node2) session.add_link(node1.id, node2.id, iface1_data, iface2_data) # instantiate session session.instantiate() return node1, node2
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_get_node_links(self, grpc_server: CoreGrpcServer, ip_prefixes: IpPrefixes): # given client = CoreGrpcClient() session = grpc_server.coreemu.create_session() switch = session.add_node(SwitchNode) node = session.add_node(CoreNode) iface_data = ip_prefixes.create_iface(node) session.add_link(node.id, switch.id, iface_data) # then with client.context_connect(): response = client.get_node_links(session.id, switch.id) # then assert len(response.links) == 1
def test_get_node_links_exception( self, grpc_server: CoreGrpcServer, ip_prefixes: IpPrefixes ): # given client = CoreGrpcClient() session = grpc_server.coreemu.create_session() switch = session.add_node(SwitchNode) node = session.add_node(CoreNode) iface_data = ip_prefixes.create_iface(node) session.add_link(node.id, switch.id, iface_data) # then with pytest.raises(grpc.RpcError): with client.context_connect(): client.get_node_links(session.id, 3)
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 test_update_node_to_net(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(CoreNode) node2 = session.add_node(SwitchNode) iface1_data = ip_prefixes.create_iface(node1) iface1, _ = session.add_link(node1.id, node2.id, iface1_data) assert iface1.local_options != LINK_OPTIONS # when session.update_link(node1.id, node2.id, iface1_id=iface1_data.id, options=LINK_OPTIONS) # then assert iface1.local_options == LINK_OPTIONS assert iface1.has_local_netem
def test_add_net_to_node(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(SwitchNode) node2 = session.add_node(CoreNode) iface2_data = ip_prefixes.create_iface(node2) # when _, iface = session.add_link(node1.id, node2.id, iface2_data=iface2_data, options=LINK_OPTIONS) # then assert node1.links() assert node2.get_iface(iface2_data.id) assert iface is not None assert iface.local_options == LINK_OPTIONS assert iface.has_local_netem
def test_iface(self, session: Session, ip_prefixes: IpPrefixes): """ Test interface methods. :param session: session for test :param ip_prefixes: generates ip addresses for nodes """ # create ptp ptp_node = session.add_node(PtpNet) # create nodes node1 = session.add_node(CoreNode) node2 = session.add_node(CoreNode) # link nodes to ptp net for node in [node1, node2]: iface = ip_prefixes.create_iface(node) session.add_link(node.id, ptp_node.id, iface1_data=iface) # instantiate session session.instantiate() # check link data gets generated assert ptp_node.links(MessageFlags.ADD) # check common nets exist between linked nodes assert node1.commonnets(node2) assert node2.commonnets(node1) # check we can retrieve interface id assert 0 in node1.ifaces assert 0 in node2.ifaces # check interface parameters iface = node1.get_iface(0) iface.setparam("test", 1) assert iface.getparam("test") == 1 assert iface.getparams() # delete interface and test that if no longer exists node1.delete_iface(0) assert 0 not in node1.ifaces
def test_add_node_to_node_uni(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(CoreNode) node2 = session.add_node(CoreNode) iface1_data = ip_prefixes.create_iface(node1) iface2_data = ip_prefixes.create_iface(node2) link_options1 = LinkOptions( delay=50, bandwidth=5000000, loss=25, dup=25, jitter=10, buffer=100, unidirectional=True, ) link_options2 = LinkOptions( delay=51, bandwidth=5000001, loss=26, dup=26, jitter=11, buffer=101, unidirectional=True, ) # when iface1, iface2 = session.add_link(node1.id, node2.id, iface1_data, iface2_data, link_options1) session.update_link(node2.id, node1.id, iface2_data.id, iface1_data.id, link_options2) # then assert node1.get_iface(iface1_data.id) assert node2.get_iface(iface2_data.id) assert iface1 is not None assert iface2 is not None assert iface1.local_options == link_options1 assert iface1.has_local_netem assert iface2.local_options == link_options2 assert iface2.has_local_netem
def test_two_emane_interfaces(self, session: Session): """ Test nodes running multiple emane interfaces. :param core.emulator.coreemu.EmuSession session: session for test """ # 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) options.emane = EmaneIeee80211abgModel.name emane_net1 = session.add_node(EmaneNet, options=options) options.emane = EmaneRfPipeModel.name emane_net2 = session.add_node(EmaneNet, options=options) # 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) # create interfaces ip_prefix1 = IpPrefixes("10.0.0.0/24") ip_prefix2 = IpPrefixes("10.0.1.0/24") for i, node in enumerate([node1, node2]): node.setposition(x=150 * (i + 1), y=150) iface_data = ip_prefix1.create_iface(node) session.add_link(node.id, emane_net1.id, iface1_data=iface_data) iface_data = ip_prefix2.create_iface(node) session.add_link(node.id, emane_net2.id, iface1_data=iface_data) # instantiate session session.instantiate() # ping node2 from node1 on both interfaces and check success status = ping(node1, node2, ip_prefix1, count=5) assert not status status = ping(node1, node2, ip_prefix2, count=5) assert not status
# required imports import netaddr, dataclasses, fabric, lxml, pyproj 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.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)