def example(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(_type=NodeTypes.SWITCH)
# create nodes
for _ in range(args.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.id, switch.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes to run example
first_node = session.get_node(2)
last_node = session.get_node(args.nodes + 1)
first_node_address = prefixes.ip4_address(first_node)
logging.info("node %s pinging %s", last_node.name, first_node_address)
output = last_node.cmd(f"ping -c {args.count} {first_node_address}")
logging.info(output)
# shutdown session
coreemu.shutdown()
def ping(from_node: CoreNode, to_node: CoreNode, ip_prefixes: IpPrefixes):
address = ip_prefixes.ip4_address(to_node.id)
try:
from_node.cmd(f"ping -c 1 {address}")
status = 0
except CoreCommandError as e:
status = e.returncode
return status
def main():
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create emane network node, emane determines connectivity based on
# location, so the session and nodes must be configured to provide one
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions()
options.set_position(80, 50)
emane_network = session.add_node(_type=NodeTypes.EMANE,
options=options,
_id=100)
session.emane.set_model(emane_network, EmaneIeee80211abgModel)
# create nodes
options = NodeOptions(model="mdr")
for i in range(NODES):
node = session.add_node(options=options)
node.setposition(x=150 * (i + 1), y=150)
interface = prefixes.create_interface(node)
session.add_link(node.id, emane_network.id, interface_one=interface)
# instantiate session
session.instantiate()
# OSPF MDR requires some time for routes to be created
logging.info("waiting %s seconds for OSPF MDR to create routes",
EMANE_DELAY)
time.sleep(EMANE_DELAY)
# get nodes to run example
first_node = session.get_node(1)
last_node = session.get_node(NODES)
address = prefixes.ip4_address(first_node)
logging.info("node %s pinging %s", last_node.name, address)
output = last_node.cmd(f"ping -c 3 {address}")
logging.info(output)
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.set_wireless_model(wlan, BasicRangeModel)
# create nodes
wireless_nodes = []
for _ in xrange(options.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.objid, wlan.objid, interface_one=interface)
wireless_nodes.append(node)
# link all created nodes with the wireless network
session.wireless_link_all(wlan, wireless_nodes)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_object(2)
last_node = session.get_object(options.nodes + 1)
print "starting iperf server on node: %s" % first_node.name
first_node.cmd(["iperf", "-s", "-D"])
address = prefixes.ip4_address(first_node)
print "node %s connecting to %s" % (last_node.name, address)
last_node.client.icmd(["iperf", "-t", str(options.time), "-c", address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes
wireless_nodes = []
for _ in xrange(options.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.objid, wlan.objid, interface_one=interface)
wireless_nodes.append(node)
# link all created nodes with the wireless network
session.wireless_link_all(wlan, wireless_nodes)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_object(2)
last_node = session.get_object(options.nodes + 1)
print "starting iperf server on node: %s" % first_node.name
first_node.cmd(["iperf", "-s", "-D"])
address = prefixes.ip4_address(first_node)
print "node %s connecting to %s" % (last_node.name, address)
last_node.client.icmd(["iperf", "-t", str(options.time), "-c", address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def example(args):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes, must set a position for wlan basic range model
options = NodeOptions(model="mdr")
options.set_position(0, 0)
for _ in range(args.nodes):
node = session.add_node(options=options)
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_node(2)
last_node = session.get_node(args.nodes + 1)
logging.info("starting iperf server on node: %s", first_node.name)
first_node.cmd("iperf -s -D")
address = prefixes.ip4_address(first_node)
logging.info("node %s connecting to %s", last_node.name, address)
output = last_node.cmd(f"iperf -t {args.time} -c {address}")
logging.info(output)
first_node.cmd("killall -9 iperf")
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes, must set a position for wlan basic range model
node_options = NodeOptions()
node_options.set_position(0, 0)
for _ in range(options.nodes):
node = session.add_node(node_options=node_options)
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_node(2)
last_node = session.get_node(options.nodes + 1)
print("starting iperf server on node: %s" % first_node.name)
first_node.cmd(["iperf", "-s", "-D"])
address = prefixes.ip4_address(first_node)
print("node %s connecting to %s" % (last_node.name, address))
last_node.client.icmd(["iperf", "-t", str(options.time), "-c", address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(_type=NodeTypes.SWITCH)
# create nodes
for _ in range(options.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.id, switch.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes to run example
first_node = session.get_node(2)
last_node = session.get_node(options.nodes + 1)
print("starting iperf server on node: %s" % first_node.name)
first_node.cmd(["iperf", "-s", "-D"])
first_node_address = prefixes.ip4_address(first_node)
print("node %s connecting to %s" % (last_node.name, first_node_address))
last_node.client.icmd(
["iperf", "-t",
str(options.time), "-c", first_node_address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def main():
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(WlanNode, _id=100)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes, must set a position for wlan basic range model
options = NodeOptions(model="mdr")
options.set_position(0, 0)
for _ in range(NODES):
node = session.add_node(CoreNode, options=options)
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_node(1, CoreNode)
last_node = session.get_node(NODES, CoreNode)
address = prefixes.ip4_address(first_node)
logging.info("node %s pinging %s", last_node.name, address)
output = last_node.cmd(f"ping -c 3 {address}")
logging.info(output)
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(_type=NodeTypes.SWITCH)
# create nodes
for _ in xrange(options.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.objid, switch.objid, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes to run example
first_node = session.get_object(2)
last_node = session.get_object(options.nodes + 1)
print "starting iperf server on node: %s" % first_node.name
first_node.cmd(["iperf", "-s", "-D"])
first_node_address = prefixes.ip4_address(first_node)
print "node %s connecting to %s" % (last_node.name, first_node_address)
last_node.client.icmd(["iperf", "-t", str(options.time), "-c", first_node_address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
class Env():
def __init__(self, env_config, silent=True):
if not silent:
load_logging_config()
self.envParser = EnvParser(env_config)
if self.envParser.ip4_prefix:
self.prefix = IpPrefixes(ip4_prefix=self.envParser.ip4_prefix)
else:
self.prefix = IpPrefixes(ip6_prefix=self.envParser.ip6_prefix)
self.nodes = {} # pc nodes
self.networks = [] # switches nodes
# create emulator instance for creating sessions and utility methods
self.coreemu = CoreEmu()
self.session = self.coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
self.session.set_state(EventTypes.CONFIGURATION_STATE)
# create nodes
for node in self.envParser.nodes:
self.nodes[int(node["id"])] = {"obj": self.session.add_node(_type=NodeTypes.DEFAULT), "nets": [],
"ip": None, "curr_net": None}
# create networks
for net in self.envParser.networks:
self.networks.append(self.session.add_node(_type=NodeTypes.SWITCH))
for node in net["nodes"]:
interface = self.prefix.create_interface(self.nodes[node["id"]]["obj"],
name=self.envParser.dev_prefix + str(net["id"]))
self.nodes[node["id"]]["ip"] = self.prefix.ip4_address(self.nodes[node["id"]]["obj"])
self.session.add_link(self.nodes[node["id"]]["obj"].id, self.networks[-1].id, interface_one=interface)
self.nodes[node["id"]]["nets"].append({
"net": net["id"]
})
# certs
shutil.rmtree('certs', True)
self.__create_root_ca()
for node in self.nodes:
self.__create_node_cert(node)
# instantiate session
self.start()
def get_node_ip(self, node):
return self.nodes[node]["ip"]
def run_command(self, node, command, wait=True):
print(*command)
self.nodes[node]["obj"].client.cmd(command, wait)
def run_icommand(self, node, command):
self.nodes[node]["obj"].client.icmd(command)
def run_terminal(self, node):
self.nodes[node]["obj"].client.term()
def change_net(self, node, net):
self.nodes[node]["obj"].cmd(
["ip", 'l', 'set', self.envParser.dev_prefix + str(self.nodes[node]['curr_net']), 'down'])
self.nodes[node]["obj"].cmd(["ip", 'l', 'set', self.envParser.dev_prefix + str(net), 'up'])
self.nodes[node]["curr_net"] = net
'''options:
delay TIME [ JITTER [CORRELATION]] [distribution {uniform|normal|pareto|paretonormal} ]
corrupt PERCENT [CORRELATION]
duplicate PERCENT [CORRELATION]
loss random PERCENT [CORRELATION]
loss state P13 [P31 [P32 [P23 P14]]
loss gemodel PERCENT [R [1-H [1-K]]
reorder PRECENT [CORRELATION] [ gap DISTANCE ]
'''
def add_net_params(self, nodes, net, params):
for node in nodes:
for param in params:
self.nodes[node]["obj"].client.cmd(
["tc", 'qdisc', 'add', 'dev', self.envParser.dev_prefix + str(net), 'root', 'netem', param] +
params[param])
return
'''
Use add on first setting a params, later use set
'''
def set_net_params(self, nodes, net, params):
for node in nodes:
for param in params:
self.nodes[node]["obj"].cmd(
["tc", 'qdisc', 'change', 'dev', self.envParser.dev_prefix + str(net), 'root', 'netem', param] +
params[param])
return
def start(self):
self.session.instantiate()
for node in self.nodes.values():
for net in node['nets']:
node["obj"].cmd(["ip", 'l', 'set', self.envParser.dev_prefix + str(net['net']), 'down'])
node["obj"].cmd(["ip", 'l', 'set', self.envParser.dev_prefix + str(node['nets'][0]['net']), 'up'])
node['curr_net'] = node['nets'][0]['net']
def finish(self):
# remove certs
shutil.rmtree('certs')
# shutdown session
self.coreemu.shutdown()
# XXX: every cert's related things are store in "certs" directory just for now
def __create_root_ca(self):
try:
os.mkdir('certs')
except FileExistsError:
pass
os.system("openssl genrsa -out certs/rootCA.key 4096")
os.system(
"openssl req -x509 -new -nodes -key certs/rootCA.key -sha256 -days 1024 -subj \"/C=PL/ST=CA/O=DTN_TEST_ENV, Inc./CN=ROOT_CA\" -out certs/rootCA.crt")
def __create_node_cert(self, nodeId):
os.system("openssl genrsa -out certs/node" + str(nodeId) + ".key 2048")
os.system("openssl req -new -sha256 -key certs/node" + str(
nodeId) + ".key -subj \"/C=PL/ST=CA/O=DTN_TEST_ENV, Inc./CN=node" + str(
nodeId) + "\" -out certs/node" + str(nodeId) + ".csr")
os.system("openssl x509 -req -in certs/node" + str(
nodeId) + ".csr -CA certs/rootCA.crt -CAkey certs/rootCA.key -CAcreateserial -out certs/node" + str(
nodeId) + ".crt -days 500 -sha256")