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 main(): setLogLevel('info') Popen(['rm', '-r', '/tmp/minindn/'], stdout=PIPE, stderr=PIPE).communicate() ndn = Minindn() repos = { 'r1': { 'repoPrefix': '/repo/r1', 'servedPrefixes': ['/sensor/s1'], 'host': ndn.net['r1'] } } sensors = { 's1': { 'sensorPrefix': '/sensor/s1', 'host': ndn.net['s1'], 'service': 'repo' } # sensor is interested in repo service } users = { 'u1': { 'userPrefix': '/user/u1', 'host': ndn.net['u1'], 'service': 'repo' } # user is interested in repo service, and to find what prefixes it serves } repo_obj = Repo() bms = BMS(ndn, ndn.args, repo_obj, repos, sensors, users) bms.configureRepo() bms.configureSensor() bms.configureUsers() # insert some data into the repo bms.users['u1']["repoNames"] = getRepoNames(bms.users['u1']['host'].name, bms.users['u1']["logFile"]) bms.sensors['s1']["repoNames"] = getRepoNames( bms.sensors['s1']['host'].name, bms.sensors['s1']['logFile']) repo_obj.putDataIntoRepo(bms.sensors['s1']["host"], bms.sensors['s1']['repoNames'][0], bms.sensors['s1']["sensorPrefix"]) time.sleep(2) #make sure data is inserted into the repo repo_obj.getDataFromRepo(bms.users['u1']["host"], bms.users['u1']["repoNames"][0], bms.sensors['s1']["sensorPrefix"]) MiniNDNCLI(ndn.net) ndn.stop()
def registerRoute(node, namePrefix, remoteNodeAddress, protocol=PROTOCOL_UDP, origin=255, cost=0, inheritFlag=True, captureFlag=False, expirationInMillis=None): cmd = ('nfdc route add {} {}://{} origin {} cost {} {}{}{}').format( namePrefix, protocol, remoteNodeAddress, origin, cost, 'no-inherit ' if not inheritFlag else '', 'capture ' if captureFlag else '', 'expires {}'.format(expirationInMillis) if expirationInMillis else '') debug(node.cmd(cmd)) Minindn.sleep(SLEEP_TIME)
def start(self): self.createFaces() Application.start(self, 'nlsr -f {}'.format(self.confFile), self.logFile, self.envDict) Minindn.sleep(1)
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)
def unsetStrategy(node, namePrefix): debug(node.cmd("nfdc strategy unset {}".format(namePrefix))) Minindn.sleep(SLEEP_TIME)
def setStrategy(node, namePrefix, strategy): cmd = 'nfdc strategy set {} ndn:/localhost/nfd/strategy/{}'.format( namePrefix, strategy) debug(node.cmd(cmd)) Minindn.sleep(SLEEP_TIME)
from minindn.minindn import Minindn from minindn.apps.app_manager import AppManager from minindn.apps.nfd import Nfd from minindn.apps.nlsr import Nlsr from nlsr_common import getParser if __name__ == '__main__': setLogLevel('info') topo = Topo() h1 = topo.addHost('h1') h2 = topo.addHost('h2') topo.addLink(h1, h2, delay='10ms') ndn = Minindn(parser=getParser(), topo=topo) args = ndn.args ndn.start() nfds = AppManager(ndn, ndn.net.hosts, Nfd) nlsrs = AppManager(ndn, [], Nlsr) host1 = ndn.net.hosts[0] nlsrs.startOnNode(host1, security=args.security, faceType=args.faceType, nFaces=args.faces, routingType=args.routingType) expectedTotalCount = 500
from minindn.util import MiniNDNCLI 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 # 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)
nodes = dict() if type == 'C': for c in range(0, count): name = 'c{}'.format(c + 1) nodes[name] = 'printer' elif type == 'P': for c in range(0, count): name = 'p{}'.format(c + 1) nodes[name] = ['printer', 100] return nodes if __name__ == '__main__': subprocess.call(['rm', '-r', '/tmp/minindn/*']) setLogLevel('info') ndn = Minindn() producers = dict() consumers = dict() producers = generateNode('P', 3) consumers = generateNode('C', 1) print(consumers, producers) exp = NDNSDExperiment(ndn, producers, consumers) # ----------------------------- adding static routes using ndn routing helper ----------------------- # For all host, pass ndn.net.hosts or a list, [ndn.net['a'], ..] or [ndn.net.hosts[0],.] info('Adding static routes to NFD\n') grh = NdnRoutingHelper(ndn.net) for host in exp.producer_nodes: hostName = host.name appPrefix = '/ndnsd/{}/service-info'.format(hostName) discoveryPrefix = '/discovery/{}'.format(exp.producers[hostName][0])
from mininet.log import setLogLevel, info from minindn.minindn import Minindn from minindn.util import MiniNDNCLI 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 minindn.helpers.nfdc import Nfdc from nlsr_common import getParser if __name__ == '__main__': setLogLevel('info') Minindn.cleanUp() Minindn.verifyDependencies() # Can pass a custom parser, custom topology, or any Mininet params here ndn = Minindn(parser=getParser()) args = ndn.args ndn.start() # Start apps with AppManager which registers a clean up function with ndn 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,
from minindn.apps.nfd import Nfd from minindn.helpers.nfdc import Nfdc def registerRouteToAllNeighbors(ndn, host, syncPrefix): for node in ndn.net.hosts: for neighbor in node.connectionsTo(host): ip = node.IP(neighbor[0]) Nfdc.createFace(host, ip) Nfdc.registerRoute(host, syncPrefix, ip) if __name__ == '__main__': setLogLevel('info') ndn = Minindn() args = ndn.args ndn.start() nfds = AppManager(ndn, ndn.net.hosts, Nfd) syncPrefix = "/sync" numUserPrefixesPerNode = 2 maxUpdatesPerUserPrefixPerNode = 3 for host in ndn.net.hosts: Nfdc.setStrategy(host, syncPrefix, Nfdc.STRATEGY_MULTICAST) registerRouteToAllNeighbors(ndn, host, syncPrefix) info('Starting psync-full-sync on all the nodes\n')
import argparse import sys from mininet.log import setLogLevel, info from mininet.topo import Topo from minindn.minindn import Minindn from minindn.util import MiniNDNCLI from minindn.apps.app_manager import AppManager from minindn.apps.nfd import Nfd from minindn.helpers.ndn_routing_helper import NdnRoutingHelper if __name__ == '__main__': setLogLevel('info') Minindn.cleanUp() 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.''') ''' Experiment run with default topology, test cases won't work with other topologies
import sys from mininet.log import setLogLevel, info from mininet.topo import Topo from minindn.minindn import Minindn from minindn.apps.app_manager import AppManager from minindn.apps.nfd import Nfd if __name__ == '__main__': setLogLevel('info') topo = Topo() topo.addHost('h1') ndn = Minindn(topo=topo) args = ndn.args ndn.start() nfds = AppManager(ndn, ndn.net.hosts, Nfd) host1 = ndn.net.hosts[0] host1.cmd('export NDN_LOG=examples.PartialSyncProducerApp=INFO') host1.cmd('psync-producer /sync /{} 10 1 &> producer.log &'.format( host1.name)) time.sleep(1) host1.cmd('export NDN_LOG=examples.PartialSyncConsumerApp=INFO:$NDN_LOG') host1.cmd('psync-consumer /sync 5 &> consumer.log &')
def unregisterRoute(node, namePrefix, remoteNodeAddress, origin=255): cmd = 'nfdc route remove {} {} {}'.format(namePrefix, remoteNodeAddress, origin) debug(node.cmd(cmd)) Minindn.sleep(SLEEP_TIME)
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()
def createFace(node, remoteNodeAddress, protocol='udp', isPermanent=False): cmd = ('nfdc face create {}://{} {}'.format( protocol, remoteNodeAddress, 'permanent' if isPermanent else 'persistent')) debug(node.cmd(cmd)) Minindn.sleep(SLEEP_TIME)
def start(self): Application.start(self, 'mw-nfd --config {}'.format(self.confFile), logfile=self.logFile) Minindn.sleep(2)
def destroyFace(node, remoteNodeAddress, protocol='udp'): debug( node.cmd('nfdc face destroy {}://{}'.format( protocol, remoteNodeAddress))) Minindn.sleep(SLEEP_TIME)
# along with Mini-NDN, e.g., in COPYING.md file. # If not, see <http://www.gnu.org/licenses/>. 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)
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()