def __init__(self, session, objid="ctrlnet", name=None, prefix=None, hostid=None, start=True, assign_address=True, updown_script=None, serverintf=None): """ Creates a CtrlNet instance. :param core.session.Session session: core session instance :param int objid: node id :param str name: node namee :param prefix: control network ipv4 prefix :param hostid: host id :param bool start: start flag :param str assign_address: assigned address :param str updown_script: updown script :param serverintf: server interface :return: """ self.prefix = ipaddress.Ipv4Prefix(prefix) self.hostid = hostid self.assign_address = assign_address self.updown_script = updown_script self.serverintf = serverintf LxBrNet.__init__(self, session, objid=objid, name=name, start=start)
def ltesession(opt): """ Run a test LTE session. """ nodeutils.set_node_map(nodemaps.NODES) session = Ns3Session(1, persistent=True, duration=opt.duration) lte = session.add_object(cls=Ns3LteNet, name="wlan1") lte.setsubchannels(range(25), range(50, 100)) if opt.verbose: ascii_helper = ns.network.AsciiTraceHelper() stream = ascii_helper.CreateFileStream('/tmp/ns3lte.tr') lte.lte.EnableAsciiAll(stream) prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") mobb = None nodes = [] for i in xrange(1, opt.numnodes + 1): node = session.addnode(name="n%d" % i) mob = ns.mobility.ConstantPositionMobilityModel() mob.SetPosition(ns.core.Vector3D(10.0 * i, 0.0, 0.0)) if i == 1: # first node is nodeb lte.setnodeb(node) mobb = mob node.newnetif(lte, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) nodes.append(node) if i == 1: _tmp, ns3dev = lte.findns3dev(node) lte.lte.AddMobility(ns3dev.GetPhy(), mob) if i > 1: lte.linknodeb(node, nodes[0], mob, mobb) session.thread = session.run(vis=opt.visualize) return session
def createbridgedsession(self, numnodes, verbose=False): """ Build a topology consisting of the given number of LxcNodes connected to a WLAN. """ # IP subnet prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") self.session = Session(1) # emulated network self.net = self.session.add_object(cls=nodes.WlanNode, name="wlan1") prev = None for i in xrange(1, numnodes + 1): addr = "%s/%s" % (prefix.addr(i), 32) tmp = self.session.add_object(cls=nodes.CoreNode, objid=i, name="n%d" % i) tmp.newnetif(self.net, [addr]) self.nodes.append(tmp) self.session.services.addservicestonode(tmp, "router", "IPForward") self.session.services.bootnodeservices(tmp) self.staticroutes(i, prefix, numnodes) # link each node in a chain, with the previous node if prev: self.net.link(prev.netif(0), tmp.netif(0)) prev = tmp
def topology(self, numnodes, linkprob, verbose=False): """ Build a topology consisting of the given number of ManetNodes connected to a WLAN and probabilty of links and set the session, WLAN, and node list objects. """ # IP subnet prefix = ipaddress.Ipv4Prefix("10.14.0.0/16") self.session = Session(1) # emulated network self.net = self.session.add_object(cls=nodes.WlanNode) for i in xrange(1, numnodes + 1): addr = "%s/%s" % (prefix.addr(i), 32) tmp = self.session.add_object(cls=ManetNode, ipaddr=addr, objid="%d" % i, name="n%d" % i) tmp.newnetif(self.net, [addr]) self.nodes.append(tmp) # connect nodes with probability linkprob for i in xrange(numnodes): for j in xrange(i + 1, numnodes): r = random.random() if r < linkprob: if self.verbose: self.info("linking (%d,%d)" % (i, j)) self.net.link(self.nodes[i].netif(0), self.nodes[j].netif(0)) # force one link to avoid partitions (should check if this is needed) j = i while j == i: j = random.randint(0, numnodes - 1) if self.verbose: self.info("linking (%d,%d)" % (i, j)) self.net.link(self.nodes[i].netif(0), self.nodes[j].netif(0)) self.nodes[i].boot() # run the boot.sh script on all nodes to start Quagga for i in xrange(numnodes): self.nodes[i].cmd(["./%s" % self.nodes[i].bootsh])
def wifisession(opt): """ Run a test wifi session. """ nodeutils.set_node_map(nodemaps.NODES) session = Ns3Session(1, persistent=True, duration=opt.duration) session.name = "ns3wifi" session.filename = session.name + ".py" session.node_count = str(opt.numnodes + 1) add_to_server(session) wifi = session.add_object(cls=Ns3WifiNet, name="wlan1") wifi.setposition(30, 30, 0) wifi.phy.Set("RxGain", ns.core.DoubleValue(18.0)) prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") nodes = [] for i in xrange(1, opt.numnodes + 1): node = session.addnode(name="n%d" % i) node.newnetif(wifi, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) nodes.append(node) session.setupconstantmobility() wifi.usecorepositions() # PHY tracing # wifi.phy.EnableAsciiAll("ns3wifi") session.thread = session.run(vis=False) return session
def wimaxsession(opt): """ Run a test wimax session. """ nodeutils.set_node_map(nodemaps.NODES) session = Ns3Session(1, persistent=True, duration=opt.duration) wimax = session.add_object(cls=Ns3WimaxNet, name="wlan1") # wimax.wimax.EnableLogComponents() prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") # create one classifier for ICMP (protocol 1) traffic # src port low/high, dst port low/high, protocol, priority # classifier = (0, 65000, 0, 65000, 1, 1) classifier = (0, 65000, 0, 65000, 17, 1) nodes = [] for i in xrange(1, opt.numnodes + 1): node = session.addnode(name="n%d" % i) if i == 1: wimax.setbasestation(node) node.newnetif(wimax, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) if i > 2: wimax.addflow(nodes[-1], node, classifier, classifier) nodes.append(node) session.setupconstantmobility() session.thread = session.run(vis=False) return session
def __init__(self, session, objid="ctrlnet", name=None, prefix=None, hostid=None, start=True, assign_address=True, updown_script=None, serverintf=None): self.prefix = ipaddress.Ipv4Prefix(prefix) self.hostid = hostid self.assign_address = assign_address self.updown_script = updown_script self.serverintf = serverintf OvsNet.__init__(self, session, objid=objid, name=name, start=start)
def __init__(self, port=CORE_API_PORT): self.host = "localhost" self.port = port address = (self.host, self.port) self.server = CoreServer(address, CoreHandler, { "numthreads": 1, "daemonize": False, }) self.distributed_server = "core2" self.prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") self.session = None self.request_handler = None
def main(): usagestr = "usage: %prog [-h] [options] [args]" parser = optparse.OptionParser(usage=usagestr) parser.set_defaults(numnodes=5) parser.add_option("-n", "--numnodes", dest="numnodes", type=int, help="number of nodes") def usage(msg=None, err=0): sys.stdout.write("\n") if msg: sys.stdout.write(msg + "\n\n") parser.print_help() sys.exit(err) # parse command line options (options, args) = parser.parse_args() if options.numnodes < 1: usage("invalid number of nodes: %s" % options.numnodes) for a in args: sys.stderr.write("ignoring command line argument: '%s'\n" % a) start = datetime.datetime.now() # IP subnet prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") session = Session(1, persistent=True) if 'server' in globals(): server.addsession(session) # emulated Ethernet switch switch = session.add_object(cls=nodes.SwitchNode, name="switch") switch.setposition(x=80, y=50) print "creating %d nodes with addresses from %s" % (options.numnodes, prefix) for i in xrange(1, options.numnodes + 1): tmp = session.add_object(cls=nodes.CoreNode, name="n%d" % i, objid=i) tmp.newnetif(switch, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) tmp.cmd([constants.SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"]) tmp.setposition(x=150 * i, y=150) n.append(tmp) session.node_count = str(options.numnodes + 1) session.instantiate() print "elapsed time: %s" % (datetime.datetime.now() - start) # start a shell on node 1 n[1].term("bash") raw_input("press enter to exit") session.shutdown()
def generatequaggaconfig(cls, node): cfg = "router ospf\n" rtrid = cls.routerid(node) cfg += " router-id %s\n" % rtrid # network 10.0.0.0/24 area 0 for ifc in node.netifs(): if hasattr(ifc, 'control') and ifc.control is True: continue for a in ifc.addrlist: if a.find(".") < 0: continue net = ipaddress.Ipv4Prefix(a) cfg += " network %s area 0\n" % net cfg += "!\n" return cfg
def test(numnodes, testsec): # node list n = [] # IP subnet prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") session = Session(1) # emulated network net = session.add_object(cls=nodes.SwitchNode) for i in xrange(1, numnodes + 1): tmp = session.add_object(cls=nodes.LxcNode, name="n%d" % i) tmp.newnetif(net, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) n.append(tmp) n[0].cmd(["iperf", "-s", "-D"]) n[-1].icmd(["iperf", "-t", str(int(testsec)), "-c", str(prefix.addr(1))]) n[0].cmd(["killall", "-9", "iperf"]) raw_input("press enter to exit") session.shutdown()
def createemanesession(self, numnodes, verbose=False, cls=None, values=None): """ Build a topology consisting of the given number of LxcNodes connected to an EMANE WLAN. """ prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") self.session = Session(2) self.session.node_count = str(numnodes + 1) self.session.master = True self.session.location.setrefgeo(47.57917, -122.13232, 2.00000) self.session.location.refscale = 150.0 self.session.config["emane_models"] = "RfPipe, Ieee80211abg, Bypass" self.session.emane.loadmodels() self.net = self.session.add_object(cls=EmaneNode, objid=numnodes + 1, name="wlan1") self.net.verbose = verbose # self.session.emane.addobj(self.net) for i in xrange(1, numnodes + 1): addr = "%s/%s" % (prefix.addr(i), 32) tmp = self.session.add_object(cls=nodes.CoreNode, objid=i, name="n%d" % i) # tmp.setposition(i * 20, 50, None) tmp.setposition(50, 50, None) tmp.newnetif(self.net, [addr]) self.nodes.append(tmp) self.session.services.addservicestonode(tmp, "router", "IPForward") if values is None: values = cls.getdefaultvalues() self.session.emane.setconfig(self.net.objid, cls.name, values) self.session.instantiate() self.info("waiting %s sec (TAP bring-up)" % 2) time.sleep(2) for i in xrange(1, numnodes + 1): tmp = self.nodes[i - 1] self.session.services.bootnodeservices(tmp) self.staticroutes(i, prefix, numnodes)
def __init__(self): # setup nodes node_map = nodemaps.NODES nodeutils.set_node_map(node_map) # load emane services quagga.load_services() utility.load_services() address = ("localhost", CORE_API_PORT) self.server = CoreServer(address, CoreRequestHandler, { "numthreads": 1, "daemonize": False, }) self.distributed_server = "core2" self.prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") self.session = None self.request_handler = None
def wifisession(opt): """ Run a random walk wifi session. """ nodeutils.set_node_map(nodemaps.NODES) session = Ns3Session(1, persistent=True, duration=opt.duration) session.name = "ns3wifirandomwalk" session.filename = session.name + ".py" session.node_count = str(opt.numnodes + 1) add_to_server(session) wifi = session.add_object(cls=Ns3WifiNet, name="wlan1", rate="OfdmRate12Mbps") wifi.setposition(30, 30, 0) # for improved connectivity wifi.phy.Set("RxGain", ns.core.DoubleValue(18.0)) prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") services_str = "zebra|OSPFv3MDR|IPForward" nodes = [] for i in xrange(1, opt.numnodes + 1): node = session.addnode(name="n%d" % i) node.newnetif(wifi, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) nodes.append(node) session.services.addservicestonode(node, "router", services_str) session.services.bootnodeservices(node) session.setuprandomwalkmobility(bounds=(1000.0, 750.0, 0)) # PHY tracing # wifi.phy.EnableAsciiAll("ns3wifirandomwalk") # mobility tracing # session.setupmobilitytracing(wifi, "ns3wifirandomwalk.mob.tr", # nodes, verbose=True) session.startns3mobility(refresh_ms=150) # start simulation # session.instantiate() ? session.thread = session.run(vis=opt.viz) return session
def test(options): prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") session = Session(1, persistent=True) if options.enablesdt: # GUI default session.location.setrefgeo(47.57917, -122.13232, 50.0) session.location.refscale = 100.0 session.options.enablesdt = True session.options.sdturl = options.sdturl wlanid = options.numnodes + 1 net = session.add_object(cls=WlanNode, name="wlan%d" % wlanid, objid=wlanid) values = list(BasicRangeModel.getdefaultvalues()) # values[0] = 5000000 # 5000km range net.setmodel(BasicRangeModel, values) for i in xrange(1, options.numnodes + 1): node = session.add_object(cls=LxcNode, name="n%d" % i, objid=i) address = "%s/%s" % (prefix.addr(i), prefix.prefixlen) print "setting node address: %s - %s" % (node.objid, address) node.newnetif(net, [address]) # set increasing Z coordinates node.setposition(10, 10, 100) n.append(node) # example setting node n2 to a high altitude # n[1].setposition(10, 10, 2000000) # 2000km # session.sdt.updatenode(n[1].objid, 0, 10, 10, 2000000) # launches terminal for the first node # n[0].term("bash") n[0].icmd(["ping", "-c", "5", "127.0.0.1"]) # wait for rate seconds to allow ebtables commands to commit time.sleep(EbtablesQueue.rate) raw_input("press enter to exit") session.shutdown()
def main(): usagestr = "usage: %prog [-h] [options] [args]" parser = optparse.OptionParser(usage=usagestr) parser.set_defaults(numnodes=5, slave=None) parser.add_option("-n", "--numnodes", dest="numnodes", type=int, help="number of nodes") parser.add_option("-s", "--slave-server", dest="slave", type=str, help="slave server IP address") def usage(msg=None, err=0): sys.stdout.write("\n") if msg: sys.stdout.write(msg + "\n\n") parser.print_help() sys.exit(err) # parse command line options (options, args) = parser.parse_args() if options.numnodes < 1: usage("invalid number of nodes: %s" % options.numnodes) if not options.slave: usage("slave server IP address (-s) is a required argument") for a in args: sys.stderr.write("ignoring command line argument: '%s'\n" % a) start = datetime.datetime.now() prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") session = Session(1) if 'server' in globals(): server.addsession(session) # distributed setup - connect to slave server slaveport = options.slave.split(':') slave = slaveport[0] if len(slaveport) > 1: port = int(slaveport[1]) else: port = CORE_API_PORT print "connecting to slave at %s:%d" % (slave, port) session.broker.addserver(slave, slave, port) session.broker.setupserver(slave) session.set_state(EventTypes.CONFIGURATION_STATE) tlvdata = coreapi.CoreEventTlv.pack(EventTlvs.TYPE.value, EventTypes.CONFIGURATION_STATE.value) session.broker.handlerawmsg(coreapi.CoreEventMessage.pack(0, tlvdata)) switch = session.add_object(cls=nodes.SwitchNode, name="switch") switch.setposition(x=80, y=50) num_local = options.numnodes / 2 num_remote = options.numnodes / 2 + options.numnodes % 2 print "creating %d (%d local / %d remote) nodes with addresses from %s" % \ (options.numnodes, num_local, num_remote, prefix) for i in xrange(1, num_local + 1): node = session.add_object(cls=nodes.CoreNode, name="n%d" % i, objid=i) node.newnetif(switch, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) node.cmd( [constants.SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"]) node.setposition(x=150 * i, y=150) n.append(node) flags = MessageFlags.ADD.value session.broker.handlerawmsg(switch.tonodemsg(flags=flags)) # create remote nodes via API for i in xrange(num_local + 1, options.numnodes + 1): node = nodes.CoreNode(session=session, objid=i, name="n%d" % i, start=False) node.setposition(x=150 * i, y=150) node.server = slave n.append(node) node_data = node.data(flags) node_message = dataconversion.convert_node(node_data) session.broker.handlerawmsg(node_message) # create remote links via API for i in xrange(num_local + 1, options.numnodes + 1): tlvdata = coreapi.CoreLinkTlv.pack(LinkTlvs.N1_NUMBER.value, switch.objid) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.N2_NUMBER.value, i) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.TYPE.value, LinkTypes.WIRED.value) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_NUMBER.value, 0) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_IP4.value, prefix.addr(i)) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_IP4_MASK.value, prefix.prefixlen) msg = coreapi.CoreLinkMessage.pack(flags, tlvdata) session.broker.handlerawmsg(msg) session.instantiate() tlvdata = coreapi.CoreEventTlv.pack(EventTlvs.TYPE.value, EventTypes.INSTANTIATION_STATE.value) msg = coreapi.CoreEventMessage.pack(0, tlvdata) session.broker.handlerawmsg(msg) # start a shell on node 1 n[1].client.term("bash") print "elapsed time: %s" % (datetime.datetime.now() - start) print "To stop this session, use the 'core-cleanup' script on this server" print "and on the remote slave server."
def main(): usagestr = "usage: %prog [-h] [options] [args]" parser = optparse.OptionParser(usage=usagestr) parser.set_defaults(numnodes=5) parser.add_option("-n", "--numnodes", dest="numnodes", type=int, help="number of nodes") def usage(msg=None, err=0): sys.stdout.write("\n") if msg: sys.stdout.write(msg + "\n\n") parser.print_help() sys.exit(err) # parse command line options (options, args) = parser.parse_args() if options.numnodes < 1: usage("invalid number of nodes: %s" % options.numnodes) for a in args: sys.stderr.write("ignoring command line argument: '%s'\n" % a) start = datetime.datetime.now() # IP subnet prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") # session with some EMANE initialization cfg = {'verbose': 'false'} session = Session(1, config=cfg, persistent=True) session.master = True session.location.setrefgeo(47.57917, -122.13232, 2.00000) session.location.refscale = 150.0 session.config['emane_models'] = "RfPipe, Ieee80211abg, Bypass" session.emane.loadmodels() if 'server' in globals(): server.addsession(session) # EMANE WLAN print "creating EMANE WLAN wlan1" wlan = session.add_object(cls=EmaneNode, name="wlan1") wlan.setposition(x=80, y=50) names = EmaneIeee80211abgModel.getnames() values = list(EmaneIeee80211abgModel.getdefaultvalues()) # TODO: change any of the EMANE 802.11 parameter values here for i in range(0, len(names)): print "EMANE 80211 \"%s\" = \"%s\"" % (names[i], values[i]) try: values[names.index('pathlossmode')] = '2ray' except ValueError: values[names.index('propagationmodel')] = '2ray' session.emane.setconfig(wlan.objid, EmaneIeee80211abgModel.name, values) services_str = "zebra|OSPFv3MDR|IPForward" print "creating %d nodes with addresses from %s" % \ (options.numnodes, prefix) for i in xrange(1, options.numnodes + 1): tmp = session.add_object(cls=nodes.CoreNode, name="n%d" % i, objid=i) tmp.newnetif(wlan, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) tmp.cmd( [constants.SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"]) tmp.setposition(x=150 * i, y=150) session.services.addservicestonode(tmp, "", services_str) n.append(tmp) # this starts EMANE, etc. session.node_count = str(options.numnodes + 1) session.instantiate() # start a shell on node 1 n[1].term("bash") print "elapsed time: %s" % (datetime.datetime.now() - start)
def test_broker(self, cored): """ Test session broker creation. :param core.emulator.coreemu.EmuSession session: session for test :param cored: cored daemon server to test with """ # set core daemon to run in the background thread = threading.Thread(target=cored.server.serve_forever) thread.daemon = True thread.start() # ip prefix for nodes prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") daemon = "localhost" # add server session = cored.server.coreemu.create_session() session.broker.addserver(daemon, "127.0.0.1", CORE_API_PORT) # setup server session.broker.setupserver(daemon) # do not want the recvloop running as we will deal ourselves session.broker.dorecvloop = False # have broker handle a configuration state change session.set_state(EventTypes.CONFIGURATION_STATE) event_message = state_message(EventTypes.CONFIGURATION_STATE) session.broker.handlerawmsg(event_message) # create a switch node switch = session.add_node(_type=NodeTypes.SWITCH) switch.setposition(x=80, y=50) switch.server = daemon # retrieve switch data representation, create a switch message for broker to handle switch_data = switch.data(MessageFlags.ADD.value) switch_message = dataconversion.convert_node(switch_data) session.broker.handlerawmsg(switch_message) # create node one node_one = session.add_node() node_one.server = daemon # create node two node_two = session.add_node() node_two.server = daemon # create node messages for the broker to handle for node in [node_one, node_two]: node_data = node.data(MessageFlags.ADD.value) node_message = dataconversion.convert_node(node_data) session.broker.handlerawmsg(node_message) # create links to switch from nodes for broker to handle for index, node in enumerate([node_one, node_two], start=1): ip4_address = prefix.addr(index) link_message = switch_link_message(switch, node, ip4_address, prefix.prefixlen) session.broker.handlerawmsg(link_message) # change session to instantiation state event_message = state_message(EventTypes.INSTANTIATION_STATE) session.broker.handlerawmsg(event_message) # Get the ip or last node and ping it from the first output, status = run_cmd(node_one, "ip -4 -o addr show dev eth0") pingip = output.split()[3].split("/")[0] output, status = run_cmd(node_two, "ping -c 5 " + pingip) assert not status
def main(): usagestr = "usage: %prog [-h] [options] [args]" parser = optparse.OptionParser(usage=usagestr) parser.set_defaults(waittime=0.2, numnodes=0, bridges=0, retries=0, logfile=None, services=None) parser.add_option("-w", "--waittime", dest="waittime", type=float, help="number of seconds to wait between node creation" \ " (default = %s)" % parser.defaults["waittime"]) parser.add_option("-n", "--numnodes", dest="numnodes", type=int, help="number of nodes (default = unlimited)") parser.add_option("-b", "--bridges", dest="bridges", type=int, help="number of nodes per bridge; 0 = one bridge " \ "(def. = %s)" % parser.defaults["bridges"]) parser.add_option("-r", "--retry", dest="retries", type=int, help="number of retries on error (default = %s)" % \ parser.defaults["retries"]) parser.add_option("-l", "--log", dest="logfile", type=str, help="log memory usage to this file (default = %s)" % \ parser.defaults["logfile"]) parser.add_option("-s", "--services", dest="services", type=str, help="pipe-delimited list of services added to each " "node (default = %s)\n(Example: zebra|OSPFv2|OSPFv3|" "IPForward)" % parser.defaults["services"]) def usage(msg=None, err=0): sys.stdout.write("\n") if msg: sys.stdout.write(msg + "\n\n") parser.print_help() sys.exit(err) (options, args) = parser.parse_args() for a in args: sys.stderr.write("ignoring command line argument: %s\n" % a) start = datetime.datetime.now() prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") print "Testing how many network namespace nodes this machine can create." print " - %s" % linuxversion() mem = memfree() print " - %.02f GB total memory (%.02f GB swap)" % \ (mem["total"] / GBD, mem["stotal"] / GBD) print " - using IPv4 network prefix %s" % prefix print " - using wait time of %s" % options.waittime print " - using %d nodes per bridge" % options.bridges print " - will retry %d times on failure" % options.retries print " - adding these services to each node: %s" % options.services print " " lfp = None if options.logfile is not None: # initialize a csv log file header lfp = open(options.logfile, "a") lfp.write("# log from howmanynodes.py %s\n" % time.ctime()) lfp.write("# options = %s\n#\n" % options) lfp.write("# numnodes,%s\n" % ",".join(MEMKEYS)) lfp.flush() session = Session(1, persistent=True) switch = session.add_object(cls=nodes.SwitchNode) switchlist.append(switch) print "Added bridge %s (%d)." % (switch.brname, len(switchlist)) i = 0 retry_count = options.retries while True: i += 1 # optionally add a bridge (options.bridges nodes per bridge) try: if options.bridges > 0 and switch.numnetif() >= options.bridges: switch = session.add_object(cls=nodes.SwitchNode) switchlist.append(switch) print "\nAdded bridge %s (%d) for node %d." % \ (switch.brname, len(switchlist), i) except Exception, e: print "At %d bridges (%d nodes) caught exception:\n%s\n" % \ (len(switchlist), i - 1, e) break # create a node try: n = session.add_object(cls=nodes.LxcNode, name="n%d" % i) n.newnetif(switch, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) n.cmd([ constants.SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0" ]) if options.services is not None: session.services.addservicestonode(n, "", options.services) n.boot() nodelist.append(n) if i % 25 == 0: print "\n%s nodes created " % i, mem = memfree() free = mem["free"] + mem["buff"] + mem["cached"] swap = mem["stotal"] - mem["sfree"] print "(%.02f/%.02f GB free/swap)" % (free / GBD, swap / GBD), if lfp: lfp.write("%d," % i) lfp.write("%s\n" % ",".join(str(mem[x]) for x in MEMKEYS)) lfp.flush() else: sys.stdout.write(".") sys.stdout.flush() time.sleep(options.waittime) except Exception, e: print "At %d nodes caught exception:\n" % i, e if retry_count > 0: print "\nWill retry creating node %d." % i shutil.rmtree(n.nodedir, ignore_errors=True) retry_count -= 1 i -= 1 time.sleep(options.waittime) continue else: print "Stopping at %d nodes!" % i break
def ip_prefix(): return ipaddress.Ipv4Prefix("10.83.0.0/16")
def __init__(self, prefix=None, gw=None, metric=None): try: self.prefix = ipaddress.Ipv4Prefix(prefix) except Exception, e: raise ValueError, "Invalid prefix given to Route object: %s\n%s" % \ (prefix, e)
def main(): usagestr = "usage: %prog [-n] number of nodes [-d] daemon address" parser = optparse.OptionParser(usage=usagestr) parser.set_defaults(numnodes=5, daemon="127.0.0.1:" + str(CORE_API_PORT)) parser.add_option("-n", "--numnodes", dest="numnodes", type=int, help="number of nodes") parser.add_option("-d", "--daemon-server", dest="daemon", type=str, help="daemon server IP address") def usage(msg=None, err=0): sys.stdout.write("\n") if msg: sys.stdout.write(msg + "\n\n") parser.print_help() sys.exit(err) # parse command line options (options, args) = parser.parse_args() if options.numnodes < 1: usage("invalid number of nodes: %s" % options.numnodes) if not options.daemon: usage("daemon server IP address (-d) is a required argument") for a in args: sys.stderr.write("ignoring command line argument: %s\n" % a) start = datetime.datetime.now() prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") session = Session(1) if "server" in globals(): server.addsession(session) # distributed setup - connect to daemon server daemonport = options.daemon.split(":") daemonip = daemonport[0] # Localhost is already set in the session but we change it to be the remote daemon # This stops the remote daemon trying to build a tunnel back which would fail daemon = "localhost" if len(daemonport) > 1: port = int(daemonport[1]) else: port = CORE_API_PORT print "connecting to daemon at %s:%d" % (daemon, port) session.broker.addserver(daemon, daemonip, port) # Set the local session id to match the port. # Not necessary but seems neater. session.broker.setupserver(daemon) # We do not want the recvloop running as we will deal ourselves session.broker.dorecvloop = False # Change to configuration state on both machines session.set_state(EventTypes.CONFIGURATION_STATE) tlvdata = coreapi.CoreEventTlv.pack(EventTlvs.TYPE.value, EventTypes.CONFIGURATION_STATE.value) session.broker.handlerawmsg(coreapi.CoreEventMessage.pack(0, tlvdata)) flags = MessageFlags.ADD.value switch = nodes.SwitchNode(session=session, name="switch", start=False) switch.setposition(x=80, y=50) switch.server = daemon switch_data = switch.data(flags) switch_message = dataconversion.convert_node(switch_data) session.broker.handlerawmsg(switch_message) number_of_nodes = options.numnodes print "creating %d remote nodes with addresses from %s" % ( options.numnodes, prefix) # create remote nodes via API for i in xrange(1, number_of_nodes + 1): node = nodes.CoreNode(session=session, objid=i, name="n%d" % i, start=False) node.setposition(x=150 * i, y=150) node.server = daemon node_data = node.data(flags) node_message = dataconversion.convert_node(node_data) session.broker.handlerawmsg(node_message) n.append(node) # create remote links via API for i in xrange(1, number_of_nodes + 1): tlvdata = coreapi.CoreLinkTlv.pack(LinkTlvs.N1_NUMBER.value, switch.objid) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.N2_NUMBER.value, i) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.TYPE.value, LinkTypes.WIRED.value) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_NUMBER.value, 0) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_IP4.value, prefix.addr(i)) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_IP4_MASK.value, prefix.prefixlen) msg = coreapi.CoreLinkMessage.pack(flags, tlvdata) session.broker.handlerawmsg(msg) # We change the daemon to Instantiation state # We do not change the local session as it would try and build a tunnel and fail tlvdata = coreapi.CoreEventTlv.pack(EventTlvs.TYPE.value, EventTypes.INSTANTIATION_STATE.value) msg = coreapi.CoreEventMessage.pack(0, tlvdata) session.broker.handlerawmsg(msg) # Get the ip or last node and ping it from the first print "Pinging from the first to the last node" pingip = cmd(n[-1], "ip -4 -o addr show dev eth0").split()[3].split("/")[0] print cmd(n[1], "ping -c 5 " + pingip) print "elapsed time: %s" % (datetime.datetime.now() - start) print "To stop this session, use the core-cleanup script on the remote daemon server." raw_input("press enter to exit")
def main(): usagestr = "usage: %prog [-h] [options] [args]" parser = optparse.OptionParser(usage=usagestr) parser.set_defaults(numnodes=5) parser.add_option("-n", "--numnodes", dest="numnodes", type=int, help="number of nodes") def usage(msg=None, err=0): sys.stdout.write("\n") if msg: sys.stdout.write(msg + "\n\n") parser.print_help() sys.exit(err) # parse command line options (options, args) = parser.parse_args() if options.numnodes < 1: usage("invalid number of nodes: %s" % options.numnodes) if options.numnodes >= 255: usage("invalid number of nodes: %s" % options.numnodes) for a in args: sys.stderr.write("ignoring command line argument: '%s'\n" % a) start = datetime.datetime.now() session = Session(1, persistent=True) if 'server' in globals(): server.addsession(session) print "creating %d nodes" % options.numnodes left = None prefix = None for i in xrange(1, options.numnodes + 1): tmp = session.add_object(cls=nodes.CoreNode, name="n%d" % i, objid=i) if left: tmp.newnetif(left, ["%s/%s" % (prefix.addr(2), prefix.prefixlen)]) # limit: i < 255 prefix = ipaddress.Ipv4Prefix("10.83.%d.0/24" % i) right = session.add_object(cls=nodes.PtpNet) tmp.newnetif(right, ["%s/%s" % (prefix.addr(1), prefix.prefixlen)]) tmp.cmd([constants.SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"]) tmp.cmd([constants.SYSCTL_BIN, "net.ipv4.conf.all.forwarding=1"]) tmp.cmd([constants.SYSCTL_BIN, "net.ipv4.conf.default.rp_filter=0"]) tmp.setposition(x=100 * i, y=150) n.append(tmp) left = right prefixes = map(lambda (x): ipaddress.Ipv4Prefix("10.83.%d.0/24" % x), xrange(1, options.numnodes + 1)) # set up static routing in the chain for i in xrange(1, options.numnodes + 1): for j in xrange(1, options.numnodes + 1): if j < i - 1: gw = prefixes[i - 2].addr(1) elif j > i: if i > len(prefixes) - 1: continue gw = prefixes[i - 1].addr(2) else: continue net = prefixes[j - 1] n[i].cmd([constants.IP_BIN, "route", "add", str(net), "via", str(gw)]) print "elapsed time: %s" % (datetime.datetime.now() - start)