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 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 test_mobility(self, core):
"""
Test basic wlan network.
:param conftest.Core core: core fixture to test with
"""
# create wlan
wlan_node = core.session.add_object(cls=nodes.WlanNode)
values = BasicRangeModel.getdefaultvalues()
wlan_node.setmodel(BasicRangeModel, values)
# create nodes
core.create_node("n1",
objid=1,
position=(0, 0),
services=EMANE_SERVICES,
model="mdr")
core.create_node("n2",
objid=2,
position=(0, 0),
services=EMANE_SERVICES,
model="mdr")
# add interfaces
interface_one = core.add_interface(wlan_node, "n1")
interface_two = core.add_interface(wlan_node, "n2")
# link nodes in wlan
core.link(wlan_node, interface_one, interface_two)
# configure mobility script for session
config = ConfigData(
node=wlan_node.objid,
object="ns2script",
type=0,
data_types=(10, 3, 11, 10, 10, 10, 10, 10, 0),
data_values="file=%s|refresh_ms=50|loop=1|autostart=0.0|"
"map=|script_start=|script_pause=|script_stop=" % _MOBILITY_FILE)
core.session.config_object(config)
# add handler for receiving node updates
event = threading.Event()
def node_update(_):
event.set()
core.session.node_handlers.append(node_update)
# instantiate session
core.session.instantiate()
# assert node directories created
core.assert_nodes()
# validate we receive a node message for updating its location
assert event.wait(5)
def __init__(self, session, batallion_index):
self.companies = [None]
self.batallion_index = batallion_index
self.twlans = []
dist = MAX_C_DISPL / 2 + MAX_P_DISPL + MAX_P_DISPL / 10
pos = (dist, dist, 0)
verts = ngon_verts(COMPANIES_IN_BATALLION + 1, MAX_C_DISPL / 2)
LOCATIONS = [(pos[0] + verts[i][0], pos[1] + verts[i][1], 0)
for i in xrange(COMPANIES_IN_BATALLION + 1)]
x = LOCATIONS[0][0]
y = LOCATIONS[0][1]
r_verts = ngon_verts(COMPANIES_IN_BATALLION * 2, MAX_P_DISPL / 10)
self.wlan = session.addobj(cls=pycore.nodes.WlanNode,
name='uwlan%d' %
(COMPANIES_IN_BATALLION + 1))
self.wlan.setposition(x=x, y=y)
values = list(BasicRangeModel.getdefaultvalues())
values[0] = str(WLAN_RANGE)
self.wlan.setmodel(BasicRangeModel, values)
self.routers = [None]
for i in xrange(COMPANIES_IN_BATALLION * 2):
r_index = COMPANIES_IN_BATALLION * COMPANIES_IN_BATALLION * 2 + 1 + i
router = session.addobj(cls=pycore.nodes.CoreNode,
name='r%d' % r_index)
router.setposition(x=x + r_verts[i][0], y=y + r_verts[i][1])
session.services.addservicestonode(router, 'router', None, False)
index = 1 + i
router.newnetif(self.wlan, [
'%d.%d.1.%d/24' %
(self.batallion_index, COMPANIES_IN_BATALLION + 1, index)
])
self.routers.append(router)
for i in xrange(1, COMPANIES_IN_BATALLION + 1):
self.connect_company(session, LOCATIONS[i])
top_nodes = list(self.companies) + [self]
index = 1
for i in xrange(1, len(top_nodes)):
start_i = i * 2 - 1
for j in xrange(i + 1, len(top_nodes)):
self.link(session, index, top_nodes[i].routers[start_i],
top_nodes[j].routers[i * 2 - 1], top_nodes[i])
index = index + 1
self.link(session, index, top_nodes[i].routers[start_i + 1],
top_nodes[j].routers[i * 2], top_nodes[j])
index = index + 1
start_i += 2
def link(self, session, index, router1, router2, owner):
wlan = session.addobj(cls=pycore.nodes.WlanNode,
name='twlan%d' % index)
r1_pos = router1.position.get()
r2_pos = router2.position.get()
wlan_x = (r1_pos[0] + r2_pos[0]) / 2
wlan_y = (r1_pos[1] + r2_pos[1]) / 2
wlan.setposition(x=wlan_x, y=wlan_y)
values = list(BasicRangeModel.getdefaultvalues())
values[0] = str(WLAN_RANGE)
wlan.setmodel(BasicRangeModel, values)
owner.twlans.append(wlan)
router1.newnetif(wlan,
['%d.%d.9.1/24' % (self.batallion_index, index)])
router2.newnetif(wlan,
['%d.%d.9.2/24' % (self.batallion_index, index)])
def test_wlan_basic_range_bad(self, core):
"""
Test basic wlan network with leveraging basic range model.
:param conftest.Core core: core fixture to test with
"""
# create wlan
wlan_node = core.session.add_object(cls=nodes.WlanNode)
values = BasicRangeModel.getdefaultvalues()
wlan_node.setmodel(BasicRangeModel, values)
# create nodes
core.create_node("n1",
position=(0, 0),
services=EMANE_SERVICES,
model="mdr")
core.create_node("n2",
position=(0, 0),
services=EMANE_SERVICES,
model="mdr")
# add interfaces
interface_one = core.add_interface(wlan_node, "n1")
interface_two = core.add_interface(wlan_node, "n2")
# link nodes in wlan
core.link(wlan_node, interface_one, interface_two)
# move nodes out of range, default range check is 275
core.get_node("n1").setposition(0, 0)
core.get_node("n2").setposition(500, 500)
# instantiate session
core.session.instantiate()
# assert node directories created
core.assert_nodes()
# ping n2 from n1 and assert failure )
time.sleep(3)
status = core.ping("n1", "n2")
assert status
def test(numnodes):
# node list
n = []
prefix = ipaddr.IPv4Prefix("10.83.0.0/16")
session = pycore.Session(persistent = True)
wlanid = numnodes + 1
net = session.addobj(cls = pycore.nodes.WlanNode, name = "wlan%d" % wlanid,
objid = wlanid, verbose = True)
net.setmodel(BasicRangeModel, BasicRangeModel.getdefaultvalues())
for i in range(1, 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)
n[0].term("bash")
# wait for rate seconds to allow ebtables commands to commit
time.sleep(EbtablesQueue.rate)
def test(options):
prefix = ipaddress.Ipv4Prefix("10.83.0.0/16")
session = Session(1, persistent=True)
if options.enablesdt:
# GUI default
session.location.setrefgeo(47.57917, -122.13232, 50.0)
session.location.refscale = 100.0
session.options.enablesdt = True
session.options.sdturl = options.sdturl
wlanid = options.numnodes + 1
net = session.add_object(cls=WlanNode,
name="wlan%d" % wlanid,
objid=wlanid)
values = list(BasicRangeModel.getdefaultvalues())
# values[0] = 5000000 # 5000km range
net.setmodel(BasicRangeModel, values)
for i in xrange(1, options.numnodes + 1):
node = session.add_object(cls=LxcNode, name="n%d" % i, objid=i)
address = "%s/%s" % (prefix.addr(i), prefix.prefixlen)
print "setting node address: %s - %s" % (node.objid, address)
node.newnetif(net, [address])
# set increasing Z coordinates
node.setposition(10, 10, 100)
n.append(node)
# example setting node n2 to a high altitude
# n[1].setposition(10, 10, 2000000) # 2000km
# session.sdt.updatenode(n[1].objid, 0, 10, 10, 2000000)
# launches terminal for the first node
# n[0].term("bash")
n[0].icmd(["ping", "-c", "5", "127.0.0.1"])
# wait for rate seconds to allow ebtables commands to commit
time.sleep(EbtablesQueue.rate)
raw_input("press enter to exit")
session.shutdown()
def __init__(self, session, pos, batallion_index, company_index):
self.platoons = [None]
self.hosts = [None]
self.batallion_index = batallion_index
self.company_index = company_index
self.twlans = []
p_verts = ngon_verts(PLATOONS_IN_COMPANY, MAX_P_DISPL / 2)
P_LOCATIONS = [(pos[0] + p_verts[i][0], pos[1] + p_verts[i][1], 0)
for i in xrange(PLATOONS_IN_COMPANY)]
r_verts = ngon_verts(COMPANIES_IN_BATALLION * 2, MAX_P_DISPL / 10)
self.wlan = session.addobj(cls=pycore.nodes.WlanNode,
name='uwlan%d' % company_index)
self.wlan.setposition(x=pos[0], y=pos[1])
values = list(BasicRangeModel.getdefaultvalues())
values[0] = str(WLAN_RANGE)
self.wlan.setmodel(BasicRangeModel, values)
self.routers = [None]
for i in xrange(COMPANIES_IN_BATALLION * 2):
r_index = (self.company_index - 1) * \
(COMPANIES_IN_BATALLION * 2) + 1 + i
router = session.addobj(cls=pycore.nodes.CoreNode,
name='r%d' % r_index)
router.setposition(x=pos[0] + r_verts[i][0],
y=pos[1] + r_verts[i][1])
session.services.addservicestonode(router, 'router', None, False)
index = HOSTS_IN_PLATOON * PLATOONS_IN_COMPANY + 1 + i
router.newnetif(self.wlan, [
'%d.%d.1.%d/24' %
(self.batallion_index, self.company_index, index)
])
self.routers.append(router)
for i in xrange(PLATOONS_IN_COMPANY):
self.connect_platoon(session, P_LOCATIONS[i])
def test_wlan_basic_range_good(self, core):
"""
Test basic wlan network.
:param conftest.Core core: core fixture to test with
"""
# create wlan
wlan_node = core.session.add_object(cls=nodes.WlanNode)
values = BasicRangeModel.getdefaultvalues()
wlan_node.setmodel(BasicRangeModel, values)
# create nodes
core.create_node("n1",
position=(0, 0),
services=EMANE_SERVICES,
model="mdr")
core.create_node("n2",
position=(0, 0),
services=EMANE_SERVICES,
model="mdr")
# add interfaces
interface_one = core.add_interface(wlan_node, "n1")
interface_two = core.add_interface(wlan_node, "n2")
# link nodes in wlan
core.link(wlan_node, interface_one, interface_two)
# instantiate session
core.session.instantiate()
# assert node directories created
core.assert_nodes()
# ping n2 from n1 and assert success
status = core.ping("n1", "n2")
assert not status
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
