def main():
start = datetime.datetime.now()
session = pycore.Session(persistent=True)
if 'server' in globals():
server.addsession(session)
batallion = Batallion(session, 1)
num_nodes = COMPANIES_IN_BATALLION * (HOSTS_IN_PLATOON * PLATOONS_IN_COMPANY + 2 * COMPANIES_IN_BATALLION + 1) + \
2 * COMPANIES_IN_BATALLION + 1 + \
(COMPANIES_IN_BATALLION + 1) * COMPANIES_IN_BATALLION
print 'Finished creating %d nodes.' % num_nodes
if MOVEMENT:
thread = threading.Thread(target=movement_thread,
args=(
generate_configs(batallion),
session,
REFRESH_MS,
))
thread.start()
thread.join()
session.node_count = num_nodes
session.instantiate()
print "elapsed time: %s" % (datetime.datetime.now() - start)
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 = ipaddr.IPv4Prefix("10.14.0.0/16")
self.session = pycore.Session()
# emulated network
self.net = self.session.addobj(cls = pycore.nodes.WlanNode)
for i in xrange(1, numnodes + 1):
addr = "%s/%s" % (prefix.addr(i), 32)
tmp = self.session.addobj(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 createbridgedsession(self, numnodes, verbose=False):
''' Build a topology consisting of the given number of LxcNodes
connected to a WLAN.
'''
# IP subnet
prefix = ipaddr.IPv4Prefix("10.0.0.0/16")
self.session = pycore.Session()
# emulated network
self.net = self.session.addobj(cls=pycore.nodes.WlanNode, name="wlan1")
prev = None
for i in xrange(1, numnodes + 1):
addr = "%s/%s" % (prefix.addr(i), 32)
tmp = self.session.addobj(cls=pycore.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.verbose)
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 test(options):
prefix = ipaddr.IPv4Prefix("10.83.0.0/16")
session = pycore.Session(persistent=True)
if options.enablesdt:
session.location.setrefgeo(47.57917, -122.13232, 50.0) # GUI default
session.location.refscale = 100.0
session.options.enablesdt = True
session.options.sdturl = options.sdturl
wlanid = options.numnodes + 1
net = session.addobj(cls=pycore.nodes.WlanNode,
name="wlan%d" % wlanid,
objid=wlanid,
verbose=True)
values = list(BasicRangeModel.getdefaultvalues())
#values[0] = 5000000 # 5000km range
net.setmodel(BasicRangeModel, values)
for i in xrange(1, options.numnodes + 1):
tmp = session.addobj(cls=pycore.nodes.LxcNode, name="n%d" % i, objid=i)
tmp.newnetif(net, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)])
# set increasing Z coordinates
tmp.setposition(10, 10, 100 * i)
n.append(tmp)
# 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)
n[0].term("bash")
# wait for rate seconds to allow ebtables commands to commit
time.sleep(EbtablesQueue.rate)
def __init__(self, numnodes, nodecls=quagga.node.QuaggaTestNode):
assert numnodes >= 0
self.session = pycore.Session()
self.n = []
for i in xrange(numnodes):
nodeid = i + 1
n = self.session.addobj(cls=nodecls,
name='n%s' % nodeid,
nodeid=nodeid)
self.n.append(n)
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 = ipaddr.IPv4Prefix("10.83.0.0/16")
session = pycore.Session(persistent=True)
if 'server' in globals():
server.addsession(session)
# emulated Ethernet switch
switch = session.addobj(cls=pycore.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.addobj(cls=pycore.nodes.CoreNode,
name="n%d" % i,
objid=i)
tmp.newnetif(switch, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)])
tmp.cmd([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()
# start a shell on node 1
n[1].term("bash")
print "elapsed time: %s" % (datetime.datetime.now() - start)
def __init__(self, hub_name):
logging.config.fileConfig('logging.conf')
super(Xgrid, self).__init__()
self.session = pycore.Session(persistent=True)
self.hub = self.session.addobj(cls=pycore.nodes.HubNode, name=hub_name)
self.database = Database("database", self.hub, self.session,
"10.0.0.3/24")
self.director = Director("director", self.hub, self.session,
"10.0.0.1/24")
self.publisher = Publisher("publisher", self.hub, self.session,
"10.0.0.2/24")
def test(numnodes, testsec):
# node list
n = []
# IP subnet
prefix = ipaddr.IPv4Prefix("10.83.0.0/16")
session = pycore.Session()
# emulated network
net = session.addobj(cls = pycore.nodes.SwitchNode)
for i in xrange(1, numnodes + 1):
tmp = session.addobj(cls = pycore.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"])
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 = ipaddr.IPv4Prefix("10.0.0.0/16")
self.session = pycore.Session()
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.cfg['emane_models'] = "RfPipe, Ieee80211abg, Bypass"
self.session.emane.loadmodels()
self.net = self.session.addobj(cls=pycore.nodes.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.addobj(cls=pycore.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",
self.verbose)
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 main():
addservice(JoshService)
session = pycore.Session(persistent=True)
test(2,100,session)
# now we launch cored.py services so GUI can connect to this script
print "launching cored services"
# the following lines are from cored.py cored()
cfg, args = cored.getMergedConfig("%s/core.conf" % CORE_CONF_DIR)
cored.banner()
server = cored.CoreServer(("localhost", coreapi.CORE_API_PORT),
cored.CoreRequestHandler, cfg)
print "adding session %s to cored.server" % session.sessionid
server.addsession(session)
print "running cored server - you may now connect the GUI"
try:
server.serve_forever()
except KeyboardInterrupt:
pass
def _import(self):
""" Internal routine: create a temporary session and import
nodes and interfaces from it.
"""
# create temp session from which to import nodes and interfaces
tmp = pycore.Session()
misc.xmlsession.opensessionxml(tmp, self._xml_file)
# remember new and old wlan objects
wn = None
wo = None
# import objects
for o in tmp.objs():
if isinstance(o, netns.nodes.WlanNode):
wo = o
wn = self.addobj(netns.nodes.WlanNode, name=wo.name)
x, y, z = wo.getposition()
wn.setposition(x, y, z)
wn.setmodel(mobility.BasicRangeModel,
self._model_params(wo.name))
elif isinstance(o, netns.nodes.CoreNode):
n = self.addobj(netns.nodes.CoreNode, name=o.name)
x, y, z = o.getposition()
n.setposition(x, y, z)
else:
raise Exception("object of unknown class: %s" % o)
# import interfaces
for i in wo.netifs():
o = self.objbyname(i.node.name)
o.newnetif(net=wn, addrlist=i.addrlist)
# close import session
tmp.shutdown()
#!/usr/bin/python
import time
import sys
import shutil
from core import netns
from core import pycore
def ncmd(node, args):
return node.redircmd(sys.stdin.fileno(),sys.stdout.fileno(),sys.stdout.fileno(),args)
print("Expected behavior: all 20 packets should be allowed through")
session = pycore.Session(persistent=True)
ptpnet1 = netns.nodes.PtpNet(session)
ptpnet2 = netns.nodes.PtpNet(session)
n1 = session.addobj(cls = pycore.nodes.CoreNode, name="n1")
router = session.addobj(cls = pycore.nodes.CoreNode, name="router")
n2 = session.addobj(cls = pycore.nodes.CoreNode, name="n2")
router.newnetif(net=ptpnet1, addrlist=["10.0.1.1/24"], ifindex=0)
router.newnetif(net=ptpnet2, addrlist=["10.0.2.1/24"], ifindex=1)
n1.newnetif(net=ptpnet1, addrlist=["10.0.1.10/24"], ifindex=0)
n2.newnetif(net=ptpnet2, addrlist=["10.0.2.10/24"], ifindex=0)
n1.icmd(["ip","route","add","default","via","10.0.1.1"])
n2.icmd(["ip","route","add","default","via","10.0.2.1"])
router.nodefilecopy("ngp","../ngp")
router.nodefilecopy("net.conf","../net.conf")
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 = ipaddr.IPv4Prefix("10.83.0.0/16")
# session with some EMANE initialization
cfg = {'verbose': 'false'}
session = pycore.Session(cfg = cfg, persistent = True)
session.master = True
session.location.setrefgeo(47.57917,-122.13232,2.00000)
session.location.refscale = 150.0
session.cfg['emane_models'] = "RfPipe, Ieee80211abg, Bypass"
session.emane.loadmodels()
if 'server' in globals():
server.addsession(session)
# EMANE WLAN
print "creating EMANE WLAN wlan1"
wlan = session.addobj(cls = pycore.nodes.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
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|vtysh|IPForward"
print "creating %d nodes with addresses from %s" % \
(options.numnodes, prefix)
for i in xrange(1, options.numnodes + 1):
tmp = session.addobj(cls = pycore.nodes.CoreNode, name = "n%d" % i,
objid=i)
tmp.newnetif(wlan, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)])
tmp.cmd([SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"])
tmp.setposition(x=150*i,y=150)
session.services.addservicestonode(tmp, "", services_str, verbose=False)
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 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 = ipaddr.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 = pycore.Session(persistent=True)
switch = session.addobj(cls = pycore.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.addobj(cls = pycore.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.addobj(cls = pycore.nodes.LxcNode, name = "n%d" % i)
n.newnetif(switch, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)])
n.cmd([SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"])
if options.services is not None:
session.services.addservicestonode(n, "", options.services,
verbose=False)
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 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 = pycore.Session(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.addobj(cls=pycore.nodes.CoreNode,
name="n%d" % i,
objid=i)
if left:
tmp.newnetif(left, ["%s/%s" % (prefix.addr(2), prefix.prefixlen)])
prefix = ipaddr.IPv4Prefix("10.83.%d.0/24" % i) # limit: i < 255
right = session.addobj(cls=pycore.nodes.PtpNet)
tmp.newnetif(right, ["%s/%s" % (prefix.addr(1), prefix.prefixlen)])
tmp.cmd([SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"])
tmp.cmd([SYSCTL_BIN, "net.ipv4.conf.all.forwarding=1"])
tmp.cmd([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): ipaddr.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([IP_BIN, "route", "add", str(net), "via", str(gw)])
print "elapsed time: %s" % (datetime.datetime.now() - start)
def runExperiment_serverLog(logPath, csv, xType, initBandwidth, initDelay, initJitter, initLoss, initDuplicate, xVals, numRuns):
curPath = logPath + csv
workfile = open(curPath,"w")
workfile.write("timestamp,sourceIP,sourcePort,destinationIP,destinationPort,ID,interval,dataTransferred,bandwidth\n")
workfile.close()
session = pycore.Session(persistent=True)
node1 = session.addobj(cls=pycore.nodes.CoreNode, name="n1")
node2 = session.addobj(cls=pycore.nodes.CoreNode, name="n2")
hub1 = session.addobj(cls=pycore.nodes.HubNode, name="hub1")
node1.newnetif(hub1, ["10.0.0.1/24"], ifname = "net1")
node2.newnetif(hub1, ["10.0.0.2/24"], ifname = "net2")
hub1.linkconfig(netif = node1.netif(0), bw = initBandwidth*1000000, delay = initDelay, jitter = initJitter,
loss = initLoss, duplicate = initDuplicate, devname=None)
hub1.linkconfig(netif = node2.netif(0), bw = initBandwidth*1000000, delay = initDelay, jitter = initJitter,
loss = initLoss, duplicate = initDuplicate, devname=None)
node2.shcmd("nohup iperf -s -f m >> %s &" %(curPath))
if xType == "bandwidth":
for bandwidth in xVals:
hub1.linkconfig(netif = node1.netif(0), bw = bandwidth*1000000, delay = initDelay, jitter = initJitter,
loss = initLoss, duplicate = initDuplicate, devname=None)
hub1.linkconfig(netif = node2.netif(0), bw = bandwidth*1000000, delay = initDelay, jitter = initJitter,
loss = initLoss, duplicate = initDuplicate, devname=None)
time.sleep(2) #give time for linkconfigs to be processed by CORE
for i in range(numRuns):
node1.cmd(["iperf","-c","10.0.0.2"], wait=True)
time.sleep(30)
elif xType == "delay":
for delay in xVals:
hub1.linkconfig(netif = node1.netif(0), bw = initBandwidth*1000000, delay = delay/2.0, jitter = initJitter,
loss = initLoss, duplicate = initDuplicate, devname=None)
hub1.linkconfig(netif = node2.netif(0), bw = initBandwidth*1000000, delay = delay/2.0, jitter = initJitter,
loss = initLoss, duplicate = initDuplicate, devname=None)
time.sleep(2) #give time for linkconfigs to be processed by CORE
for i in range(numRuns):
node1.cmd(["iperf","-c","10.0.0.2"], wait=True)
time.sleep(30)
elif xType == "jitter":
for jitter in xVals:
hub1.linkconfig(netif = node1.netif(0), bw = initBandwidth*1000000, delay = initDelay, jitter = jitter,
loss = initLoss, duplicate = initDuplicate, devname=None)
hub1.linkconfig(netif = node2.netif(0), bw = initBandwidth*1000000, delay = initDelay, jitter = jitter,
loss = initLoss, duplicate = initDuplicate, devname=None)
time.sleep(2) #give time for linkconfigs to be processed by CORE
for i in range(numRuns):
node1.cmd(["iperf","-c","10.0.0.2"], wait=True)
time.sleep(30)
elif xType == "loss":
for loss in xVals:
hub1.linkconfig(netif = node1.netif(0), bw = initBandwidth*1000000, delay = initDelay, jitter = initJitter,
loss = loss, duplicate = initDuplicate, devname=None)
hub1.linkconfig(netif = node2.netif(0), bw = initBandwidth*1000000, delay = initDelay, jitter = initJitter,
loss = loss, duplicate = initDuplicate, devname=None)
time.sleep(2) #give time for linkconfigs to be processed by CORE
for i in range(numRuns):
node1.cmd(["iperf","-c","10.0.0.2"], wait=True)
time.sleep(30)
elif xType == "duplicate":
for duplicate in xVals:
hub1.linkconfig(netif = node1.netif(0), bw = initBandwidth*1000000, delay = initDelay, jitter = initJitter,
loss = initLoss, duplicate = duplicate, devname=None)
hub1.linkconfig(netif = node2.netif(0), bw = initBandwidth*1000000, delay = initDelay, jitter = initJitter,
loss = initLoss, duplicate = duplicate, devname=None)
time.sleep(2) #give time for linkconfigs to be processed by CORE
for i in range(numRuns):
node1.cmd(["iperf","-c","10.0.0.2"], wait=True)
time.sleep(30)
else:
print("Error: invalid x-value type")
session.shutdown()
exit(-1)
session.shutdown()
return
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(coreapi.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 = ipaddr.IPv4Prefix("10.83.0.0/16")
session = pycore.Session(persistent=True)
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 = coreapi.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.sessionid = session.broker.getserver(
'localhost')[2].getsockname()[1]
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.setstate(coreapi.CORE_EVENT_CONFIGURATION_STATE)
tlvdata = coreapi.CoreEventTlv.pack(coreapi.CORE_TLV_EVENT_TYPE,
coreapi.CORE_EVENT_CONFIGURATION_STATE)
session.broker.handlerawmsg(coreapi.CoreEventMessage.pack(0, tlvdata))
flags = coreapi.CORE_API_ADD_FLAG
switch = pycore.nodes.SwitchNode(session=session,
name='switch',
start=False)
switch.setposition(x=80, y=50)
switch.server = daemon
session.broker.handlerawmsg(switch.tonodemsg(flags=flags))
numberOfNodes = options.numnodes
print "creating %d remote nodes with addresses from %s" % \
(options.numnodes, prefix)
# create remote nodes via API
for i in xrange(1, numberOfNodes + 1):
tmp = pycore.nodes.CoreNode(session=session,
objid=i,
name="n%d" % i,
start=False)
tmp.setposition(x=150 * i, y=150)
tmp.server = daemon
session.broker.handlerawmsg(tmp.tonodemsg(flags=flags))
n.append(tmp)
# create remote links via API
for i in xrange(1, numberOfNodes + 1):
tlvdata = coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_N1NUMBER,
switch.objid)
tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_N2NUMBER, i)
tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_TYPE,
coreapi.CORE_LINK_WIRED)
tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_IF2NUM, 0)
tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_IF2IP4,
prefix.addr(i))
tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_IF2IP4MASK,
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(coreapi.CORE_TLV_EVENT_TYPE,
coreapi.CORE_EVENT_INSTANTIATION_STATE)
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."
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()
prefix = ipaddr.IPv4Prefix("10.83.0.0/16")
session = pycore.Session(persistent=True)
wlan = session.addobj(cls = pycore.nodes.WlanNode, name = "wlan")
values = BasicRangeModel.getdefaultvalues()
wlan.setmodel(BasicRangeModel, values)
wlan.setposition(x=80,y=50)
print "creating %d nodes with addresses from %s" % \
(options.numnodes, prefix)
model = "PC"
for i in xrange(1, options.numnodes + 1):
n = session.addobj(cls = pycore.nodes.CoreNode, name = "n%d" % i,
objid=i)
n.type = model
n.newnetif(wlan, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)])
n.cmd(["sysctl", "net.ipv4.icmp_echo_ignore_broadcasts=0"])
n.setposition(x=150*i,y=150)
session.services.addservicestonode(n, model, "DefaultRoute", False)
session.services.addservicestonode(n, "", "MyHaggleService", True)
session.services.bootnodeservices(n)
nodes.append(n)
# start a shell on node 1
nodes[1].term("bash")
print "elapsed time: %s" % (datetime.datetime.now() - start)
t = threading.Thread(target = wandering_node, args=(nodes[1],))
t.start()
# now we launch cored.py services so GUI can connect to this script
print "launching cored services"
# the following lines are from cored.py cored()
cfg, args = cored.getMergedConfig("%s/core.conf" % CORE_CONF_DIR)
cored.banner()
server = cored.CoreServer(("localhost", coreapi.CORE_API_PORT),
cored.CoreRequestHandler, cfg)
print "adding session %s to cored.server" % session.sessionid
server.addsession(session)
print "running cored server - you may now connect the GUI"
try:
server.serve_forever()
except KeyboardInterrupt:
pass
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 = ipaddr.IPv4Prefix("10.83.0.0/16")
session = pycore.Session(persistent=True)
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 = coreapi.CORE_API_PORT
print "connecting to slave at %s:%d" % (slave, port)
session.broker.addserver(slave, slave, port)
session.broker.setupserver(slave)
session.setstate(coreapi.CORE_EVENT_CONFIGURATION_STATE)
tlvdata = coreapi.CoreEventTlv.pack(coreapi.CORE_TLV_EVENT_TYPE,
coreapi.CORE_EVENT_CONFIGURATION_STATE)
session.broker.handlerawmsg(coreapi.CoreEventMessage.pack(0, tlvdata))
switch = session.addobj(cls = pycore.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):
tmp = session.addobj(cls = pycore.nodes.CoreNode, name = "n%d" % i,
objid=i)
tmp.newnetif(switch, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)])
tmp.cmd([SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"])
tmp.setposition(x=150*i,y=150)
n.append(tmp)
flags = coreapi.CORE_API_ADD_FLAG
session.broker.handlerawmsg(switch.tonodemsg(flags=flags))
# create remote nodes via API
for i in xrange(num_local + 1, options.numnodes + 1):
tmp = pycore.nodes.CoreNode(session = session, objid = i,
name = "n%d" % i, start=False)
tmp.setposition(x=150*i,y=150)
tmp.server = slave
n.append(tmp)
session.broker.handlerawmsg(tmp.tonodemsg(flags=flags))
# create remote links via API
for i in xrange(num_local + 1, options.numnodes + 1):
tlvdata = coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_N1NUMBER,
switch.objid)
tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_N2NUMBER, i)
tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_TYPE,
coreapi.CORE_LINK_WIRED)
tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_IF2NUM, 0)
tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_IF2IP4,
prefix.addr(i))
tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_IF2IP4MASK,
prefix.prefixlen)
msg = coreapi.CoreLinkMessage.pack(flags, tlvdata)
session.broker.handlerawmsg(msg)
session.instantiate()
tlvdata = coreapi.CoreEventTlv.pack(coreapi.CORE_TLV_EVENT_TYPE,
coreapi.CORE_EVENT_INSTANTIATION_STATE)
msg = coreapi.CoreEventMessage.pack(0, tlvdata)
session.broker.handlerawmsg(msg)
# start a shell on node 1
n[1].term("bash")
# TODO: access to remote nodes is currently limited in this script
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 runMesherExperiment(duration, node_cnt, logfolder, scheduler=None, delay=0):
def createCoreNode(node_number, cable):
if node_number < 1 or node_number > 254:
raise Exception("0 < node_number < 256, since we use 10.0.0.0/24")
node = session.addobj(cls=pycore.nodes.CoreNode, name="n{}".format(str(i).zfill(3)))
node.newnetif(cable, ["10.0.0.{}/24".format(i)])
session.services.addservicestonode(node, "", services, verbose=False)
return node
def endExperiment():
print("### Ending experiment...")
print(" stopping netmon")
netmon.stop()
# os.mkdir("{}/netmon".format(logfolder))
print(" copying files")
os.mkdir("{}/mesher".format(logfolder))
for f in os.listdir(session.sessiondir):
if f.endswith(".log"):
# if f.startswith("netmon"): shutil.move("{}/{}".format(session.sessiondir, f), "{}/netmon".format(logfolder))
if f.startswith("mesher"): shutil.move("{}/{}".format(session.sessiondir, f), "{}/mesher".format(logfolder))
else: shutil.move("{}/{}".format(session.sessiondir, f), logfolder)
with open("{}/configuration.csv".format(logfolder), "w+") as config:
config.write("duration, {}\n".format(duration))
config.write("node_cnt, {}\n".format(node_cnt))
try:
config.write("scheduler, {}\n".format(scheduler.split("/")[-1]))
except Exception as e:
config.write("scheduler, {}\n".format(scheduler))
print(" shutting down session")
session.shutdown()
print(" done.\n")
print(" Results in folder: {}\n".format(logfolder))
def copy_scheduler(scheduler):
if not scheduler:
print("Warn: No scheduler set, removing {}".format(scheduler_targer))
elif not os.path.exists(scheduler):
print("Warn: No file at \"{}\", removing {}".format(scheduler_targer))
else:
shutil.copyfile(scheduler, scheduler_targer)
shutil.copyfile(scheduler, "{}/scheduler.js".format(logfolder))
copy_scheduler(scheduler)
print("### Creating CORE session.")
session = pycore.Session(persistent=True)
def signal_handler(signal, frame):
endExperiment()
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
print("### Importing custom services from {}".format(myservices_path))
service.CoreServices(session).importcustom(myservices_path)
print("### Creating central network hub.")
hub = session.addobj(cls=pycore.nodes.HubNode, name="hub")
print("### Creating {} nodes with services: {}".format(node_cnt, services))
nodes = []
for i in range(node_cnt):
nodes.append(createCoreNode(i+1, hub))
print("### Attaching netmon to network hub.")
netmon.start(hub.brname, outpath="{}/netmon-hub.csv".format(logfolder), port=8032)
if delay == 0:
print("### Starting node services in 20s window")
s = sched.scheduler(time.time, time.sleep)
def finished(): print(" Finished starting nodes.")
s.enter(20, 1, finished, ())
for n in nodes:
node_delay = random.uniform(0, 20.0)
s.enter(node_delay, 1, service.CoreServices(session).bootnodeservices, (n,))
s.run()
remaining_duration = duration - 20
else:
print("### Starting node services (with avg {}s delay)".format(delay))
remaining_duration = duration - len(nodes) * delay
for n in nodes:
preDelay = random.uniform(0, delay)
time.sleep(preDelay)
service.CoreServices(session).bootnodeservices(n)
time.sleep(delay-preDelay)
sys.stdout.write(".")
print("\n### Experiment is now running for remaining {} seconds.\n".format(remaining_duration))
for i in range(remaining_duration):
time.sleep(1)
sys.stdout.write(".")
print(" time's up!")
endExperiment()
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 = ipaddr.IPv4Prefix("10.83.0.0/16")
session = pycore.Session(persistent=True)
# emulated Ethernet switch
switch = session.addobj(cls = pycore.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.addobj(cls = pycore.nodes.CoreNode, name = "n%d" % i,
objid=i)
tmp.newnetif(switch, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)])
tmp.cmd(["sysctl", "net.ipv4.icmp_echo_ignore_broadcasts=0"])
tmp.setposition(x=150*i,y=150)
tmp.verbose = True
print "node %s nodedir=%s" % (tmp.name, tmp.nodedir)
session.services.addservicestonode(tmp, "", "MyService", True)
session.services.bootnodeservices(tmp)
n.append(tmp)
# start a shell on node 1
n[1].term("bash")
print "elapsed time: %s" % (datetime.datetime.now() - start)
# now we launch cored.py services so GUI can connect to this script
print "launching cored services"
# the following lines are from cored.py cored()
cfg, args = cored.getMergedConfig("%s/core.conf" % CORE_CONF_DIR)
cored.banner()
server = cored.CoreServer(("localhost", coreapi.CORE_API_PORT),
cored.CoreRequestHandler, cfg)
print "adding session %s to cored.server" % session.sessionid
server.addsession(session)
print "running cored server - you may now connect the GUI"
try:
server.serve_forever()
except KeyboardInterrupt:
pass
