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 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_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 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 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 __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(ip4_prefix, ip6_prefix)
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 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 __init__(self, yml_nodes=None, yml_links=None, netmask="10.0.0.0/24"): """ Constructor for the Topology class - Creates a topology and starts the emulation, if no parameters were provided then an empty topolgy is created. :param yml_nodes: a list containing the nodes parsed from the topology configuration file, defaults to None :type yml_nodes: list(YML_node), optional :param yml_links: a list containing the links parsed from the topology configuration file, defaults to None :type yml_links: list(parser.YML_link), optional :param netmask: the netmask tells the emulator what sort of IP addresses the virtual nodes should be assigned, defaults to 10.0.0.0/24 :type netmask: str """ Topology.prefixes = IpPrefixes( ip4_prefix=netmask) #prefixes # CORE prefixes self.coreemu = globals().get("coreemu", CoreEmu()) # CORE container for sessions self.session = self.coreemu.create_session() # CORE session self.flag_physical_node = False self.netmask = netmask self.interfaceDict = {} self.inter_nodes = [] # Nodes from coreNode types self.physical_links = {} self.list_physical_links = [] self.session.set_state(EventTypes.CONFIGURATION_STATE) self.interNodeObjects = [] self.interLinkObjects = [] if (yml_nodes and yml_links): self._init_topology(yml_nodes, yml_links) else: self.session.instantiate()
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_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_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 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 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 __init__(self, env_config, silent=True): if not silent: load_logging_config() self.envParser = EnvParser(env_config) if self.envParser.ip4_prefix: self.prefix = IpPrefixes(ip4_prefix=self.envParser.ip4_prefix) else: self.prefix = IpPrefixes(ip6_prefix=self.envParser.ip6_prefix) self.nodes = {} # pc nodes self.networks = [] # switches nodes # create emulator instance for creating sessions and utility methods self.coreemu = CoreEmu() self.session = self.coreemu.create_session() # must be in configuration state for nodes to start, when using "node_add" below self.session.set_state(EventTypes.CONFIGURATION_STATE) # create nodes for node in self.envParser.nodes: self.nodes[int(node["id"])] = {"obj": self.session.add_node(_type=NodeTypes.DEFAULT), "nets": [], "ip": None, "curr_net": None} # create networks for net in self.envParser.networks: self.networks.append(self.session.add_node(_type=NodeTypes.SWITCH)) for node in net["nodes"]: interface = self.prefix.create_interface(self.nodes[node["id"]]["obj"], name=self.envParser.dev_prefix + str(net["id"])) self.nodes[node["id"]]["ip"] = self.prefix.ip4_address(self.nodes[node["id"]]["obj"]) self.session.add_link(self.nodes[node["id"]]["obj"].id, self.networks[-1].id, interface_one=interface) self.nodes[node["id"]]["nets"].append({ "net": net["id"] }) # certs shutil.rmtree('certs', True) self.__create_root_ca() for node in self.nodes: self.__create_node_cert(node) # instantiate session self.start()
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 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 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 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 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 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 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_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 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(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 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 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 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()
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 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