def test_delete_link(self, grpc_server: CoreGrpcServer, ip_prefixes: IpPrefixes): # 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) 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}: link_node = node break assert len(link_node.all_link_data(0)) == 1 # then with client.context_connect(): response = client.delete_link(session.id, node_one.id, node_two.id, interface_one.id, interface_two.id) # then assert response.result is True assert len(link_node.all_link_data(0)) == 0
def example(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() 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 session.set_location(47.57917, -122.13232, 2.00000, 1.0) options = NodeOptions() options.set_position(80, 50) emane_network = session.add_node(_type=NodeTypes.EMANE, options=options) session.emane.set_model(emane_network, EmaneIeee80211abgModel) # create nodes options = NodeOptions(model="mdr") for i in range(args.nodes): node = session.add_node(options=options) node.setposition(x=150 * (i + 1), y=150) interface = prefixes.create_interface(node) session.add_link(node.id, emane_network.id, interface_one=interface) # instantiate session session.instantiate() # shutdown session input("press enter to exit...") coreemu.shutdown()
def example(options): # 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_network = session.create_emane_network( model=EmaneIeee80211abgModel, geo_reference=(47.57917, -122.13232, 2.00000) ) emane_network.setposition(x=80, y=50) # create nodes for i in xrange(options.nodes): node = session.create_wireless_node() node.setposition(x=150 * (i + 1), y=150) interface = prefixes.create_interface(node) session.add_link(node.objid, emane_network.objid, interface_one=interface) # instantiate session session.instantiate() # start a shell on the first node node = session.get_object(2) node.client.term("bash") # shutdown session raw_input("press enter to exit...") coreemu.shutdown()
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) interface = ip_prefixes.create_interface(node) session.add_link(node.id, switch.id, interface) options = core_pb2.LinkOptions(bandwidth=30000) link = switch.all_link_data()[0] assert options.bandwidth != link.bandwidth # then with client.context_connect(): response = client.edit_link(session.id, node.id, switch.id, options, interface_one_id=interface.id) # then assert response.result is True link = switch.all_link_data()[0] assert options.bandwidth == link.bandwidth
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 node_one = session.add_node(CoreNode) node_two = session.add_node(CoreNode) # link nodes to net node for node in [node_one, node_two]: interface = ip_prefixes.create_interface(node) session.add_link(node.id, net_node.id, interface_one=interface) # instantiate session session.instantiate() # ping n2 from n1 and assert success status = ping(node_one, node_two, ip_prefixes) assert not status
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 node_one = session.add_node(CoreNode) node_two = session.add_node(CoreNode) # link nodes to ptp net for node in [node_one, node_two]: interface = ip_prefixes.create_interface(node) session.add_link(node.id, ptp_node.id, interface_one=interface) # get node client for testing client = node_one.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_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) node_one = session.add_node(CoreNode, options=options) node_two = session.add_node(CoreNode, options=options) # link nodes for node in [node_one, node_two]: interface = ip_prefixes.create_interface(node) session.add_link(node.id, wlan_node.id, interface_one=interface) # instantiate session session.instantiate() # ping n2 from n1 and assert success status = ping(node_one, node_two, ip_prefixes) assert not status
def example(options): # 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_network = session.create_emane_network(model=EmaneIeee80211abgModel, geo_reference=(47.57917, -122.13232, 2.00000)) emane_network.setposition(x=80, y=50) # create nodes for i in range(options.nodes): node = session.create_wireless_node() node.setposition(x=150 * (i + 1), y=150) interface = prefixes.create_interface(node) session.add_link(node.id, emane_network.id, interface_one=interface) # instantiate session session.instantiate() # start a shell on the first node node = session.get_node(2) node.client.term("bash") # shutdown session input("press enter to exit...") coreemu.shutdown()
def example(nodes): # ip generator for example prefixes = IpPrefixes("192.168.10.0/24") node_list = [] # create emulator instance for creating sessions and utility methods coreemu = globals().get("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 nodes node_options = NodeOptions() x = 0 for i in range(nodes): node_options.set_position(x, 100) x = x+70 session.add_node(node_options=node_options) node_list.append(node) # create switch network node wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN) session.mobility.set_model(wlan, BasicRangeModel) for node in node_list: interface = prefixes.create_interface(node) session.add_link(node.id, wlan.id, interface_one=interface) # instantiate session session.instantiate()
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() node_one = session.add_node(options=options) options.server = server_name node_two = session.add_node(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) # instantiate session session.instantiate() # pause script for verification input("press enter for shutdown") # shutdown session coreemu.shutdown()
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) interface = ip_prefixes.create_interface(node) session.add_link(node.id, wlan.id, interface) link_data = wlan.all_link_data()[0] queue = Queue() def handle_event(event_data): assert event_data.session_id == session.id assert event_data.HasField("link_event") queue.put(event_data) # 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 example(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() 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(_type=NodeTypes.SWITCH) # create nodes for _ in range(args.nodes): node = session.add_node() interface = prefixes.create_interface(node) session.add_link(node.id, switch.id, interface_one=interface) # instantiate session session.instantiate() # get nodes to run example first_node = session.get_node(2) last_node = session.get_node(args.nodes + 1) first_node_address = prefixes.ip4_address(first_node) logging.info("node %s pinging %s", last_node.name, first_node_address) output = last_node.cmd(f"ping -c {args.count} {first_node_address}") logging.info(output) # shutdown session coreemu.shutdown()
def test_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) # when session.add_link(node_one.id, node_two.id, interface_two=interface_two) # then assert node_one.all_link_data() assert node_two.netif(interface_two.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 node_one = session.add_node(CoreNode) node_two = session.add_node(CoreNode) # link nodes to ptp net for node in [node_one, node_two]: interface = ip_prefixes.create_interface(node) session.add_link(node.id, ptp_node.id, interface_one=interface) # instantiate session session.instantiate() # get ids for nodes n1_id = node_one.id n2_id = node_two.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(n1_id, CoreNode) with pytest.raises(CoreError): assert not session.get_node(n2_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)
def test_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) # when session.add_link(node_one.id, node_two.id, interface_one, interface_two) # then assert node_one.netif(interface_one.id) assert node_two.netif(interface_two.id)
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) interface = ip_prefixes.create_interface(node) session.add_link(node.id, switch.id, interface) # then with pytest.raises(grpc.RpcError): with client.context_connect(): client.get_node_links(session.id, 3)
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) node_one = session.add_node(CoreNode, options=options) node_two = session.add_node(CoreNode, options=options) # link nodes for node in [node_one, node_two]: interface = ip_prefixes.create_interface(node) session.add_link(node.id, wlan_node.id, interface_one=interface) # 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_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) interface = ip_prefixes.create_interface(node) session.add_link(node.id, switch.id, interface) # then with client.context_connect(): response = client.get_node_links(session.id, switch.id) # then assert len(response.links) == 1
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) # 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) # instantiate session session.instantiate() return node_one, node_two
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(_type=NodeTypes.EMANE, 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(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) # 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) last_node = session.get_node(NODES) address = prefixes.ip4_address(first_node) 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 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) node_one = session.add_node(options=options) emane_net = session.add_node(_type=NodeTypes.EMANE) session.emane.set_model(emane_net, EmaneIeee80211abgModel) options.server = server_name node_two = session.add_node(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) # instantiate session session.instantiate() # pause script for verification input("press enter for shutdown") # shutdown session coreemu.shutdown()
def test_netif(self, session: Session, ip_prefixes: IpPrefixes): """ Test netif methods. :param session: session for test :param ip_prefixes: generates ip addresses for nodes """ # create ptp ptp_node = session.add_node(PtpNet) # create nodes node_one = session.add_node(CoreNode) node_two = session.add_node(CoreNode) # link nodes to ptp net for node in [node_one, node_two]: interface = ip_prefixes.create_interface(node) session.add_link(node.id, ptp_node.id, interface_one=interface) # instantiate session session.instantiate() # check link data gets generated 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) # check we can retrieve netif index assert node_one.ifname(0) assert node_two.ifname(0) # check interface parameters interface = node_one.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)
def example(options): # 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(_type=NodeTypes.WIRELESS_LAN) session.mobility.set_model(wlan, BasicRangeModel) # create nodes wireless_nodes = [] for _ in xrange(options.nodes): node = session.add_node() interface = prefixes.create_interface(node) session.add_link(node.objid, wlan.objid, interface_one=interface) wireless_nodes.append(node) # link all created nodes with the wireless network session.wireless_link_all(wlan, wireless_nodes) # instantiate session session.instantiate() # get nodes for example run first_node = session.get_object(2) last_node = session.get_object(options.nodes + 1) print "starting iperf server on node: %s" % first_node.name first_node.cmd(["iperf", "-s", "-D"]) address = prefixes.ip4_address(first_node) print "node %s connecting to %s" % (last_node.name, address) last_node.client.icmd(["iperf", "-t", str(options.time), "-c", address]) first_node.cmd(["killall", "-9", "iperf"]) # shutdown session coreemu.shutdown()
def test_models(self, session: Session, model: 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) node_one = session.add_node(CoreNode, options=options) options.set_position(300, 150) node_two = session.add_node(CoreNode, options=options) for i, node in enumerate([node_one, node_two]): 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) # instantiate session session.instantiate() # ping n2 from n1 and assert success status = ping(node_one, node_two, ip_prefixes, count=5) assert not status
def example(options): # 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(_type=NodeTypes.WIRELESS_LAN) session.set_wireless_model(wlan, BasicRangeModel) # create nodes wireless_nodes = [] for _ in xrange(options.nodes): node = session.add_node() interface = prefixes.create_interface(node) session.add_link(node.objid, wlan.objid, interface_one=interface) wireless_nodes.append(node) # link all created nodes with the wireless network session.wireless_link_all(wlan, wireless_nodes) # instantiate session session.instantiate() # get nodes for example run first_node = session.get_object(2) last_node = session.get_object(options.nodes + 1) print "starting iperf server on node: %s" % first_node.name first_node.cmd(["iperf", "-s", "-D"]) address = prefixes.ip4_address(first_node) print "node %s connecting to %s" % (last_node.name, address) last_node.client.icmd(["iperf", "-t", str(options.time), "-c", address]) first_node.cmd(["killall", "-9", "iperf"]) # shutdown session coreemu.shutdown()
def example(args): # 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(_type=NodeTypes.WIRELESS_LAN) 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(args.nodes): node = session.add_node(options=options) interface = prefixes.create_interface(node) session.add_link(node.id, wlan.id, interface_one=interface) # instantiate session session.instantiate() # get nodes for example run first_node = session.get_node(2) last_node = session.get_node(args.nodes + 1) logging.info("starting iperf server on node: %s", first_node.name) first_node.cmd("iperf -s -D") address = prefixes.ip4_address(first_node) logging.info("node %s connecting to %s", last_node.name, address) output = last_node.cmd(f"iperf -t {args.time} -c {address}") logging.info(output) first_node.cmd("killall -9 iperf") # shutdown session coreemu.shutdown()
def example(nodes): # ip generator for example prefixes = IpPrefixes("10.83.0.0/16") # create emulator instance for creating sessions and utility methods 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(_type=NodeTypes.SWITCH) # create nodes for _ in range(nodes): node = session.add_node() interface = prefixes.create_interface(node) session.add_link(node.id, switch.id, interface_one=interface) # instantiate session session.instantiate()
def example(options): # 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(_type=NodeTypes.WIRELESS_LAN) session.mobility.set_model(wlan, BasicRangeModel) # create nodes, must set a position for wlan basic range model node_options = NodeOptions() node_options.set_position(0, 0) for _ in range(options.nodes): node = session.add_node(node_options=node_options) interface = prefixes.create_interface(node) session.add_link(node.id, wlan.id, interface_one=interface) # instantiate session session.instantiate() # get nodes for example run first_node = session.get_node(2) last_node = session.get_node(options.nodes + 1) print("starting iperf server on node: %s" % first_node.name) first_node.cmd(["iperf", "-s", "-D"]) address = prefixes.ip4_address(first_node) print("node %s connecting to %s" % (last_node.name, address)) last_node.client.icmd(["iperf", "-t", str(options.time), "-c", address]) first_node.cmd(["killall", "-9", "iperf"]) # shutdown session coreemu.shutdown()
def example(nodes): # ip generator for example prefixes = IpPrefixes("10.83.0.0/16") # create emulator instance for creating sessions and utility methods 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(_type=NodeTypes.SWITCH) # create nodes for _ in xrange(nodes): node = session.add_node() interface = prefixes.create_interface(node) session.add_link(node.objid, switch.objid, interface_one=interface) # instantiate session session.instantiate()
def test_link_update(self, session: Session, ip_prefixes: IpPrefixes): # given delay = 50 bandwidth = 5000000 per = 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") != per assert interface_one.getparam("duplicate") != dup assert interface_one.getparam("jitter") != jitter # when link_options = LinkOptions() link_options.delay = delay link_options.bandwidth = bandwidth link_options.per = per link_options.dup = dup link_options.jitter = jitter session.update_link( node_one.id, node_two.id, interface_one_id=interface_one_data.id, options=link_options, ) # then assert interface_one.getparam("delay") == delay assert interface_one.getparam("bw") == bandwidth assert interface_one.getparam("loss") == per assert interface_one.getparam("duplicate") == dup assert interface_one.getparam("jitter") == jitter
def example(nodes): # ip generator for example prefixes = IpPrefixes("192.168.10.0/24") node_list = [] # create emulator instance for creating sessions and utility methods core_emu = globals().get("coreemu", CoreEmu()) session = core_emu.create_session() # must be in configuration state for nodes to start, when using "node_add" below session.set_state(EventTypes.CONFIGURATION_STATE) # create nodes node_options = NodeOptions() x = 0 for i in range(nodes): y = 200 x = x + 100 if (i - 1) % 2 == 0: #node id starts at 1 y = 400 node_options.set_position(x, y) node = session.add_node(node_options=node_options) node_list.append(node) # create switch network node wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN) session.mobility.set_model(wlan, BasicRangeModel) for node in node_list: interface = prefixes.create_interface(node) session.add_link(node.id, wlan.id, interface_one=interface) # instantiate session session.instantiate() for node_num in range(2, 2 + nodes - 1): n = session.get_node(node_num) print("starting swarmdag on node: %s" % n.name) n.cmd([swarmdag_path, ">", "swarmdag.txt"])
def example(options): # 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 switch network node switch = session.add_node(_type=NodeTypes.SWITCH) # create nodes for _ in range(options.nodes): node = session.add_node() interface = prefixes.create_interface(node) session.add_link(node.id, switch.id, interface_one=interface) # instantiate session session.instantiate() # get nodes to run example first_node = session.get_node(2) last_node = session.get_node(options.nodes + 1) print("starting iperf server on node: %s" % first_node.name) first_node.cmd(["iperf", "-s", "-D"]) first_node_address = prefixes.ip4_address(first_node) print("node %s connecting to %s" % (last_node.name, first_node_address)) last_node.client.icmd( ["iperf", "-t", str(options.time), "-c", first_node_address]) first_node.cmd(["killall", "-9", "iperf"]) # shutdown session coreemu.shutdown()
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_interface(node) session.add_link(node.id, wlan.id, interface_one=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) 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 example(options): # 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 switch network node switch = session.add_node(_type=NodeTypes.SWITCH) # create nodes for _ in xrange(options.nodes): node = session.add_node() interface = prefixes.create_interface(node) session.add_link(node.objid, switch.objid, interface_one=interface) # instantiate session session.instantiate() # get nodes to run example first_node = session.get_object(2) last_node = session.get_object(options.nodes + 1) print "starting iperf server on node: %s" % first_node.name first_node.cmd(["iperf", "-s", "-D"]) first_node_address = prefixes.ip4_address(first_node) print "node %s connecting to %s" % (last_node.name, first_node_address) last_node.client.icmd(["iperf", "-t", str(options.time), "-c", first_node_address]) first_node.cmd(["killall", "-9", "iperf"]) # shutdown session coreemu.shutdown()