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()