def start(self): self.ndn.start() AppManager(self.ndn, self.ndn.net.hosts, Nfd, logLevel='INFO') AppManager(self.ndn, self.ndn.net.hosts, Nlsr, logLevel='INFO') Popen(['cp', 'test.info', '/usr/local/etc/ndn/ndnsd_default.info'], stdout=PIPE, stderr=PIPE).communicate() # give some time for route computation and installation time.sleep(20)
def start(self, nlsr): self.ndn.start() sleep(5) AppManager(self.ndn, self.hosts, Nfd, logLevel='DEBUG') if nlsr: AppManager(self.ndn, self.ndn.net.hosts, Nlsr, security=self.ndn.args.security, logLevel='INFO') sleep(180) Popen(['cp', 'test.info', '/usr/local/etc/ndn/ndnsd_default.info'], stdout=PIPE, stderr=PIPE).communicate()
def start(self): self.ndn.start() time.sleep(5) self.setMTUsize(9000) nfds = AppManager(self.ndn, self.ndn.net.hosts, Nfd, logLevel='DEBUG') Popen(['cp', 'test.info', '/usr/local/etc/ndn/ndnsd_default.info'], stdout=PIPE, stderr=PIPE).communicate()
def start(ndn): ndn.start() time.sleep(5) setMTUsize(ndn, 9000) nfds = AppManager(ndn, ndn.net.hosts, Nfd, logLevel='DEBUG') time.sleep(0.1) # info('Starting NLSR on nodes\n') # nlsrs = AppManager(ndn, ndn.net.hosts, Nlsr) # time.sleep(50) # Popen(['cp', 'test.info', '/usr/local/etc/ndn/ndnsd_default.info'], stdout=PIPE, stderr=PIPE).communicate() # print ("did i came here") setTsharkLog(ndn.net)
def run(): Minindn.cleanUp() Minindn.verifyDependencies() topo = Topo() # Setup topo info("Setup\n") a = topo.addHost('a') b = topo.addHost('b') c = topo.addHost('c') topo.addLink(a, b, delay='10ms', bw=10) topo.addLink(b, c, delay='10ms', bw=10) ndn = Minindn(topo=topo) ndn.start() info("Configuring NFD\n") nfds = AppManager(ndn, ndn.net.hosts, Nfd, logLevel="DEBUG") #nlsr = AppManager(ndn, ndn.net.hosts, Nlsr, logLevel="DEBUG") # This is a fancy way of setting up the routes without violating DRY; # the important bit to note is the Nfdc command links = {"a": ["b"], "b": ["c"]} for first in links: for second in links[first]: host1 = ndn.net[first] host2 = ndn.net[second] interface = host2.connectionsTo(host1)[0][0] #info(interface) interface_ip = interface.IP() Nfdc.createFace(host1, interface_ip) Nfdc.registerRoute(host1, PREFIX, interface_ip, cost=0) info("Starting pings...\n") pingserver_log = open("/tmp/minindn/c/ndnpingserver.log", "w") pingserver = getPopen(ndn.net["c"], "ndnpingserver {}".format(PREFIX), stdout=pingserver_log, stderr=pingserver_log) ping1 = getPopen(ndn.net["a"], "ndnping {} -c 5".format(PREFIX), stdout=PIPE, stderr=PIPE) ping1.wait() info(ping1.stdout.read()) interface = ndn.net["b"].connectionsTo(ndn.net["a"])[0][0] info("Failing link\n") interface.config(delay="10ms", bw=10, loss=100) ping2 = getPopen(ndn.net["a"], "ndnping {} -c 5".format(PREFIX), stdout=PIPE, stderr=PIPE) ping2.wait() info(ping2.stdout.read()) interface.config(delay="10ms", bw=10, loss=0) MiniNDNCLI(ndn.net) info("Finished!\n") ndn.stop()
def runExperiment(): setLogLevel('info') info("Starting network") topo = Topo() sta1 = topo.addStation("sta1", range=150, speed=5) sta2 = topo.addStation("sta2", range=200) ap1 = topo.addAccessPoint("ap1", position="150,150,0", range=150) topo.addLink(sta1, ap1, delay="10ms") topo.addLink(sta2, ap1, delay="10ms") ndnwifi = MinindnWifi(topo=topo) a = ndnwifi.net["sta1"] b = ndnwifi.net["sta2"] # Test for model-based mobility if ndnwifi.args.modelMob: ndnwifi.startMobilityModel(model='GaussMarkov') #Test for replay based mobility if ndnwifi.args.mobility: info("Running with mobility...") p1, p2, p3, p4 = dict(), dict(), dict(), dict() p1 = {'position': '150.0,150.0,0.0'} p2 = {'position': '140.0,130.0,0.0'} p3 = {'position': '250.0,250.0,0.0'} p4 = {'position': '301.0,301.0,0.0'} ndnwifi.net.mobility(a, 'start', time=1, **p1) ndnwifi.net.mobility(a, 'stop', time=12, **p3) ndnwifi.net.mobility(b, 'start', time=2, **p2) ndnwifi.net.mobility(b, 'stop', time=22, **p4) ndnwifi.net.stopMobility(time=23) ndnwifi.startMobility(time=0, mob_rep=1, reverse=False) ndnwifi.start() info("Starting NFD") sleep(2) nfds = AppManager(ndnwifi, ndnwifi.net.stations, Nfd) info("Starting pingserver...") NDNPing.startPingServer(b, "/example") Nfdc.createFace(a, b.IP()) Nfdc.registerRoute(a, "/example", b.IP()) info("Starting ping...") NDNPing.ping(a, "/example", 10) # Start the CLI MiniNDNWifiCLI(ndnwifi.net) ndnwifi.net.stop() ndnwifi.cleanUp()
def setup_producers(network, producers): nodes_args = {} for i, node_name in enumerate(sorted(network.groups["producers"])): nodes_args[node_name] = { "domain_file": network.domain_file, "prefix": "/ndn/%s-site/%s" % (node_name, node_name), "n_producers": len(producers), "i_producer": i } producers_s = AppManager(network, producers, ProducerService, nodes_args=nodes_args) return producers_s
def runExperiment(): setLogLevel('info') info("Starting network") ndnwifi = MinindnWifi() a = ndnwifi.net["sta1"] b = ndnwifi.net["sta2"] # Test for model-based mobility if ndnwifi.args.modelMob: ndnwifi.startMobilityModel(model='GaussMarkov') #Test for replay based mobility if ndnwifi.args.mobility: info("Running with mobility...") p1, p2, p3, p4 = dict(), dict(), dict(), dict() p1 = {'position': '40.0,30.0,0.0'} p2 = {'position': '40.0,40.0,0.0'} p3 = {'position': '31.0,10.0,0.0'} p4 = {'position': '200.0,200.0,0.0'} ndnwifi.net.mobility(a, 'start', time=1, **p1) ndnwifi.net.mobility(b, 'start', time=2, **p2) ndnwifi.net.mobility(a, 'stop', time=12, **p3) ndnwifi.net.mobility(b, 'stop', time=22, **p4) ndnwifi.net.stopMobility(time=23) ndnwifi.startMobility(time=0, mob_rep=1, reverse=False) ndnwifi.start() info("Starting NFD") sleep(2) nfds = AppManager(ndnwifi, ndnwifi.net.stations, Nfd) info("Starting pingserver...") NDNPing.startPingServer(b, "/example") Nfdc.createFace(a, b.IP()) Nfdc.registerRoute(a, "/example", b.IP()) info("Starting ping...") NDNPing.ping(a, "/example", nPings=10) sleep(10) # Start the CLI MiniNDNWifiCLI(ndnwifi.net) ndnwifi.net.stop() ndnwifi.cleanUp()
MyMinindn.verifyDependencies() # # Disable security # MyMinindn.ndnSecurityDisabled = True parser = argparse.ArgumentParser() network = MyMinindn(parser=parser) try: network.start() # NFD info("Starting NFD on nodes\n") nfds = AppManager(network, network.net.hosts, CustomNFD, environments=network.environments, csPolicy=network.args.cs_strategy, csSize=CACHE_SIZE, csUnsolicitedPolicy="admit-all") # NLSR info('Starting NLSR on nodes\n') nlsrs = AppManager(network, network.net.hosts, Nlsr) # Producers producers = [n for n in network.net.hosts if n.name in network.groups["producers"]] info("Starting NDN producers on %s\n" % network.groups["producers"]) producers_s = setup_producers(network, producers) # Consumers consumers = [n for n in network.net.hosts if n.name in network.groups["consumers"]] info("Starting NDN consumers on %s\n" % network.groups["consumers"])
def runExperiment(strTopoPath, lstDataQueue, bWifi=True): """ Runs the experiment using regular MiniNDN """ global g_bShowMiniNDNCli, g_bSDNEnabled logging.info('[runExperiment] Running MiniNDN experiment') if (bWifi): MiniNDNClass = MinindnWifi else: MiniNDNClass = Minindn Minindn.cleanUp() Minindn.verifyDependencies() ###################################################### # Start MiniNDN and set controller, if any if (g_bSDNEnabled): ndn = MiniNDNClass(topoFile=strTopoPath, controller=RemoteController) else: ndn = MiniNDNClass(topoFile=strTopoPath) ndn.start() # Wifi topology uses stations instead of hosts, the idea is the same if (bWifi): lstHosts = ndn.net.stations + ndn.net.hosts # for pStation in ndn.net.stations: # strIP = pStation.IP() + '/24' # setStationIPs(pStation, strIP) # logging.info('[runExperiment] station=%s, IP=%s' % (str(pStation), strIP)) if (ndn.net.aps is not None) and (len(ndn.net.aps) > 0): # Connect all APs to the remote controller # This should be done regardless of SDN, otherwise packets will not be routed logging.info('[runExperiment] Setting up access points...') nApId = 1 for pAp in ndn.net.aps: strApId = '1000000000' + str(nApId).zfill(6) subprocess.call([ 'ovs-vsctl', 'set-controller', str(pAp), 'tcp:127.0.0.1:6633' ]) subprocess.call([ 'ovs-vsctl', 'set', 'bridge', str(pAp), 'other-config:datapath-id=' + strApId ]) nApId += 1 # TODO: Add priority based rules to APs if g_bSDNEnabled # ovs-ofctl add-flow <ap_name> dl_type=0x0800 else: lstHosts = ndn.net.hosts ####################################################### # Initialize NFD and set cache size based on host type logging.info('[runExperiment] Starting NFD on nodes') lstHumanHosts = [] lstDroneHosts = [] lstSensorHosts = [] lstVehicleHosts = [] for pHost in lstHosts: if (pHost.name[0] == 'h'): lstHumanHosts.append(pHost) elif (pHost.name[0] == 'd'): lstDroneHosts.append(pHost) elif (pHost.name[0] == 's'): lstSensorHosts.append(pHost) elif (pHost.name[0] == 'v'): lstVehicleHosts.append(pHost) else: raise Exception( '[runExperiment] Hostname=%s not recognized as human, drone, sensor or vehicle' % pHost.name) nfdsHuman = AppManager(ndn, lstHumanHosts, Nfd, csSize=c_nHumanCacheSize, logLevel=c_strNFDLogLevel) logging.info('[runExperiment] Cache set for humans=%d, size=%d' % (len(lstHumanHosts), c_nHumanCacheSize)) nfdsDrone = AppManager(ndn, lstDroneHosts, Nfd, csSize=c_nDroneCacheSize, logLevel=c_strNFDLogLevel) logging.info('[runExperiment] Cache set for drones=%d, size=%d' % (len(lstDroneHosts), c_nDroneCacheSize)) nfdsSensor = AppManager(ndn, lstSensorHosts, Nfd, csSize=c_nSensorCacheSize, logLevel=c_strNFDLogLevel) logging.info('[runExperiment] Cache set for sensors=%d, size=%d' % (len(lstSensorHosts), c_nSensorCacheSize)) nfdsVehicle = AppManager(ndn, lstVehicleHosts, Nfd, csSize=c_nVehicleCacheSize, logLevel=c_strNFDLogLevel) logging.info('[runExperiment] Cache set for vehicles=%d, size=%d' % (len(lstVehicleHosts), c_nVehicleCacheSize)) # Advertise faces logging.info('[runExperiment] Setting up faces for %d hosts' % len(lstHosts)) for pHostOrig in lstHosts: for pHostDest in lstHosts: if (pHostDest != pHostOrig): logging.debug( '[runExperiment] Register, pHostOrig=%s; pHostDest=%s' % (str(pHostOrig), str(pHostDest))) Nfdc.createFace(pHostOrig, pHostDest.IP()) Nfdc.registerRoute( pHostOrig, RandomTalks.getFilterByHostname(str(pHostDest)), pHostDest.IP()) if (not bWifi): ########################################################## # Initialize NLSR logging.info('[runExperiment] Starting NLSR on nodes') nlsrs = AppManager(ndn, lstHosts, Nlsr, logLevel=c_strNLSRLogLevel) ########################################################## # Wait for NLSR initialization, at least 30 seconds to be on the safe side logging.info('[runExperiment] NLSR sleep set to %d seconds' % c_nNLSRSleepSec) time.sleep(c_nNLSRSleepSec) ########################################################## # Set up and run experiment logging.info('[runExperiment] Begin experiment') Experiment = RandomTalks(lstHosts, lstDataQueue) try: logging.info('[runExperiment] Running pingall ...') # ndn.net.pingAll() logging.info('[runExperiment] Pingall done') Experiment.setup() (dtBegin, dtEnd) = Experiment.run() except Exception as e: logging.error( '[runExperiment] An exception was raised during the experiment: %s' % str(e)) raise logging.info( '[runExperiment] End of experiment, TimeElapsed=%s; KBytesConsumed=%.2f' % (str(dtEnd - dtBegin), float(Experiment.nBytesConsumed) / 1024)) if (g_bShowMiniNDNCli): if (bWifi): MiniNDNWifiCLI(ndn.net) else: MiniNDNCLI(ndn.net) ndn.stop()
from minindn.util import MiniNDNCLI from minindn.apps.nfd import Nfd from minindn.apps.nlsr import Nlsr from minindn.apps.tshark import Tshark # THIS EXPERIMENT WILL USE EITHER A PASSED TOPOLOGY FILE OR THE DEFAULT # (located at mini-ndn/topologies/default-topology.conf) IF NOT SPECIFIED. # SEE THE DOCUMENTATION ON WRITING YOUR OWN TOPOLOGY FILES. if __name__ == '__main__': setLogLevel('info') Minindn.cleanUp() Minindn.verifyDependencies() ndn = Minindn() ndn.start() info('Starting tshark logging on nodes\n') tshark = AppManager(ndn, ndn.net.hosts, Tshark, logFolder="./log/", singleLogFile=False) info('Starting NFD on nodes\n') nfds = AppManager(ndn, ndn.net.hosts, Nfd) info('Starting NLSR on nodes\n') nlsrs = AppManager(ndn, ndn.net.hosts, Nlsr) MiniNDNCLI(ndn.net) ndn.stop()
def runExperiment(): setLogLevel('info') info("Starting network") ndnwifi = MinindnWifi( controller=lambda name: RemoteController( name, ip='127.0.0.1', port=6633), topoFile='/home/vagrant/icnsimulations/topologies/topo-tiny.conf') ndnwifi.start() sleep(2) nApId = 1 for pAp in ndnwifi.net.aps: strApId = '1000000000' + str(nApId).zfill(6) subprocess.call( ['ovs-vsctl', 'set-controller', str(pAp), 'tcp:127.0.0.1:6633']) subprocess.call([ 'ovs-vsctl', 'set', 'bridge', str(pAp), 'other-config:datapath-id=' + strApId ]) nApId += 1 # Set IPs for access points nNextIP = 4 lstIntfSet = [] for pAp in ndnwifi.net.aps: lstIntf = pAp.intfList() for pIntf in lstIntf: strIntf = pIntf.name if (strIntf != 'lo') and (strIntf not in lstIntfSet): strIP = '10.0.0.' + str(nNextIP) + '/24' info('AP=%s; Intf=%s; IP=%s\n' % (str(pAp), strIntf, strIP)) pAp.setIP(strIP, intf=pIntf) nNextIP += 1 lstIntfSet.append(strIntf) # Set IPs for hosts for pStation in ndnwifi.net.stations: lstIntf = pStation.intfList() for pIntf in lstIntf: strIntf = pIntf.name if (strIntf != 'lo') and (strIntf not in lstIntfSet): strIP = '10.0.0.' + str(nNextIP) + '/24' info('STATION=%s; Intf=%s; IP=%s\n' % (str(pStation), strIntf, strIP)) pStation.setIP(strIP, intf=pIntf) nNextIP += 1 lstIntfSet.append(strIntf) info("Starting NFD\n") nfds = AppManager(ndnwifi, ndnwifi.net.stations + ndnwifi.net.aps, Nfd) # nlsrs = AppManager(ndnwifi, ndnwifi.net.aps, Nlsr) # Create faces linking every node and instantiate producers info("Creating faces and instantiating producers...\n") hshProducers = {} for pHostOrig in ndnwifi.net.stations + ndnwifi.net.aps: for pHostDest in ndnwifi.net.stations + ndnwifi.net.aps: if (pHostDest != pHostOrig): info('Register, pHostOrig=%s; pHostDest=%s\n' % (str(pHostOrig), str(pHostDest))) Nfdc.createFace(pHostOrig, pHostDest.IP()) Nfdc.registerRoute(pHostOrig, interestFilterForHost(pHostDest), pHostDest.IP()) getPopen(pHostOrig, 'producer %s &' % interestFilterForHost(pHostOrig)) # cons = ndnwifi.net.stations['h0'] # getPopen(cons, 'consumer-with-timer h0') # Start the CLI if (c_bShowCli): MiniNDNWifiCLI(ndnwifi.net) ndnwifi.net.stop() ndnwifi.cleanUp()
dest='faceType', default='udp', choices=['udp', 'tcp']) parser.add_argument('--routing', dest='routingType', default='link-state', choices=['link-state', 'hr', 'dry'], help='''Choose routing type, dry = link-state is used but hr is calculated for comparision.''') ndn = Minindn(parser=parser) ndn.start() info('Starting NFD on nodes\n') nfds = AppManager(ndn, ndn.net.hosts, Nfd) info('Adding static routes to NFD\n') grh = NdnRoutingHelper(ndn.net, ndn.args.faceType, ndn.args.routingType) ####### Configuring nodes based on input parameters info("\nConfiguring nodes\n\n") for host in ndn.net.hosts: value = host.params['params'].get('type', "client") if (value == "server"): data_prefix = host.params['params'].get('prefix', "/example/testApp") # For all host, pass ndn.net.hosts or a list, [ndn.net['a'], ..] or [ndn.net.hosts[0],.] grh.addOrigin([ndn.net[str(host)]], [data_prefix]) info(str(host) + " declared producer for " + data_prefix + "\n") run_cmd = host.params['params'].get('run') if (run_cmd):
from minindn.apps.nfd import Nfd from minindn.apps.nlsr import Nlsr from minindn.helpers.experiment import Experiment from minindn.helpers.nfdc import Nfdc from nlsr_common import getParser if __name__ == '__main__': setLogLevel('info') ndn = Minindn(parser=getParser()) args = ndn.args ndn.start() nfds = AppManager(ndn, ndn.net.hosts, Nfd) nlsrs = AppManager(ndn, ndn.net.hosts, Nlsr, sync=args.sync, security=args.security, faceType=args.faceType, nFaces=args.faces, routingType=args.routingType, logLevel='ndn.*=TRACE:nlsr.*=TRACE') Experiment.checkConvergence(ndn, ndn.net.hosts, args.ctime, quit=False) if args.nPings != 0: Experiment.setupPing(ndn.net.hosts, Nfdc.STRATEGY_BEST_ROUTE) Experiment.startPctPings(ndn.net, args.nPings, args.pctTraffic)
from nlsr_common import getParser # THIS EXPERIMENT WILL USE EITHER A PASSED TOPOLOGY FILE VIA CLI ARGUMENTS # OR THE DEFAULT (located at mini-ndn/topologies/default-topology.conf) # IF NOT SPECIFIED. SEE THE DOCUMENTATION ON WRITING YOUR OWN TOPOLOGY FILES. if __name__ == '__main__': setLogLevel('info') ndn = Minindn(parser=getParser()) args = ndn.args ndn.start() nfds = AppManager(ndn, ndn.net.hosts, Nfd) nlsrs = AppManager(ndn, ndn.net.hosts, Nlsr, sync=args.sync, security=args.security, faceType=args.faceType, nFaces=args.faces, routingType=args.routingType) Experiment.checkConvergence(ndn, ndn.net.hosts, args.ctime, quit=True) firstNode = ndn.net.hosts[0] if args.security: firstNode.cmd('ndnsec-set-default /ndn/{}-site/%C1.Operator/op'.format(
from minindn.apps.app_manager import AppManager from minindn.apps.nfd import Nfd from minindn.apps.nlsr import Nlsr from minindn.helpers.experiment import Experiment from nlsr_common import getParser if __name__ == '__main__': setLogLevel('info') ndn = Minindn(parser=getParser()) args = ndn.args ndn.start() nfds = AppManager(ndn, ndn.net.hosts, Nfd) nlsrs = AppManager(ndn, [], Nlsr) i = 1 info('Starting NLSR on nodes\n') for host in ndn.net.hosts: nlsrs.startOnNode(host, security=args.security, sync=args.sync, faceType=args.faceType, nFaces=args.faces, routingType=args.routingType) # Wait 1/2 minute between starting NLSRs # Wait 1 hour before starting last NLSR if i == len(ndn.net.hosts) - 1:
Minindn.verifyDependencies() parser = argparse.ArgumentParser() parser.add_argument('--face-type', dest='faceType', default='udp', choices=['udp', 'tcp']) parser.add_argument('--routing', dest='routingType', default='link-state', choices=['link-state', 'hr', 'dry'], help='''Choose routing type, dry = link-state is used but hr is calculated for comparision.''') ndn = Minindn(parser=parser) ndn.start() ########## info('Starting tshark logging on nodes\n') tshark = AppManager(ndn, ndn.net.hosts, Tshark, logFolder="../log/", singleLogFile=True) ######### info('Starting NFD on nodes\n') nfds = AppManager(ndn, ndn.net.hosts, Nfd) info('Adding static routes to NFD\n') grh = NdnRoutingHelper(ndn.net, ndn.args.faceType, ndn.args.routingType) info("\nConfiguring nodes\n\n") for host in ndn.net.hosts: value = host.params['params'].get('type',"client") if (value=="server"): data_prefix = host.params['params'].get('prefix',"/example/testApp") # For all host, pass ndn.net.hosts or a list, [ndn.net['a'], ..] or [ndn.net.hosts[0],.] grh.addOrigin([ndn.net[str(host)]], [data_prefix])
random.seed(randomSeed) serverCluster = ndn.args.serverCluster protocol = ndn.args.protocol traceFile = ndn.args.traceFile srcDir = ndn.args.srcDir qspRequestInterval = ndn.args.qspRequestInterval dump_params(ndn.args) is_ndn_eval = True if (protocol != "ZMQ") else False is_ip_eval = not is_ndn_eval info('Start PCAP logging on nodes\n') AppManager(ndn, ndn.net.hosts, Tshark, logFolder=logDir, singleLogFile=True) ################### Start NFDs ################### if is_ndn_eval: # NFD is only required in NDN evaluations info('Starting NFD on nodes\n') nfds = AppManager(ndn, ndn.net.hosts, Nfd) time.sleep(5) # Wait until all NFDs are started ####### Here, the real magic is starting ####### # Calculate regions of the servers requestLevel = int(log(sqrt(numServers), 2)) regionSize = treeSize / 2**requestLevel servers = []
def setup_consumers(network, consumers, zipf=None, interval=None, range=None, target=None): return AppManager( network, consumers, ConsumerService, target=target, zipf=zipf, interval=interval, range=range, prefixes=' '.join(["/ndn/%s-site/%s" % (p, p) for p in sorted(network.groups["producers"])]))
This scenario demonstrates the functionality of the IPRoutingHelper. First, the routing helper calculates and configures routes between all nodes and then calls the `pingAll` command to demonstrate that all nodes are reachable. Successful experiments end with: `*** Results: 0% dropped` To demonstrate the IPRoutingHelper in more complex scenarios, consider starting the experiment with the Geant-Topology (topologies/geant.conf). """ if __name__ == '__main__': setLogLevel('info') Minindn.cleanUp() Minindn.verifyDependencies() ndn = Minindn() ndn.start() info('Starting NFD on nodes\n') nfds = AppManager(ndn, ndn.net.hosts, Nfd) info('Starting NLSR on nodes\n') nlsrs = AppManager(ndn, ndn.net.hosts, Nlsr) # Calculate all routes for IP routing IPRoutingHelper.calcAllRoutes(ndn.net) info("IP routes configured, start ping\n") ndn.net.pingAll() ndn.stop()
def run(): PREFIX = "/ndn/test/" Minindn.cleanUp() Minindn.verifyDependencies() topo = Topo() # Setup topo print("Setup") c1 = topo.addHost('c1') i1 = topo.addHost('i1') i2 = topo.addHost('i2') i3 = topo.addHost('i3') i4 = topo.addHost('i4') i5 = topo.addHost('i5') i6 = topo.addHost('i6') p1 = topo.addHost('p1') topo.addLink(c1, i1, bw=10) topo.addLink(i1, i2, bw=4, delay='40ms') topo.addLink(i1, i3, bw=4, delay='10ms') topo.addLink(i1, i4, bw=4, delay='40ms') topo.addLink(i1, i5, bw=4, delay='40ms') topo.addLink(i2, i6, bw=7, delay='7ms') topo.addLink(i3, i6, bw=7, delay='7ms') topo.addLink(i4, i6, bw=7, delay='7ms') topo.addLink(i5, i6, bw=7, delay='7ms') topo.addLink(i6, p1, bw=10) ndn = Minindn(topo=topo) ndn.start() nfds = AppManager(ndn, ndn.net.hosts, Nfd) # Setup routes to C2 # This is not functional but I'm saving this as an example for the future :) # for host1 in ndn.net.hosts: # for host2 in ndn.net.hosts: # if 'p' in host1.name and not 'p' in host2.name: # return # elif 'i' in host1.name and 'c' in host2.name: # return # else: # interface = host2.connectionsTo(host1)[0] # interface_ip = interface.IP() # Nfdc.registerRoute(host1, PREFIX, interface_ip) links = {"c1": ["i1", "i2"], "i1": ["p1"], "i2": ["p2"]} for first in links: for second in links[first]: host1 = ndn.net[first] host2 = ndn.net[second] interface = host2.connectionsTo(host1)[0] interface_ip = interface.IP() Nfdc.registerRoute(host1, PREFIX, interface_ip) interface = host2.connectionsTo(host1)[0] interface_ip = interface.IP() Nfdc.registerRoute(host1, PREFIX, interface_ip) # Run small thing before to ensure info caching, large afterwards? # print("Setup round") # getPopen(ndn.net["c1"], "ndn-traffic-client -c 5 cons_conf") # getPopen(ndn.net["p1"], "ndn-traffic-server -c 5 prod_conf") # # TODO: Traffic generator! # sleep(5) # ? # nfds["i3"].stop() # tempshark = Tshark(ndn["c1"]) # tempshark.start() # print("Round 1") # time1 = time() # getPopen(ndn.net["c1"], "ndn-traffic-client -c 20 cons_conf") # getPopen(ndn.net["p1"], "ndn-traffic-server -c 20 prod_conf") # # Wait on processes to close, end # time2 = time() # print("Time elapsed: {} s".format(time2 - time1)) MiniNDNCLI(ndn.net)
from mininet.log import setLogLevel, info from minindn.minindn import Minindn from minindn.apps.app_manager import AppManager from minindn.util import MiniNDNCLI from minindn.apps.nfd import Nfd from minindn.apps.nlsr import Nlsr from minindn.apps.tshark import Tshark if __name__ == '__main__': setLogLevel('info') Minindn.cleanUp() Minindn.verifyDependencies() ndn = Minindn() ndn.start() info('Starting tshark logging on nodes\n') tshark = AppManager(ndn, ndn.net.hosts, Tshark, logFolder="./log/") info('Starting NFD on nodes\n') nfds = AppManager(ndn, ndn.net.hosts, Nfd) info('Starting NLSR on nodes\n') nlsrs = AppManager(ndn, ndn.net.hosts, Nlsr) MiniNDNCLI(ndn.net) ndn.stop()
def runExperiment(): setLogLevel('info') dtBegin = datetime.now() info("Starting network") ndn = Minindn( topoFile='/home/vagrant/icnsimulations/topologies/wired-topo4.conf') # ndn = Minindn(topoFile='/home/vagrant/icnsimulations/topologies/wired-switch.conf', controller=lambda name: RemoteController(name, ip='127.0.0.1', port=6633)) ndn.start() # Properly connect switches to the SDN controller # nApId = 1 # for pSwitch in ndn.net.switches: # info('Setting up switch=%s\n3 vsctl', 'set-controller', str(pSwitch), 'tcp:127.0.0.1:6633']) # subprocess.call(['ovs-vsctl', 'set', 'bridge', str(pSwitch), 'other-config:datapath-id='+strApId]) # nApId += 1 # Properly set IPs for all interfaces # nNextIP = 10 # lstIntfSet = [] # for pNode in ndn.net.switches + ndn.net.hosts: # lstIntf = pNode.intfList() # for pIntf in lstIntf: # strIntf = pIntf.name # if (strIntf != 'lo') and (strIntf not in lstIntfSet): # strIP = '10.0.0.' + str(nNextIP) + '/24' # info('Node=%s; Interface=%s; IP=%s\n' % (str(pNode), strIntf, strIP)) # pNode.setIP(strIP, intf=pIntf) # nNextIP += 1 # lstIntfSet.append(strIntf) ''' Node=sw1; Interface=sw1-eth1; IP=10.0.0.10/24 Node=sw1; Interface=sw1-eth2; IP=10.0.0.11/24 Node=sw2; Interface=sw2-eth1; IP=10.0.0.12/24 Node=sw2; Interface=sw2-eth2; IP=10.0.0.13/24 Node=d0; Interface=d0-eth0; IP=10.0.0.14/24 Node=d0; Interface=d0-eth1; IP=10.0.0.15/24 Node=h0; Interface=h0-eth0; IP=10.0.0.16/24 Node=v0; Interface=v0-eth0; IP=10.0.0.17/24 ''' info("Starting NFD and NLSR\n") sleep(2) nfds = AppManager(ndn, ndn.net.hosts, Nfd, logLevel=c_strNFDLogLevel) nlsrs = AppManager(ndn, ndn.net.hosts, Nlsr, logLevel=c_strNLSRLogLevel) # Create faces linking every node and instantiate producers info("Creating faces and instantiating producers...\n") hshProducers = {} nHostsSet = 1 for pHostOrig in ndn.net.hosts: info('Register, pHostOrig=%s %d/%d\n' % (str(pHostOrig), nHostsSet, len(ndn.net.hosts))) for pHostDest in ndn.net.hosts: if (pHostDest != pHostOrig): Nfdc.createFace(pHostOrig, pHostDest.IP()) Nfdc.registerRoute(pHostOrig, interestFilterForHost(pHostDest), pHostDest.IP()) getPopen(pHostOrig, 'producer %s &' % interestFilterForHost(pHostOrig)) nHostsSet += 1 # nPeriodMs = 700 # nMaxPackets = 1000 # for pHost in ndn.net.hosts: # getPopen(pHost, 'consumer-with-timer %s %d %d' % (str(pHost), nPeriodMs, nMaxPackets for pHost in ndn.net.hosts: strCmd1 = 'export HOME=/tmp/minindn/%s; ' % str(pHost) strCmd2 = 'consumer-with-queue %s /home/vagrant/icnsimulations/topologies/queue_wired-topo4.txt &' % ( str(pHost)) strCmd = strCmd1 + strCmd2 info('cmd: %s\n' % strCmd) # pHost.cmd(strCmd) getPopen( pHost, 'consumer-with-queue %s /home/vagrant/icnsimulations/topologies/queue_wired-topo4.txt &' % (str(pHost))) dtDelta = datetime.now() - dtBegin info('Done setting up, took %.2f seconds\n' % dtDelta.total_seconds()) # Start the CLI if (c_bShowCli): MiniNDNCLI(ndn.net) ndn.net.stop() ndn.cleanUp()