From: Alina Quereilhac Date: Tue, 29 Nov 2011 14:18:28 +0000 (+0100) Subject: updating experimenbt examples X-Git-Tag: nepi-3.0.0~163^2~46 X-Git-Url: http://git.onelab.eu/?a=commitdiff_plain;h=18c1089fea6ae8f44093f3d1b9a408c0eae96ef9;p=nepi.git updating experimenbt examples --- diff --git a/examples/daemonized_testbed_controller.py b/examples/daemonized_testbed_controller.py new file mode 100644 index 00000000..2110d709 --- /dev/null +++ b/examples/daemonized_testbed_controller.py @@ -0,0 +1,85 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Experiment Topology: +# +# n1 --- n2 +# 0.1 0.2 +# + +from nepi.core.design import ExperimentDescription, FactoriesProvider +from nepi.core.execute import ExperimentController +from nepi.util import proxy +from nepi.util.constants import DeploymentConfiguration as DC +import getpass +import tempfile +import time +import os + +user = getpass.getuser() +root_dir = tempfile.mkdtemp() +netns_dir = os.path.join(root_dir, "netns") +daemon_dir = os.path.join(netns_dir, "daemon") +os.makedirs(daemon_dir) + + +exp_desc = ExperimentDescription() + +netns_provider = FactoriesProvider("netns") +netns_desc = exp_desc.add_testbed_description(netns_provider) +netns_desc.set_attribute_value("homeDirectory", netns_dir) +#netns_desc.set_attribute_value("enableDebug", True) +netns_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) +netns_desc.set_attribute_value(DC.ROOT_DIRECTORY, daemon_dir) +netns_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) +netns_desc.set_attribute_value(DC.USE_SUDO, True) + +node1 = netns_desc.create("Node") +node2 = netns_desc.create("Node") + +iface12 = netns_desc.create("P2PNodeInterface") +iface12.set_attribute_value("up", True) +node1.connector("devs").connect(iface12.connector("node")) + +iface21 = netns_desc.create("P2PNodeInterface") +iface21.set_attribute_value("up", True) +node2.connector("devs").connect(iface21.connector("node")) + +iface12.connector("p2p").connect(iface21.connector("p2p")) + +ip12 = iface12.add_address() +ip12.set_attribute_value("Address", "192.168.0.1") +ip12.set_attribute_value("NetPrefix", 30) + +ip21 = iface21.add_address() +ip21.set_attribute_value("Address", "192.168.0.2") +ip21.set_attribute_value("NetPrefix", 30) + +app1 = netns_desc.create("Application") +app1.set_attribute_value("command", "ping -qc 10 192.168.0.1") +app1.set_attribute_value("user", user) +app1.connector("node").connect(node1.connector("apps")) + +app1.enable_trace("stdout") + +xml = exp_desc.to_xml() + +controller_access_config = proxy.AccessConfiguration() +controller_access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) +controller_access_config.set_attribute_value(DC.ROOT_DIRECTORY, root_dir) +controller_access_config.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) + +controller = proxy.create_experiment_controller(xml, controller_access_config) + +controller.start() +while not controller.is_finished(app1.guid): + time.sleep(0.5) + +result = controller.trace(app1.guid, "stdout") + +controller.stop() +controller.shutdown() + +print result + diff --git a/examples/fd_cross_testbed_experiment.py b/examples/fd_cross_testbed_experiment.py new file mode 100644 index 00000000..15c219fa --- /dev/null +++ b/examples/fd_cross_testbed_experiment.py @@ -0,0 +1,136 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Experiment Topology: +# +# ns-3 | NETNS +# | + +# fd +# n1 --- n2 ----- n3 --- n4 +# +# 0.0 1.0 2.0 + + +from nepi.core.design import ExperimentDescription, FactoriesProvider +from nepi.core.execute import ExperimentController +import getpass +import tempfile +import time + +user = getpass.getuser() +root_dir = tempfile.mkdtemp() + +def create_ns3_node(ns3_desc): + node = ns3_desc.create("ns3::Node") + ipv4 = ns3_desc.create("ns3::Ipv4L3Protocol") + arp = ns3_desc.create("ns3::ArpL3Protocol") + icmp = ns3_desc.create("ns3::Icmpv4L4Protocol") + udp = ns3_desc.create("ns3::UdpL4Protocol") + node.connector("protos").connect(ipv4.connector("node")) + node.connector("protos").connect(arp.connector("node")) + node.connector("protos").connect(icmp.connector("node")) + node.connector("protos").connect(udp.connector("node")) + return node + +exp_desc = ExperimentDescription() + +ns3_provider = FactoriesProvider("ns3") +ns3_desc = exp_desc.add_testbed_description(ns3_provider) +ns3_desc.set_attribute_value("homeDirectory", root_dir) +ns3_desc.set_attribute_value("SimulatorImplementationType", "ns3::RealtimeSimulatorImpl") +ns3_desc.set_attribute_value("ChecksumEnabled", True) + +node1 = create_ns3_node(ns3_desc) +iface12 = ns3_desc.create("ns3::PointToPointNetDevice") +queue12 = ns3_desc.create("ns3::DropTailQueue") +node1.connector("devs").connect(iface12.connector("node")) +iface12.connector("queue").connect(queue12.connector("dev")) +ip12 = iface12.add_address() +ip12.set_attribute_value("Address", "10.0.0.1") + +node2 = create_ns3_node(ns3_desc) +iface21 = ns3_desc.create("ns3::PointToPointNetDevice") +queue21 = ns3_desc.create("ns3::DropTailQueue") +node2.connector("devs").connect(iface21.connector("node")) +iface21.connector("queue").connect(queue21.connector("dev")) +ip21 = iface21.add_address() +ip21.set_attribute_value("Address", "10.0.0.2") + +chan = ns3_desc.create("ns3::PointToPointChannel") +iface12.connector("chan").connect(chan.connector("dev2")) +iface21.connector("chan").connect(chan.connector("dev2")) + +iface23 = ns3_desc.create("ns3::FdNetDevice") +node2.connector("devs").connect(iface23.connector("node")) +ip23 = iface23.add_address() +ip23.set_attribute_value("Address", "10.0.1.1") + +netns_provider = FactoriesProvider("netns") +netns_desc = exp_desc.add_testbed_description(netns_provider) +netns_desc.set_attribute_value("homeDirectory", root_dir) +#netns_desc.set_attribute_value("enableDebug", True) + +node3 = netns_desc.create("Node") +iface32 = netns_desc.create("TapNodeInterface") +iface32.set_attribute_value("up", True) +node3.connector("devs").connect(iface32.connector("node")) +ip32 = iface32.add_address() +ip32.set_attribute_value("Address", "10.0.1.2") + +iface23.connector("->fd").connect(iface32.connector("fd->")) + +iface34 = netns_desc.create("P2PNodeInterface") +iface34.set_attribute_value("up", True) +node3.connector("devs").connect(iface34.connector("node")) +ip34 = iface34.add_address() +ip34.set_attribute_value("Address", "10.0.2.1") + +node4 = netns_desc.create("Node") +node4.set_attribute_value("forward_X11", True) +iface43 = netns_desc.create("P2PNodeInterface") +iface43.set_attribute_value("up", True) +node4.connector("devs").connect(iface43.connector("node")) +ip43 = iface43.add_address() +ip43.set_attribute_value("Address", "10.0.2.2") + +iface34.connector("p2p").connect(iface43.connector("p2p")) + +route = node1.add_route() +route.set_attribute_value("Destination", "10.0.2.0") +route.set_attribute_value("NextHop", "10.0.0.2") + +route = node2.add_route() +route.set_attribute_value("Destination", "10.0.2.0") +route.set_attribute_value("NextHop", "10.0.1.2") + +route = node3.add_route() +route.set_attribute_value("Destination", "10.0.0.0") +route.set_attribute_value("NextHop", "10.0.1.1") + +route = node4.add_route() +route.set_attribute_value("Destination", "10.0.0.0") +route.set_attribute_value("NextHop", "10.0.2.1") + +app = netns_desc.create("Application") +app.set_attribute_value("command", "ping -qc 3 10.0.0.1") +app.set_attribute_value("user", user) +app.connector("node").connect(node4.connector("apps")) +app.enable_trace("stdout") + +xml = exp_desc.to_xml() + +controller = ExperimentController(xml, root_dir) + +controller.start() +while not controller.is_finished(app.guid): + time.sleep(0.5) + +result = controller.trace(app.guid, "stdout") + +controller.stop() +controller.shutdown() + +print result + diff --git a/examples/multicast_overlay.py b/examples/multicast_overlay.py deleted file mode 100755 index 6dcf4907..00000000 --- a/examples/multicast_overlay.py +++ /dev/null @@ -1,666 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -import getpass -from optparse import OptionParser -import os -import sys -import shutil -import tempfile -import time -import struct -import socket -import operator -import ipaddr -import gzip -import random -import math - -sys.path.append("../../src") - -from nepi.core.design import ExperimentDescription, FactoriesProvider -from nepi.core.execute import ExperimentController -from nepi.util import proxy -from nepi.util.constants import DeploymentConfiguration as DC, ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP -from nepi.testbeds.planetlab import util as plutil - -class PlanetLabMulticastOverlay: - testbed_id = "planetlab" - slicename = "inria_nepi12" - plchost = "www.planet-lab.eu" - plkey = os.environ.get( - "PL_SSH_KEY", - "%s/.ssh/id_rsa_planetlab" % (os.environ['HOME'],) ) - pluser = os.environ.get("PL_USER") - plpass = os.environ.get("PL_PASS") - vnet = "192.168.2.0" - - port_base = 2000 + (os.getpid() % 1000) * 13 - - def setUp(self): - self.root_dir = tempfile.mkdtemp() - self.__class__.port_base = self.__class__.port_base + 100 - - def tearDown(self): - try: - shutil.rmtree(self.root_dir) - except: - # retry - time.sleep(0.1) - shutil.rmtree(self.root_dir) - - def make_experiment_desc(self): - testbed_id = self.testbed_id - slicename = self.slicename - plchost = self.plchost - pl_ssh_key = self.plkey - pl_user = self.pluser - pl_pwd = self.plpass - - exp_desc = ExperimentDescription() - pl_provider = FactoriesProvider(testbed_id) - pl_desc = exp_desc.add_testbed_description(pl_provider) - pl_desc.set_attribute_value("homeDirectory", self.root_dir) - pl_desc.set_attribute_value("slice", slicename) - pl_desc.set_attribute_value("sliceSSHKey", pl_ssh_key) - pl_desc.set_attribute_value("authUser", pl_user) - pl_desc.set_attribute_value("authPass", pl_pwd) - pl_desc.set_attribute_value("plcHost", plchost) - pl_desc.set_attribute_value("tapPortBase", self.port_base) - pl_desc.set_attribute_value("p2pDeployment", True) - pl_desc.set_attribute_value("dedicatedSlice", True) - pl_desc.set_attribute_value("plLogLevel", "INFO") - - netns_provider = FactoriesProvider("netns") - netns = exp_desc.add_testbed_description(netns_provider) - netns.set_attribute_value("homeDirectory", self.root_dir) - netns.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) - netns_root_dir = os.path.join(self.root_dir, "netns") - os.mkdir(netns_root_dir) - netns.set_attribute_value(DC.ROOT_DIRECTORY, netns_root_dir) - netns.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) - netns.set_attribute_value(DC.USE_SUDO, True) - - return pl_desc, netns, exp_desc - - def make_pl_tapnode(self, pl, ip, inet = None, label = None, hostname = None, routes = None, mcast = False, mcastrouter = False): - if not isinstance(ip, list): - ips = [ip] - else: - ips = ip - node1 = pl.create("Node") - if label: - node1.set_attribute_value("label", label) - if hostname: - node1.set_attribute_value("hostname", hostname) - iface1 = pl.create("NodeInterface") - if label: - iface1.set_attribute_value("label", label+"iface") - tap1 = [] - tap1ip = [] - for i,ip in enumerate(ips): - _tap1 = pl.create("TapInterface") - _tap1.set_attribute_value("multicast", True) - _tap1.enable_trace("pcap") # for error output - if label: - _tap1.set_attribute_value("label", label+"tap"+(str(i+1) if i else "")) - - _tap1ip = self.add_ip_address(_tap1, ip, 32) - - node1.connector("devs").connect(_tap1.connector("node")) - - tap1.append(_tap1) - tap1ip.append(_tap1ip) - - inet = inet or pl.create("Internet") - node1.connector("devs").connect(iface1.connector("node")) - iface1.connector("inet").connect(inet.connector("devs")) - - for destip, destprefix, nexthop in routes: - r1 = self.add_route(node1, destip, destprefix, nexthop) - - if mcast: - fwd = pl.create("MulticastForwarder") - fwd.enable_trace("stderr") - fwd.connector("node").connect(node1.connector("apps")) - if mcastrouter: - mrt = pl.create("MulticastRouter") - mrt.connector("fwd").connect(fwd.connector("router")) - mrt.enable_trace("stderr") - - return node1, iface1, tap1, tap1ip, inet - - def add_ip_address(self, iface, address, netprefix, broadcast = False): - ip = iface.add_address() - ip.set_attribute_value("Address", address) - ip.set_attribute_value("NetPrefix", netprefix) - ip.set_attribute_value("Broadcast", broadcast) - return ip - - def add_route(self, node, destination, netprefix, nexthop): - route = node.add_route() - route.set_attribute_value("Destination", destination) - route.set_attribute_value("NetPrefix", netprefix) - route.set_attribute_value("NextHop", nexthop) - return route - - def add_vlc_base(self, pl, node): - app = pl.create("Application") - app.set_attribute_value("rpmFusion", True) - app.set_attribute_value("depends", "vlc") - app.set_attribute_value("command", "vlc --version") - app.enable_trace("stdout") - app.enable_trace("stderr") - node.connector("apps").connect(app.connector("node")) - return app - - def add_vlc_restreamer(self, pl, node): - hostname = node.get_attribute_value("hostname") - app = self.add_vlc_base(pl, node) - app.set_attribute_value("label","vlc_restreamer_%d" % (node.guid,)) - app.set_attribute_value("command", - "vlc -vvv -I dummy" - " udp://@239.255.12.42" - " --sout '#rtp{port=6060,sdp=rtsp://"+hostname+":8080/test.sdp}'") - return app - - def add_vlc_dumper(self, pl, node): - app = self.add_vlc_base(pl, node) - app.set_attribute_value("label","vlc_dumper_%d" % (node.guid,)) - app.set_attribute_value("command", - "vlc -vvv -I dummy" - " udp://@239.255.12.42" - " --sout output") - app.enable_trace("output") - return app - - def add_vlc_source(self, netns, node, iflabel): - app = netns.create("Application") - app.set_attribute_value("user", self.user) - app.set_attribute_value("label","vlc_source_%d" % (node.guid,)) - app.set_attribute_value("command", - "vlc -vvv -I dummy " - +os.path.basename(self.movie_source) - +"--miface-addr {#[%s].addr[0].[Address]#} " % (iflabel,) - +"--sout '#udp{dst=239.255.12.42,ttl=64}'") - app.connector("node").connect(node.connector("apps")) - return app - - def add_net_monitor(self, pl, node): - app = pl.create("Application") - app.set_attribute_value("label","network_monitor_%d" % (node.guid,)) - app.set_attribute_value("command", - r"""head -n 2 /proc/net/dev ; while true ; do cat /proc/net/dev | sed -r 's/.*/'"$(date -R)"': \0/' | grep eth0 ; sleep 1 ; done""") - app.enable_trace("stdout") - node.connector("apps").connect(app.connector("node")) - return app - - def make_ns_in_pl(self, pl, exp, node1, iface1, root): - ns3_testbed_id = "ns3" - - # Add NS3 support in node1 - plnepi = pl.create("NepiDependency") - plns3 = pl.create("NS3Dependency") - plnepi.connector("node").connect(node1.connector("deps")) - plns3.connector("node").connect(node1.connector("deps")) - - # Create NS3 testbed running in node1 - ns3_provider = FactoriesProvider(ns3_testbed_id) - ns = exp.add_testbed_description(ns3_provider) - ns.set_attribute_value("rootDirectory", root) - ns.set_attribute_value("SimulatorImplementationType", "ns3::RealtimeSimulatorImpl") - ns.set_attribute_value("ChecksumEnabled", True) - ns.set_attribute_value(DC.DEPLOYMENT_HOST, "{#[%s].addr[0].[Address]#}" % ( - iface1.get_attribute_value("label"),)) - ns.set_attribute_value(DC.DEPLOYMENT_USER, - pl.get_attribute_value("slice")) - ns.set_attribute_value(DC.DEPLOYMENT_KEY, - pl.get_attribute_value("sliceSSHKey")) - ns.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) - ns.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH) - ns.set_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP, - "{#[%s].[%s]#}" % ( - node1.get_attribute_value("label"), - ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP,)) - ns.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) - - return ns - - def add_pl_ns_node(self, pl_desc, inet, label_prefix): - node = pl_desc.create("Node") - node.set_attribute_value("label", label_prefix) - iface = pl_desc.create("NodeInterface") - iface.set_attribute_value("label", label_prefix+"iface") - iface.connector("inet").connect(inet.connector("devs")) - node.connector("devs").connect(iface.connector("node")) - forwarder = pl_desc.create("MulticastForwarder") - forwarder.enable_trace("stderr") - node.connector("apps").connect(forwarder.connector("node")) - return node, iface - - def add_pl_ns_connection(self, pl_desc, pl_node, pl_addr, - ns, ns_node, ns_addr): - pl_tap = pl_desc.create("TapInterface") - pl_tap.set_attribute_value("tun_cipher", "PLAIN") - self.add_ip_address(pl_tap, pl_addr, 31) - pl_node.connector("devs").connect(pl_tap.connector("node")) - ns_fdnd = ns.create("ns3::FdNetDevice") - ns_node.connector("devs").connect(ns_fdnd.connector("node")) - self.add_ip_address(ns_fdnd, ns_addr, 31) - pl_tap.connector("fd->").connect(ns_fdnd.connector("->fd")) - - def add_pl_ns_tunchan_connection(self, pl_desc, pl_node, pl_addr, - ns, ns_node, ns_addr): - pl_tap = pl_desc.create("TunInterface") - self.add_ip_address(pl_tap, pl_addr, 31) - pl_node.connector("devs").connect(pl_tap.connector("node")) - ns_fdnd = ns.create("ns3::FdNetDevice") - ns_fdnd.enable_trace("FdPcapTrace") - self.add_ip_address(ns_fdnd, ns_addr, 31) - ns_node.connector("devs").connect(ns_fdnd.connector("node")) - ns_tc = ns.create("ns3::Nepi::TunChannel") - ns_tc.connector("fd->").connect(ns_fdnd.connector("->fd")) - pl_tap.connector("tcp").connect(ns_tc.connector("tcp")) - - def make_netns_node(self, netns): - node = netns.create("Node") - node.set_attribute_value("forward_X11", True) - command = "xterm" - app = netns.create("Application") - app.set_attribute_value("command", command) - app.set_attribute_value("user", self.user) - app.connector("node").connect(node.connector("apps")) - return node - - def make_pl_netns_connection(self, pl_desc, pl_node, netns, - netns_node, netns_iface_label): - base=struct.unpack('!L',socket.inet_aton(self.vnet))[0] - netns_addr = socket.inet_ntoa(struct.pack('!L',(base | 1))) - pl_addr = socket.inet_ntoa(struct.pack('!L',(base | 2))) - pl_tap = pl_desc.create("TunInterface") - pl_tap.set_attribute_value("multicast", True) - #pl_tap.set_attribute_value("tun_cipher", "PLAIN") - #pl_tap.enable_trace("pcap") - #pl_tap.enable_trace("packets") - self.add_ip_address(pl_tap, pl_addr, 31) - pl_node.connector("devs").connect(pl_tap.connector("node")) - - netns_tap = netns.create("TunNodeInterface") - netns_tap.set_attribute_value("label", netns_iface_label) - netns_tap.set_attribute_value("up", True) - netns_tap.set_attribute_value("mtu", 1448) - self.add_ip_address(netns_tap, netns_addr, 31) - self.add_route(netns_node, self.vnet, 24, pl_addr) - netns_node.connector("devs").connect(netns_tap.connector("node")) - - netns_tunchannel = netns.create("TunChannel") - #netns_tunchannel.set_attribute_value("tun_cipher", "PLAIN") - netns_tunchannel.connector("->fd").connect(netns_tap.connector("fd->")) - pl_tap.connector("tcp").connect(netns_tunchannel.connector("tcp")) - - def add_ns_fdnd(self, ns, node): - fdnd = ns.create("ns3::FdNetDevice") - node.connector("devs").connect(fdnd.connector("node")) - #fdnd.enable_trace("FdPcapTrace") - return fdnd - - def add_ns_node(self, ns): - node = ns.create("ns3::Node") - ipv4 = ns.create("ns3::Ipv4L3Protocol") - arp = ns.create("ns3::ArpL3Protocol") - icmp = ns.create("ns3::Icmpv4L4Protocol") - udp = ns.create("ns3::UdpL4Protocol") - node.connector("protos").connect(ipv4.connector("node")) - node.connector("protos").connect(arp.connector("node")) - node.connector("protos").connect(icmp.connector("node")) - node.connector("protos").connect(udp.connector("node")) - return node - - def add_ns_wifi_dev(self, ns, node, access_point = False): - wifi = ns.create("ns3::WifiNetDevice") - node.connector("devs").connect(wifi.connector("node")) - - phy = ns.create("ns3::YansWifiPhy") - error = ns.create("ns3::NistErrorRateModel") - manager = ns.create("ns3::ArfWifiManager") - if access_point: - mac = ns.create("ns3::ApWifiMac") - else: - mac = ns.create("ns3::StaWifiMac") - - phy.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a") - mac.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a") - phy.connector("err").connect(error.connector("phy")) - wifi.connector("phy").connect(phy.connector("dev")) - wifi.connector("mac").connect(mac.connector("dev")) - wifi.connector("manager").connect(manager.connector("dev")) - - #phy.enable_trace("YansWifiPhyPcapTrace") - return wifi, phy - - def add_ns_constant_mobility(self, ns, node, x, y, z): - mobility = ns.create("ns3::ConstantPositionMobilityModel") - position = "%d:%d:%d" % (x, y, z) - mobility.set_attribute_value("Position", position) - node.connector("mobility").connect(mobility.connector("node")) - return mobility - - def add_ns_wifi_channel(self, ns): - channel = ns.create("ns3::YansWifiChannel") - delay = ns.create("ns3::ConstantSpeedPropagationDelayModel") - loss = ns.create("ns3::LogDistancePropagationLossModel") - channel.connector("delay").connect(delay.connector("chan")) - channel.connector("loss").connect(loss.connector("prev")) - return channel - - def make_ns_wifi(self, ns, pl, pl_ns_root, inet, numwifinodes, nextip): - base=struct.unpack('!L',socket.inet_aton(self.vnet))[0] - error = False - for i in xrange(2, 6): - nr = int(math.pow(2, i)) - if nr <= (numwifinodes + 2): - break - else: - error = True - - # how many IPs will we need? - # 1 for the AP, 2 for each station and one for each extra PL node - # BUT we need to also reserve IPs to sum up to a posible subnetwork - # number of nodes: 2, 4, 8, 16, etc ... - # And finally, we need 2 extra IPs for the PL-AP iface - - nrips = (1 + 2*numwifinodes + nr + 2) - if nrips + nextip[0] > 255: - error = True - if error: - raise RuntimeError("There are not enough IP addresses for the wireless network", ) - - netprefix = 32 - i - _nextwifiip = [254] - def nextwifiip(): - ip = socket.inet_ntoa(struct.pack('!L',(base | _nextwifiip[0]))) - _nextwifiip[0] -= 1 - return ip - - _nextnstapip = [(254 - nr -1)] - def nextnstapip(): - ip = socket.inet_ntoa(struct.pack('!L',(base | _nextnstapip[0]))) - _nextnstapip[0] -= 1 - return ip - - _nexttapip = [(254 - nr - 1 - numwifinodes)] - def nexttapip(): - ip = socket.inet_ntoa(struct.pack('!L',(base | _nexttapip[0]))) - _nexttapip[0] -= 1 - return ip - - # WIFI network - wifi_chan = self.add_ns_wifi_channel(ns) - - # AP node - ap_node = self.add_ns_node(ns) - self.add_ns_constant_mobility(ns, ap_node, 0, 0, 0) - ap_wifi, ap_phy = self.add_ns_wifi_dev(ns, ap_node, access_point = True) - ap_phy.connector("chan").connect(wifi_chan.connector("phys")) - - # connect AP to PL - _nextplip = (254 - nrips) - pl_ip = socket.inet_ntoa(struct.pack('!L',(base | _nextplip))) - print "PL IP %s" % pl_ip - _nextplip -= 1 - ns_ip = socket.inet_ntoa(struct.pack('!L',(base | _nextplip))) - print "NS IP %s" % ns_ip - self.add_pl_ns_connection(pl, pl_ns_root, pl_ip, ns, ap_node, ns_ip) - - # routes in and out ns - self.add_route(ap_node, self.vnet, 24, pl_ip) - net = 256 - nr - ip = socket.inet_ntoa(struct.pack('!L',(base | net))) - self.add_route(pl_ns_root, ip, netprefix, ns_ip) - - ap_ip = nextwifiip() - print "AP IP %s" % ap_ip - self.add_ip_address(ap_wifi, ap_ip, netprefix) - - r = 50 - # STA nodes - for i in xrange(0, numwifinodes): - stai = self.add_ns_node(ns) - angi = (360/numwifinodes)*i - xi = r*math.cos(angi) - yi = r*math.sin(angi) - self.add_ns_constant_mobility(ns, stai, xi, yi, 0) - wifi, phy = self.add_ns_wifi_dev(ns, stai, access_point = False) - phy.connector("chan").connect(wifi_chan.connector("phys")) - - wifi_ip = nextwifiip() - print "WIFI IP %s" % wifi_ip - self.add_ip_address(wifi, wifi_ip, netprefix) - self.add_route(stai, self.vnet, 24, ap_ip) - - """ - pl_nodei, pl_ifacei = self.add_pl_ns_node(pl, inet, - "node2%d_pl"%i) - - pl_addr = (self.base_addr%(net+1)) - ns3_addr = (self.base_addr%(net+2)) - self.add_pl_ns_tunchan_connection(pl_desc, pl_nodei, pl_addr, - ns, stai, ns3_addr) - self.add_route(pl_nodei, (self.base_addr%32), 27, ns3_addr) - self.add_route(pl_nodei, (self.base_addr%0), 30, ns3_addr) - self.add_route(pl_nodei, (self.base_addr%4), 30, ns3_addr) - - network = (self.base_addr%net) - self.add_route(netns_node, network, 30, (self.base_addr%2)) - self.add_route(pl_node1, network, 30, (self.base_addr%6)) - self.add_route(ap_node, network, 30, wifi_addr) - """ - - def make_pl_overlay(self, numnodes, numwifinodes): - print "make_pl_overlay ..." - ns3_testbed_id = "ns3" - - pl, netns, exp = self.make_experiment_desc() - # We'll make a distribution spanning tree using prefix matching as a distance - api = plutil.getAPI(self.pluser, self.plpass) - nodes = plutil.getNodes(api, numnodes, operatingSystem = 'f12') - root = min(nodes, key=operator.attrgetter('hostname')) - links = list(plutil.getSpanningTree(nodes, root=root)) - - for node in nodes: - node.vif_ips = set() - node.children = [] - node.childips = set() - - # Build an explicit tree - for slave, master in links: - master.children.append(slave) - - # We have to assign IPs and routes. - # The IP will be assigned sequentially, depth-first. - # This will result in rather compact routing rules - nextip = [128-numnodes] - def traverse(traverse, node, parent=None, base=struct.unpack('!L',socket.inet_aton(self.vnet))[0]): - if nextip[0] >= 254: - raise RuntimeError, "Too many IPs to assign!" - - node.vif_addr = base | (nextip[0]) - nips = 1+len(node.children) # one vif per child, plus one for the parent - nextip[0] += nips - - for i in xrange(nips): - node.vif_ips.add(node.vif_addr+i) - - if parent: - parent.childips.update(node.vif_ips) - - for i,child in enumerate(node.children): - traverse(traverse, child, node, base) - - if parent: - parent.childips.update(node.childips) - - print "traverse..." - traverse(traverse, root) - - def printtree(printtree, node, indent=''): - print indent, '-', socket.inet_ntoa(struct.pack('!L',node.vif_addr)), node.country, node.city, node.site - for child in node.children: - childips = map(ipaddr.IPAddress, child.childips) - childnets = ipaddr.collapse_address_list(childips) - cip = ipaddr.IPAddress(child.vif_addr) - for cnet in childnets: - print indent, '|- R', cnet, '->', cip - printtree(printtree, child, indent+' | ') - printtree(printtree, root) - - inet = pl.create("Internet") - - ns_chosen = [] - - def maketree(maketree, node, parent=None, parentIp=None): - routes = [] - ctaps = [] - for i,child in enumerate(node.children): - childips = map(ipaddr.IPAddress, child.childips) - childnets = ipaddr.collapse_address_list(childips) - cip = ipaddr.IPAddress(child.vif_addr) - pip = ipaddr.IPAddress(node.vif_addr+1+i) - for cnet in childnets: - routes.append((cnet.ip.exploded, cnet.prefixlen, cip.exploded)) - ctaps.append( maketree(maketree, child, node, pip) ) - - if parentIp: - routes.append((self.vnet,24,parentIp)) - - if not parent: - label = "root" - else: - label = None - if not ns_chosen and node.children: - ns_chosen.append(True) - label = "ns_root" - ips = [ ipaddr.IPAddress(node.vif_addr+i) for i in xrange(1+len(node.children)) ] - node1, iface1, tap1, tap1ip, _ = self.make_pl_tapnode(pl, ips, inet, - hostname = node.hostname, - routes = routes, - mcastrouter = bool(node.children), - mcast = True, - label = label ) - - for tap, ctap in zip(tap1[1:], ctaps): - tap.connector("udp").connect(ctap.connector("udp")) - - self.add_net_monitor(pl, node1) - self.add_vlc_restreamer(pl, node1) - if random.random() < 0.1 and parent: - self.add_vlc_dumper(pl, node1) - - return tap1[0] - - print "maketree..." - maketree(maketree, root) - - # create a netns node and connect it to the root pl node - pl_root = exp.get_element_by_label("root") - netns_source = self.make_netns_node(netns) - iflabel = "source-iface" - self.make_pl_netns_connection(pl, pl_root, netns, - netns_source, iflabel) - self.add_vlc_source(netns, netns_source, iflabel) - - # add ns wireless network - pl_ns_root = exp.get_element_by_label("ns_root") - pl_ns_root_iface = exp.get_element_by_label("ns_rootiface") - ns = self.make_ns_in_pl(pl, exp, pl_ns_root, pl_ns_root_iface, "ns3") - self.make_ns_wifi(ns, pl, pl_ns_root, inet, numwifinodes, nextip) - - xml = exp.to_xml() - test_dir = "./results" - - try: - controller = ExperimentController(xml, self.root_dir) - controller.start() - - print >>sys.stderr, "Press CTRL-C to shut down" - try: - while True: - time.sleep(10) - except KeyboardInterrupt: - pass - - # download results - for testbed_guid, guids in controller.traces_info().iteritems(): - for guid, traces in guids.iteritems(): - for name, data in traces.iteritems(): - path = data["filepath"] - - if not path: - continue - - print >>sys.stderr, "Downloading trace", path - - filepath = os.path.join(test_dir, path) - - try: - trace = controller.trace(guid, name) - except: - traceback.print_exc(file=sys.stderr) - continue - try: - if not os.path.exists(os.path.dirname(filepath)): - os.makedirs(os.path.dirname(filepath)) - except: - traceback.print_exc(file=sys.stderr) - - try: - if len(trace) >= 2**20: - # Bigger than 1M, compress - tracefile = gzip.GzipFile(filepath+".gz", "wb") - else: - tracefile = open(filepath,"wb") - try: - tracefile.write(trace) - finally: - tracefile.close() - except: - traceback.print_exc(file=sys.stderr) - finally: - try: - controller.stop() - except: - import traceback - traceback.print_exc() - try: - controller.shutdown() - except: - import traceback - traceback.print_exc() - - -if __name__ == '__main__': - usage = "usage: %prog -n number_sta -m movie -u user" - parser = OptionParser(usage=usage) - parser.add_option("-u", "--user", dest="user", help="Valid linux system user (not root).", type="str", default=os.getlogin()) - parser.add_option("-m", "--movie", dest="movie", help="Path to movie file to play", type="str") - parser.add_option("-n", "--nsta", dest="nsta", help="Number of wifi stations", type="int") - parser.add_option("-N", "--nodes", dest="nsta", help="Number of overlay nodes", type="int") - parser.add_option("-a", "--base_addr", dest="base_addr", help="Base address segment for the experiment", type="str") - parser.add_option("-s", "--slicename", dest="slicename", help="PlanetLab slice", type="str") - (options, args) = parser.parse_args() - if not options.movie: - parser.error("Missing 'movie' option.") - if options.user == 'root': - parser.error("Missing or invalid 'user' option.") - if options.nsta and options.nsta > 8: - parser.error("Try a number of stations under 9.") - - exp = PlanetLabMulticastOverlay() - exp.movie_source = options.movie - exp.user = options.user - try: - exp.setUp() - exp.make_pl_overlay(5, 2) - finally: - exp.tearDown() - diff --git a/examples/netns_routing_experiment.py b/examples/netns_routing_experiment.py new file mode 100644 index 00000000..f9f15ff9 --- /dev/null +++ b/examples/netns_routing_experiment.py @@ -0,0 +1,106 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Experiment Topology: +# +# n1 --- n2 --- n3 +# 0.1 0.2 1.1 1.2 +# + +from nepi.core.design import ExperimentDescription, FactoriesProvider +from nepi.core.execute import ExperimentController +import getpass +import tempfile +import time + +user = getpass.getuser() +root_dir = tempfile.mkdtemp() + +exp_desc = ExperimentDescription() + +testbed_id = "netns" +netns_provider = FactoriesProvider(testbed_id) +netns_desc = exp_desc.add_testbed_description(netns_provider) +netns_desc.set_attribute_value("homeDirectory", root_dir) +#netns_desc.set_attribute_value("enableDebug", True) + +node1 = netns_desc.create("Node") +node2 = netns_desc.create("Node") +node3 = netns_desc.create("Node") + +iface12 = netns_desc.create("P2PNodeInterface") +iface12.set_attribute_value("up", True) +node1.connector("devs").connect(iface12.connector("node")) + +iface21 = netns_desc.create("P2PNodeInterface") +iface21.set_attribute_value("up", True) +node2.connector("devs").connect(iface21.connector("node")) + +iface23 = netns_desc.create("P2PNodeInterface") +iface23.set_attribute_value("up", True) +node2.connector("devs").connect(iface23.connector("node")) + +iface32 = netns_desc.create("P2PNodeInterface") +iface32.set_attribute_value("up", True) +node3.connector("devs").connect(iface32.connector("node")) + +iface12.connector("p2p").connect(iface21.connector("p2p")) +iface23.connector("p2p").connect(iface32.connector("p2p")) + +ip12 = iface12.add_address() +ip12.set_attribute_value("Address", "192.168.0.1") +ip12.set_attribute_value("NetPrefix", 30) + +ip21 = iface21.add_address() +ip21.set_attribute_value("Address", "192.168.0.2") +ip21.set_attribute_value("NetPrefix", 30) + +ip23 = iface23.add_address() +ip23.set_attribute_value("Address", "192.168.1.1") +ip23.set_attribute_value("NetPrefix", 30) + +ip32 = iface32.add_address() +ip32.set_attribute_value("Address", "192.168.1.2") +ip32.set_attribute_value("NetPrefix", 30) + +route1 = node1.add_route() +route1.set_attribute_value("Destination", "192.168.1.0") +route1.set_attribute_value("NetPrefix", 30) +route1.set_attribute_value("NextHop", "192.168.0.2") + +route2 = node3.add_route() +route2.set_attribute_value("Destination", "192.168.0.0") +route2.set_attribute_value("NetPrefix", 30) +route2.set_attribute_value("NextHop", "192.168.1.1") + +app1 = netns_desc.create("Application") +app1.set_attribute_value("command", "ping -qc 3 192.168.1.2") +app1.set_attribute_value("user", user) +app1.connector("node").connect(node1.connector("apps")) + +app1.enable_trace("stdout") + +app2 = netns_desc.create("Application") +app2.set_attribute_value("command", "ping -qc 3 192.168.0.1") +app2.set_attribute_value("user", user) +app2.connector("node").connect(node3.connector("apps")) + +app2.enable_trace("stdout") + +xml = exp_desc.to_xml() + +controller = ExperimentController(xml, root_dir) +controller.start() +while not (controller.is_finished(app1.guid) and \ + controller.is_finished(app2.guid)): + time.sleep(0.5) + +result1 = controller.trace(app1.guid, "stdout") +result2 = controller.trace(app2.guid, "stdout") + +controller.stop() +controller.shutdown() + +print result1 +print result2 diff --git a/examples/netns_xterm_experiment.py b/examples/netns_xterm_experiment.py new file mode 100644 index 00000000..b6f2bad8 --- /dev/null +++ b/examples/netns_xterm_experiment.py @@ -0,0 +1,70 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Experiment Topology: +# +# n1 --- n2 +# 0.1 0.2 +# + +from nepi.core.design import ExperimentDescription, FactoriesProvider +from nepi.core.execute import ExperimentController +import getpass +import tempfile +import time + +user = getpass.getuser() +root_dir = tempfile.mkdtemp() + +exp_desc = ExperimentDescription() + +testbed_id = "netns" +netns_provider = FactoriesProvider(testbed_id) +netns_desc = exp_desc.add_testbed_description(netns_provider) +netns_desc.set_attribute_value("homeDirectory", root_dir) +#netns_desc.set_attribute_value("enableDebug", True) + +node1 = netns_desc.create("Node") +node1.set_attribute_value("forward_X11", True) +node2 = netns_desc.create("Node") +node2.set_attribute_value("forward_X11", True) + +iface12 = netns_desc.create("P2PNodeInterface") +iface12.set_attribute_value("up", True) +node1.connector("devs").connect(iface12.connector("node")) + +iface21 = netns_desc.create("P2PNodeInterface") +iface21.set_attribute_value("up", True) +node2.connector("devs").connect(iface21.connector("node")) + +iface12.connector("p2p").connect(iface21.connector("p2p")) + +ip12 = iface12.add_address() +ip12.set_attribute_value("Address", "192.168.0.1") +ip12.set_attribute_value("NetPrefix", 30) + +ip21 = iface21.add_address() +ip21.set_attribute_value("Address", "192.168.0.2") +ip21.set_attribute_value("NetPrefix", 30) + +app1 = netns_desc.create("Application") +app1.set_attribute_value("command", "xterm") +app1.set_attribute_value("user", user) +app1.connector("node").connect(node1.connector("apps")) + +app2 = netns_desc.create("Application") +app2.set_attribute_value("command", "xterm") +app2.set_attribute_value("user", user) +app2.connector("node").connect(node2.connector("apps")) + +xml = exp_desc.to_xml() + +controller = ExperimentController(xml, root_dir) +controller.start() +while not (controller.is_finished(app1.guid) and \ + controller.is_finished(app2.guid)): + time.sleep(0.5) + +controller.stop() +controller.shutdown() diff --git a/examples/ns3_runtime_attribute_change.py b/examples/ns3_runtime_attribute_change.py new file mode 100644 index 00000000..7481888b --- /dev/null +++ b/examples/ns3_runtime_attribute_change.py @@ -0,0 +1,87 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Experiment Topology: +# +# n1 --- n2 +# 0.1 0.2 +# + +from nepi.core.design import ExperimentDescription, FactoriesProvider +from nepi.core.execute import ExperimentController +import tempfile +import time + +root_dir = tempfile.mkdtemp() + +exp_desc = ExperimentDescription() + +testbed_id = "ns3" +ns3_provider = FactoriesProvider(testbed_id) +ns3_desc = exp_desc.add_testbed_description(ns3_provider) +ns3_desc.set_attribute_value("homeDirectory", root_dir) +ns3_desc.set_attribute_value("SimulatorImplementationType", "ns3::RealtimeSimulatorImpl") +ns3_desc.set_attribute_value("ChecksumEnabled", True) + +node1 = ns3_desc.create("ns3::Node") +ipv41 = ns3_desc.create("ns3::Ipv4L3Protocol") +arp1 = ns3_desc.create("ns3::ArpL3Protocol") +icmp1 = ns3_desc.create("ns3::Icmpv4L4Protocol") +node1.connector("protos").connect(ipv41.connector("node")) +node1.connector("protos").connect(arp1.connector("node")) +node1.connector("protos").connect(icmp1.connector("node")) +iface1 = ns3_desc.create("ns3::PointToPointNetDevice") +queue1 = ns3_desc.create("ns3::DropTailQueue") +node1.connector("devs").connect(iface1.connector("node")) +iface1.connector("queue").connect(queue1.connector("dev")) +trace1 = iface1.enable_trace("P2PAsciiTrace") +ip1 = iface1.add_address() +ip1.set_attribute_value("Address", "10.0.0.1") + +node2 = ns3_desc.create("ns3::Node") +ipv42 = ns3_desc.create("ns3::Ipv4L3Protocol") +arp2 = ns3_desc.create("ns3::ArpL3Protocol") +icmp2 = ns3_desc.create("ns3::Icmpv4L4Protocol") +node2.connector("protos").connect(ipv42.connector("node")) +node2.connector("protos").connect(arp2.connector("node")) +node2.connector("protos").connect(icmp2.connector("node")) +iface2 = ns3_desc.create("ns3::PointToPointNetDevice") +queue2 = ns3_desc.create("ns3::DropTailQueue") +node2.connector("devs").connect(iface2.connector("node")) +iface2.connector("queue").connect(queue2.connector("dev")) +trace2 = iface2.enable_trace("P2PAsciiTrace") +ip2 = iface2.add_address() +ip2.set_attribute_value("Address", "10.0.0.2") + +chan = ns3_desc.create("ns3::PointToPointChannel") +chan.set_attribute_value("Delay", "0ns") +iface1.connector("chan").connect(chan.connector("dev2")) +iface2.connector("chan").connect(chan.connector("dev2")) + +app = ns3_desc.create("ns3::V4Ping") +app.set_attribute_value("Remote", "10.0.0.2") +app.set_attribute_value("Verbose", True) +app.set_attribute_value("StartTime", "0s") +app.set_attribute_value("StopTime", "20s") + +app.connector("node").connect(node1.connector("apps")) + +xml = exp_desc.to_xml() + +controller = ExperimentController(xml, root_dir) +controller.start() + +time.sleep(5) + +controller.set(chan.guid, "Delay", "10s") + +time.sleep(5) + +controller.set(chan.guid, "Delay", "0s") + +while not controller.is_finished(app.guid): + time.sleep(0.5) + +controller.stop() +controller.shutdown() diff --git a/examples/roads09.py b/examples/roads09.py deleted file mode 100755 index 47b42b20..00000000 --- a/examples/roads09.py +++ /dev/null @@ -1,495 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -from nepi.core.design import ExperimentDescription, FactoriesProvider -from nepi.core.execute import ExperimentController -from optparse import OptionParser, SUPPRESS_HELP -from nepi.util import proxy -from nepi.util.constants import DeploymentConfiguration as DC, ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP -import os -import shutil -import tempfile -import time -import sys -import random - -def pl_auth(): - user = os.environ.get('PL_USER') - pwd = os.environ.get('PL_PASS') - - if user and pwd: - return (user,pwd) - else: - return None - -class Roads09Ns3PLExample(object): - testbed_id = "planetlab" - slicename = "inria_nepi" - plchost = "nepiplc.pl.sophia.inria.fr" - - host1 = "nepi1.pl.sophia.inria.fr" - host2 = "nepi2.pl.sophia.inria.fr" - host3 = "nepi3.pl.sophia.inria.fr" - host4 = "nepi5.pl.sophia.inria.fr" - - def __init__(self): - #usage = "usage: %prog -m movie -u user" - #parser = OptionParser(usage=usage) - #parser.add_option("-u", "--user", dest="user", help="Valid linux system user (not root).", type="str") - #parser.add_option("-m", "--movie", dest="movie", help="Path to movie file to play", type="str") - #(options, args) = parser.parse_args() - #if not options.movie: - # parser.error("Missing 'movie' option.") - #if options.user == 'root': - # parser.error("Missing or invalid 'user' option.") - - #self.user = options.user if options.user else os.getlogin() - #self.movie = options.movie - - if not pl_auth(): - print "Example requires PlanetLab authentication info (PL_USER and PL_PASS environment variables)" - sys.exit(1) - - self.root_dir = tempfile.mkdtemp() - - - def make_experiment_desc(self): - testbed_id = self.testbed_id - slicename = self.slicename - plchost = self.plchost - pl_ssh_key = os.environ.get( - "PL_SSH_KEY", - "%s/.ssh/id_rsa_planetlab" % (os.environ['HOME'],) ) - pl_user, pl_pwd = pl_auth() - - exp_desc = ExperimentDescription() - pl_provider = FactoriesProvider(testbed_id) - pl_desc = exp_desc.add_testbed_description(pl_provider) - pl_desc.set_attribute_value("homeDirectory", self.root_dir) - pl_desc.set_attribute_value("slice", slicename) - pl_desc.set_attribute_value("sliceSSHKey", pl_ssh_key) - pl_desc.set_attribute_value("authUser", pl_user) - pl_desc.set_attribute_value("authPass", pl_pwd) - pl_desc.set_attribute_value("plcHost", plchost) - - return pl_desc, exp_desc - - def make_ns_in_pl(self, pl, exp, node1, iface1, root): - ns3_testbed_id = "ns3" - - # Add NS3 support in node1 - plnepi = pl.create("NepiDependency") - plns3 = pl.create("NS3Dependency") - plnepi.connector("node").connect(node1.connector("deps")) - plns3.connector("node").connect(node1.connector("deps")) - - # Create NS3 testbed running in node1 - ns3_provider = FactoriesProvider(ns3_testbed_id) - ns3_desc = exp.add_testbed_description(ns3_provider) - ns3_desc.set_attribute_value("rootDirectory", root) - ns3_desc.set_attribute_value("SimulatorImplementationType", "ns3::RealtimeSimulatorImpl") - ns3_desc.set_attribute_value("ChecksumEnabled", True) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_HOST, "{#[%s].addr[0].[Address]#}" % ( - iface1.get_attribute_value("label"),)) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_USER, - pl.get_attribute_value("slice")) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_KEY, - pl.get_attribute_value("sliceSSHKey")) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP, - "{#[%s].[%s]#}" % ( - node1.get_attribute_value("label"), - ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP,)) - ns3_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) - - return ns3_desc - - - - def add_ns3_fdnd(self, node, ns3_desc): - fdnd = ns3_desc.create("ns3::FdNetDevice") - node.connector("devs").connect(fdnd.connector("node")) - fdnd.enable_trace("FdPcapTrace") - return fdnd - - def add_ns3_node(self, ns3_desc): - node = ns3_desc.create("ns3::Node") - ipv4 = ns3_desc.create("ns3::Ipv4L3Protocol") - arp = ns3_desc.create("ns3::ArpL3Protocol") - icmp = ns3_desc.create("ns3::Icmpv4L4Protocol") - udp = ns3_desc.create("ns3::UdpL4Protocol") - node.connector("protos").connect(ipv4.connector("node")) - node.connector("protos").connect(arp.connector("node")) - node.connector("protos").connect(icmp.connector("node")) - node.connector("protos").connect(udp.connector("node")) - return node - - def add_ns3_wifi(self, node, ns3_desc, access_point = False, ip = None, prefix = 24): - wifi = ns3_desc.create("ns3::WifiNetDevice") - node.connector("devs").connect(wifi.connector("node")) - - phy = ns3_desc.create("ns3::YansWifiPhy") - error = ns3_desc.create("ns3::NistErrorRateModel") - manager = ns3_desc.create("ns3::ArfWifiManager") - if access_point: - mac = ns3_desc.create("ns3::QapWifiMac") - else: - mac = ns3_desc.create("ns3::QstaWifiMac") - - phy.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a") - mac.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a") - phy.connector("err").connect(error.connector("phy")) - wifi.connector("phy").connect(phy.connector("dev")) - wifi.connector("mac").connect(mac.connector("dev")) - wifi.connector("manager").connect(manager.connector("dev")) - - if ip: - self.add_ip_address(wifi, ip, prefix) - - phy.enable_trace("YansWifiPhyPcapTrace") - return wifi, phy - - def add_ns3_random_mobility(self, node, ns3_desc, x, y, z, speed, - bounds_width, bounds_height): - position = "%f:%f:%f" % (x, y, z) - bounds = "0|%f|0|%f" % (bounds_width, bounds_height) - speed = "Constant:%f" % speed - mobility = ns3_desc.create("ns3::RandomDirection2dMobilityModel") - mobility.set_attribute_value("Position", position) - mobility.set_attribute_value("Bounds", bounds) - mobility.set_attribute_value("Speed", speed) - mobility.set_attribute_value("Pause", "Constant:1") - node.connector("mobility").connect(mobility.connector("node")) - return mobility - - def add_ns3_constant_mobility(self, node, ns3_desc, x, y, z): - mobility = ns3_desc.create("ns3::ConstantPositionMobilityModel") - position = "%f:%f:%f" % (x, y, z) - mobility.set_attribute_value("Position", position) - node.connector("mobility").connect(mobility.connector("node")) - return mobility - - def add_ns3_wifi_channel(self, ns3_desc): - channel = ns3_desc.create("ns3::YansWifiChannel") - delay = ns3_desc.create("ns3::ConstantSpeedPropagationDelayModel") - loss = ns3_desc.create("ns3::LogDistancePropagationLossModel") - channel.connector("delay").connect(delay.connector("chan")) - channel.connector("loss").connect(loss.connector("prev")) - return channel - - def add_ip_address(self, iface, address, prefix = 24): - ip = iface.add_address() - ip.set_attribute_value("Address", address) - ip.set_attribute_value("Broadcast", True) - ip.set_attribute_value("NetPrefix", prefix) - return ip - - def add_route(self, nodes, destination, netprefix, nexthop): - for node in nodes: - route = node.add_route() - route.set_attribute_value("Destination", destination) - route.set_attribute_value("NetPrefix", netprefix) - route.set_attribute_value("NextHop", nexthop) - - def make_pl_router(self, pl, hostname, label, ip, inet = None): - pl1 = pl.create("Node") - pl1.set_attribute_value("hostname", hostname) - pl1.set_attribute_value("label", label) - pl1.set_attribute_value("emulation", True) - pl1if = pl.create("NodeInterface") - pl1if.set_attribute_value("label", label+"if") - pl1tap = pl.create("TapInterface") - pl1tap.enable_trace("packets") # for error output - pl1tap.set_attribute_value("label", label+"tap") - pl1tap.set_attribute_value("snat", False) - inet = inet or pl.create("Internet") - pl1.connector("devs").connect(pl1if.connector("node")) - pl1.connector("devs").connect(pl1tap.connector("node")) - pl1if.connector("inet").connect(inet.connector("devs")) - - pl1tapip = pl1tap.add_address() - pl1tapip.set_attribute_value("Address", ip) - pl1tapip.set_attribute_value("NetPrefix", 24) - pl1tapip.set_attribute_value("Broadcast", False) - - return pl1, pl1if, pl1tap, pl1tapip, inet - - def make_mesh(self, pl, exp, inet): - scale = 1.0 - walkdistance = 1.0 - walkspeed = 0.1 - - # Router 1 & NS3 host in PL - pl1, pl1if, pl1tap, pl1tapip, inet = self.make_pl_router(pl, - self.host1, "mesh_pl1", "192.168.2.2", inet) - - # Add NS3 support in pl1 - ns3 = self.make_ns_in_pl(pl, exp, pl1, pl1if, "tb-ns3-roads09-1") - - # Add WiFi channel - chan = self.add_ns3_wifi_channel(ns3) - - # Add APs - ap1 = self.add_ns3_node(ns3) - ap2 = self.add_ns3_node(ns3) - ap3 = self.add_ns3_node(ns3) - ap4 = self.add_ns3_node(ns3) - ap1wifi, ap1phy = self.add_ns3_wifi(ap1, ns3, False, "192.168.2.3", 26) - ap2wifi, ap2phy = self.add_ns3_wifi(ap2, ns3, True, "192.168.2.4", 26) - ap3wifi, ap3phy = self.add_ns3_wifi(ap3, ns3, False, "192.168.2.5", 26) - ap4wifi, ap4phy = self.add_ns3_wifi(ap4, ns3, False, "192.168.2.6", 26) - self.add_ns3_constant_mobility(ap1, ns3, -scale, -scale, 0.0) - self.add_ns3_constant_mobility(ap2, ns3, +scale, -scale, 0.0) - self.add_ns3_constant_mobility(ap3, ns3, -scale, +scale, 0.0) - self.add_ns3_constant_mobility(ap4, ns3, +scale, +scale, 0.0) - - # Add WiFi nodes - wnode1 = self.add_ns3_node(ns3) - wnode2 = self.add_ns3_node(ns3) - wnode3 = self.add_ns3_node(ns3) - wnode4 = self.add_ns3_node(ns3) - wnode5 = self.add_ns3_node(ns3) - wnode1wifi, wnode1phy = self.add_ns3_wifi(wnode1, ns3, False, "192.168.2.7", 26) - wnode2wifi, wnode2phy = self.add_ns3_wifi(wnode2, ns3, False, "192.168.2.8", 26) - wnode3wifi, wnode3phy = self.add_ns3_wifi(wnode3, ns3, False, "192.168.2.9", 26) - wnode4wifi, wnode4phy = self.add_ns3_wifi(wnode4, ns3, False, "192.168.2.10", 26) - wnode5wifi, wnode5phy = self.add_ns3_wifi(wnode5, ns3, False, "192.168.2.11", 26) - self.add_ns3_random_mobility(wnode1, ns3, -2*scale, -2*scale, 0.0, - walkspeed, walkdistance, walkdistance) - self.add_ns3_random_mobility(wnode2, ns3, -2*scale, +scale, 0.0, - walkspeed, walkdistance, walkdistance) - self.add_ns3_random_mobility(wnode3, ns3, -scale, +2*scale, 0.0, - walkspeed, walkdistance, walkdistance) - self.add_ns3_random_mobility(wnode4, ns3, +scale, +2*scale, 0.0, - walkspeed, walkdistance, walkdistance) - self.add_ns3_random_mobility(wnode5, ns3, +2*scale, +2*scale, 0.0, - walkspeed, walkdistance, walkdistance) - - # Connect all WiFi phys to the channel - ap1phy.connector("chan").connect(chan.connector("phys")) - ap2phy.connector("chan").connect(chan.connector("phys")) - ap3phy.connector("chan").connect(chan.connector("phys")) - ap4phy.connector("chan").connect(chan.connector("phys")) - wnode1phy.connector("chan").connect(chan.connector("phys")) - wnode2phy.connector("chan").connect(chan.connector("phys")) - wnode3phy.connector("chan").connect(chan.connector("phys")) - wnode4phy.connector("chan").connect(chan.connector("phys")) - wnode5phy.connector("chan").connect(chan.connector("phys")) - - # Add inet connection to AP - ap2fdnd = self.add_ns3_fdnd(ap2, ns3) - ap2fdndip = self.add_ip_address(ap2fdnd, "192.168.2.20") - ap2fdndip.set_attribute_value("NetPrefix", 32) # p2p - pl1tap.connector("fd->").connect(ap2fdnd.connector("->fd")) - pl1tap.set_attribute_value("pointopoint", "192.168.2.20") - r = ap2.add_route() - r.set_attribute_value("Destination", "192.168.2.2") - r.set_attribute_value("NetPrefix", 32) - r.set_attribute_value("NextHop", "192.168.2.20") - - # return mesh router - return ( - pl1, pl1if, pl1tap, pl1tapip, - (wnode1, wnode2, wnode3, wnode4, wnode5), - (wnode1wifi, wnode2wifi, wnode3wifi, wnode4wifi, wnode5wifi), - (ap1, ap2, ap3, ap4), - (ap1wifi, ap2wifi, ap3wifi, ap4wifi), - ns3, - inet, - ) - - def make_wifi_hotspot(self, pl, exp, inet): - scale = 1.0 - walkdistance = 1.0 - walkspeed = 0.1 - - # Router 1 & NS3 host in PL - pl1, pl1if, pl1tap, pl1tapip, inet = self.make_pl_router(pl, - self.host2, "hs_pl1", "192.168.2.65", inet) - - # Add NS3 support in pl1 - ns3 = self.make_ns_in_pl(pl, exp, pl1, pl1if, "tb-ns3-roads09-2") - - # Add WiFi channel - chan = self.add_ns3_wifi_channel(ns3) - - # Add APs - ap1 = self.add_ns3_node(ns3) - ap1wifi, ap1phy = self.add_ns3_wifi(ap1, ns3, True, "192.168.2.66", 26) - self.add_ns3_constant_mobility(ap1, ns3, 0.0, 0.0, 0.0) - - # Add WiFi nodes - wnode1 = self.add_ns3_node(ns3) - wnode2 = self.add_ns3_node(ns3) - wnode3 = self.add_ns3_node(ns3) - wnode4 = self.add_ns3_node(ns3) - wnode1wifi, wnode1phy = self.add_ns3_wifi(wnode1, ns3, False, "192.168.2.67", 26) - wnode2wifi, wnode2phy = self.add_ns3_wifi(wnode2, ns3, False, "192.168.2.68", 26) - wnode3wifi, wnode3phy = self.add_ns3_wifi(wnode3, ns3, False, "192.168.2.69", 26) - wnode4wifi, wnode4phy = self.add_ns3_wifi(wnode4, ns3, False, "192.168.2.70", 26) - self.add_ns3_random_mobility(wnode1, ns3, +scale, -2*scale, 0.0, - walkspeed, walkdistance, walkdistance) - self.add_ns3_random_mobility(wnode2, ns3, -scale, -2*scale, 0.0, - walkspeed, walkdistance, walkdistance) - self.add_ns3_random_mobility(wnode3, ns3, -2*scale, +scale, 0.0, - walkspeed, walkdistance, walkdistance) - self.add_ns3_random_mobility(wnode4, ns3, -2*scale, +2*scale, 0.0, - walkspeed, walkdistance, walkdistance) - - # Connect all WiFi phys to the channel - ap1phy.connector("chan").connect(chan.connector("phys")) - wnode1phy.connector("chan").connect(chan.connector("phys")) - wnode2phy.connector("chan").connect(chan.connector("phys")) - wnode3phy.connector("chan").connect(chan.connector("phys")) - wnode4phy.connector("chan").connect(chan.connector("phys")) - - # Add inet connection to AP2 - ap1fdnd = self.add_ns3_fdnd(ap1, ns3) - ap1fdndip = self.add_ip_address(ap1fdnd, "192.168.2.80") - ap1fdndip.set_attribute_value("NetPrefix", 32) # p2p - pl1tap.connector("fd->").connect(ap1fdnd.connector("->fd")) - pl1tap.set_attribute_value("pointopoint", "192.168.2.80") - r = ap1.add_route() - r.set_attribute_value("Destination", "192.168.2.65") - r.set_attribute_value("NetPrefix", 32) - r.set_attribute_value("NextHop", "192.168.2.80") - - # return mesh router - return ( - pl1, pl1if, pl1tap, pl1tapip, - (wnode1, wnode2, wnode3, wnode4), - (wnode1wifi, wnode2wifi, wnode3wifi, wnode4wifi), - ap1, ap1wifi, - ns3, - inet, - ) - - def run(self): - pl, exp = self.make_experiment_desc() - - pl1, pl1if, pl1tap, pl1tapip, \ - mesh_nodes, mesh_node_ifs, \ - mesh_aps, mesh_ap_ifs, \ - mesh_ns, \ - inet = self.make_mesh(pl, exp, None) - pl2, pl2if, pl2tap, pl2tapip, \ - hs_nodes, hs_node_ifs, \ - hs_ap, hs_apif, \ - hs_ns, \ - inet = self.make_wifi_hotspot(pl, exp, inet) - - # Connect the routers - pl1etap = pl.create("TapInterface") - pl1etap.enable_trace("packets") # for error output - pl1etap.set_attribute_value("label", "pl1etap") - pl1etapip = pl1etap.add_address() - pl1etapip.set_attribute_value("Address", "192.168.2.1") - pl1etapip.set_attribute_value("NetPrefix", 24) - pl1etapip.set_attribute_value("Broadcast", False) - - pl2etap = pl.create("TapInterface") - pl2etap.enable_trace("packets") # for error output - pl2etap.set_attribute_value("label", "pl2etap") - pl2etapip = pl2etap.add_address() - pl2etapip.set_attribute_value("Address", "192.168.2.81") - pl2etapip.set_attribute_value("NetPrefix", 24) - pl2etapip.set_attribute_value("Broadcast", False) - - pl1etap.connector("node").connect(pl1.connector("devs")) - pl2etap.connector("node").connect(pl2.connector("devs")) - pl1etap.connector("udp").connect(pl2etap.connector("udp")) - pl1etap.set_attribute_value("pointopoint", "192.168.2.81") - pl2etap.set_attribute_value("pointopoint", "192.168.2.1") - - # Connect the networks - - # apn -> ap2 (n != 2) - for ap in mesh_aps[:1] + mesh_aps[2:]: - r = ap.add_route() - r.set_attribute_value("Destination", "192.168.2.64") - r.set_attribute_value("NetPrefix", 26) - r.set_attribute_value("NextHop", - mesh_ap_ifs[1].addresses[0].get_attribute_value("Address") ) - - for wn in mesh_nodes: - apif = mesh_ap_ifs[ random.randint(0,len(mesh_aps)-1) ] - r = wn.add_route() - r.set_attribute_value("Destination", "192.168.2.64") - r.set_attribute_value("NetPrefix", 26) - r.set_attribute_value("NextHop", - apif.addresses[0].get_attribute_value("Address")) - - r = mesh_aps[1].add_route() - r.set_attribute_value("Destination", "192.168.2.64") - r.set_attribute_value("NetPrefix", 26) - r.set_attribute_value("NextHop", "192.168.2.2") - - r = pl1.add_route() - r.set_attribute_value("Destination", "192.168.2.64") - r.set_attribute_value("NetPrefix", 26) - r.set_attribute_value("NextHop", "192.168.2.81") - - r = pl2.add_route() - r.set_attribute_value("Destination", "192.168.2.64") - r.set_attribute_value("NetPrefix", 26) - r.set_attribute_value("NextHop", "192.168.2.80") - - for wn in hs_nodes: - r = wn.add_route() - r.set_attribute_value("Destination", "192.168.2.0") - r.set_attribute_value("NetPrefix", 26) - r.set_attribute_value("NextHop", "192.168.2.66") - - r = hs_ap.add_route() - r.set_attribute_value("Destination", "192.168.2.0") - r.set_attribute_value("NetPrefix", 26) - r.set_attribute_value("NextHop", "192.168.2.65") - - r = pl2.add_route() - r.set_attribute_value("Destination", "192.168.2.0") - r.set_attribute_value("NetPrefix", 26) - r.set_attribute_value("NextHop", "192.168.2.1") - - r = pl1.add_route() - r.set_attribute_value("Destination", "192.168.2.0") - r.set_attribute_value("NetPrefix", 26) - r.set_attribute_value("NextHop", "192.168.2.20") - - # Add pinger app inside the mesh - hs_node_ifs[0].set_attribute_value("label", "hotspot_node_1if") - mesh_node_ifs[0].set_attribute_value("label", "mesh_node_1if") - ping = mesh_ns.create("ns3::V4Ping") - ping.set_attribute_value("Remote", "192.168.2.67") #"{#[hotspot_node_1if].addr[0].[Address]#}") - ping.set_attribute_value("StartTime", "0s") - ping.set_attribute_value("StopTime", "10s") - ping.connector("node").connect(mesh_aps[0].connector("apps")) - - xml = exp.to_xml() - - print xml - - try: - controller = ExperimentController(xml, self.root_dir) - controller.start() - - while not controller.is_finished(ping.guid): - time.sleep(0.5) - - taptrace = controller.trace(pl.guid, pl1tap.guid, "packets") - - finally: - controller.stop() - controller.shutdown() - - print "Pakcets at router:" - print taptrace - - def clean(self): - shutil.rmtree(self.root_dir) - -if __name__ == '__main__': - example = Roads09Ns3PLExample() - example.run() - example.clean() - diff --git a/examples/tunnel_cross_testbed_experiment.py b/examples/tunnel_cross_testbed_experiment.py new file mode 100644 index 00000000..9468f1bf --- /dev/null +++ b/examples/tunnel_cross_testbed_experiment.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +import getpass +from nepi.core.design import ExperimentDescription, FactoriesProvider +from nepi.core.execute import ExperimentController +from nepi.util import proxy +from nepi.util.constants import DeploymentConfiguration as DC +import os +import shutil +import tempfile +import time + +root_dir = tempfile.mkdtemp() +netns_root_dir = os.path.join(root_dir, "netns") +os.makedirs(netns_root_dir) +user = getpass.getuser() +slicename = os.environ["PL_SLICE"] +plchost = "www.planet-lab.eu" +port_base = 2000 + (os.getpid() % 1000) * 13 +pl_ssh_key = os.environ.get( + "PL_SSH_KEY", + "%s/.ssh/id_rsa_planetlab" % (os.environ['HOME'],) ) +pl_user = os.environ.get('PL_USER') +pl_pwd = os.environ.get('PL_PASS') + +exp_desc = ExperimentDescription() + +pl_provider = FactoriesProvider("planetlab") +pl_desc = exp_desc.add_testbed_description(pl_provider) +pl_desc.set_attribute_value("homeDirectory", root_dir) +pl_desc.set_attribute_value("slice", slicename) +pl_desc.set_attribute_value("sliceSSHKey", pl_ssh_key) +pl_desc.set_attribute_value("authUser", pl_user) +pl_desc.set_attribute_value("authPass", pl_pwd) +pl_desc.set_attribute_value("plcHost", plchost) +pl_desc.set_attribute_value("tapPortBase", port_base) +pl_desc.set_attribute_value("p2pDeployment", False) # it's interactive, we don't want it in tests +pl_desc.set_attribute_value("dedicatedSlice", True) +pl_desc.set_attribute_value("plLogLevel", "DEBUG") + +pl_inet = pl_desc.create("Internet") + +pl_node = pl_desc.create("Node") +pl_iface = pl_desc.create("NodeInterface") +pl_iface.connector("inet").connect(pl_inet.connector("devs")) +pl_node.connector("devs").connect(pl_iface.connector("node")) + +pl_tap = pl_desc.create("TunInterface") +pl_tap.enable_trace("pcap") +pl_tap.enable_trace("packets") +pl_node.connector("devs").connect(pl_tap.connector("node")) + +ip1 = pl_tap.add_address() +ip1.set_attribute_value("Address", "192.168.3.1") +ip1.set_attribute_value("NetPrefix", 24) + +netns_provider = FactoriesProvider("netns") +netns_desc = exp_desc.add_testbed_description(netns_provider) +netns_desc.set_attribute_value("homeDirectory", root_dir) +netns_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) +netns_desc.set_attribute_value(DC.ROOT_DIRECTORY, netns_root_dir) +netns_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) +netns_desc.set_attribute_value(DC.USE_SUDO, True) + +netns_node = netns_desc.create("Node") +netns_node.set_attribute_value("forward_X11", True) + +netns_tap = netns_desc.create("TunNodeInterface") +netns_tap.set_attribute_value("up", True) +netns_tap.set_attribute_value("mtu", 1448) +netns_node.connector("devs").connect(netns_tap.connector("node")) +netns_tunchannel = netns_desc.create("TunChannel") +netns_tunchannel.connector("->fd").connect(netns_tap.connector("fd->")) + +pl_tap.connector("tcp").connect(netns_tunchannel.connector("tcp")) + +ip2 = netns_tap.add_address() +ip2.set_attribute_value("Address", "192.168.3.2") +ip2.set_attribute_value("NetPrefix", 30) + +app = netns_desc.create("Application") +app.set_attribute_value("command", "xterm") +app.set_attribute_value("user", user) +app.connector("node").connect(netns_node.connector("apps")) + +xml = exp_desc.to_xml() + +controller = ExperimentController(xml, root_dir) +controller.start() +while not controller.is_finished(app.guid): + time.sleep(0.5) + +controller.stop() +controller.shutdown() + diff --git a/examples/vlc_wireless_netns_ns3.py b/examples/vlc_wireless_netns_ns3.py deleted file mode 100755 index 469c8370..00000000 --- a/examples/vlc_wireless_netns_ns3.py +++ /dev/null @@ -1,226 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -from nepi.core.design import ExperimentDescription, FactoriesProvider -from nepi.core.execute import ExperimentController -from optparse import OptionParser, SUPPRESS_HELP -from nepi.util import proxy -import os -import shutil -import tempfile -import test_util -import time - -class VlcWirelessNetnsNs3Example(object): - def __init__(self): - usage = "usage: %prog -m movie -u user" - parser = OptionParser(usage=usage) - parser.add_option("-u", "--user", dest="user", help="Valid linux system user (not root).", type="str") - parser.add_option("-m", "--movie", dest="movie", help="Path to movie file to play", type="str") - (options, args) = parser.parse_args() - if not options.movie: - parser.error("Missing 'movie' option.") - if options.user == 'root': - parser.error("Missing or invalid 'user' option.") - - self.user = options.user if options.user else os.getlogin() - self.movie = options.movie - self.root_dir = tempfile.mkdtemp() - - def add_netns_tap(self, node, netns_desc): - tap = netns_desc.create("TapNodeInterface") - tap.set_attribute_value("up", True) - node.connector("devs").connect(tap.connector("node")) - return tap - - def add_ns3_fdnd(self, node, ns3_desc): - fdnd = ns3_desc.create("ns3::FdNetDevice") - node.connector("devs").connect(fdnd.connector("node")) - fdnd.enable_trace("FdPcapTrace") - return fdnd - - def add_ns3_node(self, ns3_desc): - node = ns3_desc.create("ns3::Node") - ipv4 = ns3_desc.create("ns3::Ipv4L3Protocol") - arp = ns3_desc.create("ns3::ArpL3Protocol") - icmp = ns3_desc.create("ns3::Icmpv4L4Protocol") - udp = ns3_desc.create("ns3::UdpL4Protocol") - node.connector("protos").connect(ipv4.connector("node")) - node.connector("protos").connect(arp.connector("node")) - node.connector("protos").connect(icmp.connector("node")) - node.connector("protos").connect(udp.connector("node")) - return node - - def add_ns3_wifi(self, node, ns3_desc, access_point = False): - wifi = ns3_desc.create("ns3::WifiNetDevice") - node.connector("devs").connect(wifi.connector("node")) - - phy = ns3_desc.create("ns3::YansWifiPhy") - error = ns3_desc.create("ns3::NistErrorRateModel") - manager = ns3_desc.create("ns3::ArfWifiManager") - if access_point: - mac = ns3_desc.create("ns3::ApWifiMac") - else: - mac = ns3_desc.create("ns3::StaWifiMac") - - phy.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a") - mac.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a") - phy.connector("err").connect(error.connector("phy")) - wifi.connector("phy").connect(phy.connector("dev")) - wifi.connector("mac").connect(mac.connector("dev")) - wifi.connector("manager").connect(manager.connector("dev")) - - phy.enable_trace("YansWifiPhyPcapTrace") - return wifi, phy - - def add_ns3_random_mobility(self, node, ns3_desc, x, y, z, speed, - bounds_width, bounds_height): - position = "%d:%d:%d" % (x, y, z) - bounds = "0|%d|0|%d" % (bounds_width, bounds_height) - speed = "Constant:%d" % speed - mobility = ns3_desc.create("ns3::RandomDirection2dMobilityModel") - mobility.set_attribute_value("Position", position) - mobility.set_attribute_value("Bounds", bounds) - mobility.set_attribute_value("Speed", speed) - mobility.set_attribute_value("Pause", "Constant:1") - node.connector("mobility").connect(mobility.connector("node")) - return mobility - - def add_ns3_constant_mobility(self, node, ns3_desc, x, y, z): - mobility = ns3_desc.create("ns3::ConstantPositionMobilityModel") - position = "%d:%d:%d" % (x, y, z) - mobility.set_attribute_value("Position", position) - node.connector("mobility").connect(mobility.connector("node")) - return mobility - - def add_ns3_wifi_channel(self, ns3_desc): - channel = ns3_desc.create("ns3::YansWifiChannel") - delay = ns3_desc.create("ns3::ConstantSpeedPropagationDelayModel") - loss = ns3_desc.create("ns3::LogDistancePropagationLossModel") - channel.connector("delay").connect(delay.connector("chan")) - channel.connector("loss").connect(loss.connector("prev")) - return channel - - def add_ip_address(self, iface, address): - ip = iface.add_address() - ip.set_attribute_value("Address", address) - - def add_route(self, node, destination, netprefix, nexthop): - route = node.add_route() - route.set_attribute_value("Destination", destination) - route.set_attribute_value("NetPrefix", netprefix) - route.set_attribute_value("NextHop", nexthop) - - def run(self): - bounds_width = bounds_height = 200 - x = y = 100 - speed = 7 - - exp_desc = ExperimentDescription() - - ## NS3 Testbed instance description ## - testbed_id = "ns3" - ns3_provider = FactoriesProvider(testbed_id) - ns3_desc = exp_desc.add_testbed_description(ns3_provider) - ns3_desc.set_attribute_value("homeDirectory", self.root_dir) - ns3_desc.set_attribute_value("SimulatorImplementationType", "ns3::RealtimeSimulatorImpl") - ns3_desc.set_attribute_value("ChecksumEnabled", True) - # create node 1 - node1 = self.add_ns3_node(ns3_desc) - mobility1 = self.add_ns3_constant_mobility(node1, ns3_desc, x, y, 0) - wifi1, phy1 = self.add_ns3_wifi(node1, ns3_desc, access_point = False) - self.add_ip_address(wifi1, "10.0.1.1") - fdnd1 = self.add_ns3_fdnd(node1, ns3_desc) - self.add_ip_address(fdnd1, "10.0.0.1") - # create node 2 - node2 = self.add_ns3_node(ns3_desc) - mobility2 = self.add_ns3_random_mobility(node2, ns3_desc, x, y, 0, - speed, bounds_width, bounds_height) - wifi2, phy2 = self.add_ns3_wifi(node2, ns3_desc, access_point = True) - self.add_ip_address(wifi2, "10.0.1.2") - fdnd2 = self.add_ns3_fdnd(node2, ns3_desc) - self.add_ip_address(fdnd2, "10.0.2.1") - # interconnect nodes with a wifi channel - wifichan = self.add_ns3_wifi_channel(ns3_desc) - phy1.connector("chan").connect(wifichan.connector("phys")) - phy2.connector("chan").connect(wifichan.connector("phys")) - - ## NETNS testbed description 1 ## - testbed_id = "netns" - netns_provider = FactoriesProvider(testbed_id) - netns_desc1 = exp_desc.add_testbed_description(netns_provider) - netns_desc1.set_attribute_value("homeDirectory", self.root_dir) - #netns_desc1.set_attribute_value("enableDebug", True) - # create node 3 - node3 = netns_desc1.create("Node") - node3.set_attribute_value("forward_X11", True) - tap1 = self.add_netns_tap(node3, netns_desc1) - self.add_ip_address(tap1, "10.0.0.2") - # create vlc server - # DEBUG!! target = "{#[vlc_client].addr[0].[Address]#}" - target = "10.0.2.2" - command = "vlc -I dummy %s --sout '#rtp{dst=%s,port=5004,mux=ts}' vlc://quit" \ - % (self.movie, target) - vlc_server = netns_desc1.create("Application") - vlc_server.set_attribute_value("command", command) - vlc_server.set_attribute_value("user", self.user) - vlc_server.connector("node").connect(node3.connector("apps")) - - #command = "xterm" - #xterm1 = netns_desc1.create("Application") - #xterm1.set_attribute_value("command", command) - #xterm1.set_attribute_value("user", self.user) - #xterm1.connector("node").connect(node3.connector("apps")) - - ## NETNS testbed description 2 ## - netns_desc2 = exp_desc.add_testbed_description(netns_provider) - netns_desc2.set_attribute_value("homeDirectory", self.root_dir) - #netns_desc2.set_attribute_value("enableDebug", True) - # create node 4 - node4 = netns_desc2.create("Node") - node4.set_attribute_value("forward_X11", True) - node4.set_attribute_value("label", "vlc_client") - tap2 = self.add_netns_tap(node4, netns_desc2) - self.add_ip_address(tap2, "10.0.2.2") - # create vlc client - vlc_client = netns_desc2.create("Application") - command = "vlc rtp://%s:5004/test.ts" % target - vlc_client.set_attribute_value("command", command) - vlc_client.set_attribute_value("user", self.user) - vlc_client.connector("node").connect(node4.connector("apps")) - - #command = "xterm" - #xterm2 = netns_desc2.create("Application") - #xterm2.set_attribute_value("command", command) - #xterm2.set_attribute_value("user", self.user) - #xterm2.connector("node").connect(node4.connector("apps")) - - ## testbed_interconnection - fdnd1.connector("->fd").connect(tap1.connector("fd->")) - fdnd2.connector("->fd").connect(tap2.connector("fd->")) - - self.add_route(node4, "10.0.0.0", 24, "10.0.2.1") - self.add_route(node4, "10.0.1.0", 24, "10.0.2.1") - self.add_route(node3, "10.0.2.0", 24, "10.0.0.1") - self.add_route(node3, "10.0.1.0", 24, "10.0.0.1") - - self.add_route(node2, "10.0.0.0", 24, "10.0.1.1") - self.add_route(node1, "10.0.2.0", 24, "10.0.1.2") - - xml = exp_desc.to_xml() - controller = ExperimentController(xml, self.root_dir) - controller.start() - while not controller.is_finished(vlc_server.guid) and \ - not controller.is_finished(vlc_client.guid): - time.sleep(0.5) - controller.stop() - controller.shutdown() - - def clean(self): - shutil.rmtree(self.root_dir) - -if __name__ == '__main__': - example = VlcWirelessNetnsNs3Example() - example.run() - example.clean() - diff --git a/examples/wimax_ns3.py b/examples/wimax_ns3.py deleted file mode 100755 index c6680cd1..00000000 --- a/examples/wimax_ns3.py +++ /dev/null @@ -1,142 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -from nepi.core.design import ExperimentDescription, FactoriesProvider -from nepi.core.execute import ExperimentController -from optparse import OptionParser, SUPPRESS_HELP -from nepi.util import proxy -import os -import shutil -import tempfile -import test_util -import time - -class Roads09Example(object): - def __init__(self): - self.root_dir = tempfile.mkdtemp() - - def add_ns3_node(self, ns3_desc): - node = ns3_desc.create("ns3::Node") - ipv4 = ns3_desc.create("ns3::Ipv4L3Protocol") - arp = ns3_desc.create("ns3::ArpL3Protocol") - icmp = ns3_desc.create("ns3::Icmpv4L4Protocol") - udp = ns3_desc.create("ns3::UdpL4Protocol") - node.connector("protos").connect(ipv4.connector("node")) - node.connector("protos").connect(arp.connector("node")) - node.connector("protos").connect(icmp.connector("node")) - node.connector("protos").connect(udp.connector("node")) - return node - - def add_ns3_wimax_bs(self, ns3_desc, node, channel): - bs = ns3_desc.create("ns3::BaseStationNetDevice") - node.connector("devs").connect(bs.connector("node")) - bs.connector("chan").connect(channel.connector("devs")) - phy = ns3_desc.create("ns3::SimpleOfdmWimaxPhy") - bs.connector("phy").connect(phy.connector("dev")) - uplink = ns3_desc.create("ns3::UplinkSchedulerSimple") - bs.connector("uplnk").connect(uplink.connector("dev")) - bssched = ns3_desc.create("ns3::BSSchedulerSimple") - bs.connector("dwnlnk").connect(bssched.connector("dev")) - bs.enable_trace("WimaxPcapTrace") - bs.enable_trace("WimaxAsciiTrace") - return bs - - def add_ns3_wimax_ss(self, ns3_desc, node, channel): - ss = ns3_desc.create("ns3::SubscriberStationNetDevice") - node.connector("devs").connect(ss.connector("node")) - ss.connector("chan").connect(channel.connector("devs")) - phy = ns3_desc.create("ns3::SimpleOfdmWimaxPhy") - ss.connector("phy").connect(phy.connector("dev")) - ss.enable_trace("WimaxPcapTrace") - ss.enable_trace("WimaxAsciiTrace") - return ss - - def add_ns3_service_flow(self, ns3_desc, ss, src_address, src_mask, - dst_address, dst_mask, src_portlow, src_porthigh, dst_portlow, - dst_porthigh, protocol, priority, direction, scheduling_type): - classifier = ns3_desc.create("ns3::IpcsClassifierRecord") - classifier.set_attribute_value("SrcAddress", src_address) - classifier.set_attribute_value("SrcMask", src_mask) - classifier.set_attribute_value("DstAddress", dst_address) - classifier.set_attribute_value("DstMask", dst_mask) - classifier.set_attribute_value("SrcPortLow", src_portlow) - classifier.set_attribute_value("SrcPortHigh",src_porthigh) - classifier.set_attribute_value("DstPortLow", dst_portlow) - classifier.set_attribute_value("DstPortHigh", dst_porthigh) - classifier.set_attribute_value("Protocol", protocol) - classifier.set_attribute_value("Priority", priority) - sflow = ns3_desc.create("ns3::ServiceFlow") - sflow.set_attribute_value("Direction", direction) - sflow.set_attribute_value("SchedulingType", scheduling_type) - sflow.connector("classif").connect(classifier.connector("sflow")) - ss.connector("sflows").connect(sflow.connector("dev")) - - def add_ip_address(self, iface, address): - ip = iface.add_address() - ip.set_attribute_value("Address", address) - - def run(self): - exp_desc = ExperimentDescription() - - testbed_id = "ns3" - ns3_provider = FactoriesProvider(testbed_id) - ns3_desc = exp_desc.add_testbed_description(ns3_provider) - ns3_desc.set_attribute_value("homeDirectory", self.root_dir) - ns3_desc.set_attribute_value("StopTime", "7.1s") - - node1 = self.add_ns3_node(ns3_desc) - node2 = self.add_ns3_node(ns3_desc) - node3 = self.add_ns3_node(ns3_desc) - - channel = ns3_desc.create("ns3::SimpleOfdmWimaxChannel") - - ss1 = self.add_ns3_wimax_ss(ns3_desc, node1, channel) - ss2 = self.add_ns3_wimax_ss(ns3_desc, node2, channel) - bs = self.add_ns3_wimax_bs(ns3_desc, node3, channel) - - self.add_ns3_service_flow(ns3_desc, ss1, "0.0.0.0", "0.0.0.0", - "10.1.1.1", "255.255.255.255", 0, 65000, 100, 100, - "UdpL4Protocol", 1, "SF_DIRECTION_DOWN", "SF_TYPE_RTPS") - self.add_ns3_service_flow(ns3_desc, ss2, "10.1.1.2", "255.255.255.255", - "0.0.0.0", "0.0.0.0", 0, 65000, 100, 100, "UdpL4Protocol", - 1, "SF_DIRECTION_UP", "SF_TYPE_RTPS") - - self.add_ip_address(ss1, "10.1.1.1") - self.add_ip_address(ss2, "10.1.1.2") - self.add_ip_address(bs, "10.1.1.3") - - udp_server = ns3_desc.create("ns3::UdpServer") - udp_server.set_attribute_value("Port", 100) - udp_server.set_attribute_value("StartTime", "6s") - udp_server.set_attribute_value("StopTime", "7s") - udp_server.connector("node").connect(node1.connector("apps")) - - udp_client = ns3_desc.create("ns3::UdpClient") - udp_client.set_attribute_value("RemotePort", 100) - udp_client.set_attribute_value("RemoteAddress", "10.1.1.1") - udp_client.set_attribute_value("MaxPackets", 1200) - udp_client.set_attribute_value("Interval", "0.5s") - udp_client.set_attribute_value("PacketSize", 1024) - udp_client.set_attribute_value("StartTime", "6s") - udp_client.set_attribute_value("StopTime", "7s") - udp_client.connector("node").connect(node2.connector("apps")) - - xml = exp_desc.to_xml() - controller = ExperimentController(xml, self.root_dir) - controller.start() - while not (controller.is_finished(udp_server.guid) and controller.is_finished(udp_client.guid)): - time.sleep(0.5) - time.sleep(0.1) - controller.stop() - controller.shutdown() - - def clean(self): - print self.root_dir - #shutil.rmtree(self.root_dir) - pass - -if __name__ == '__main__': - example = Roads09Example() - example.run() - example.clean() - diff --git a/examples/wimax_overlay.py b/examples/wimax_overlay.py deleted file mode 100755 index 5b5e3c92..00000000 --- a/examples/wimax_overlay.py +++ /dev/null @@ -1,243 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -from nepi.core.design import ExperimentDescription, FactoriesProvider -from nepi.core.execute import ExperimentController -from optparse import OptionParser, SUPPRESS_HELP -from nepi.util.constants import DeploymentConfiguration as DC -import os -import shutil -import tempfile -import time - -class WimaxOverlayExample(object): - def __init__(self): - #usage = "usage: %prog -m movie -u user" - #parser = OptionParser(usage=usage) - #parser.add_option("-u", "--user", dest="user", help="Valid linux system user (not root).", type="str") - #parser.add_option("-m", "--movie", dest="movie", help="Path to movie file to play", type="str") - #(options, args) = parser.parse_args() - #if not options.movie: - # parser.error("Missing 'movie' option.") - #if options.user == 'root': - # parser.error("Missing or invalid 'user' option.") - - #self.user = options.user if options.user else os.getlogin() - self.user = os.getlogin() - #self.movie = options.movie - self.root_dir = tempfile.mkdtemp() - - def add_ns3_node(self, ns3_desc): - node = ns3_desc.create("ns3::Node") - ipv4 = ns3_desc.create("ns3::Ipv4L3Protocol") - arp = ns3_desc.create("ns3::ArpL3Protocol") - icmp = ns3_desc.create("ns3::Icmpv4L4Protocol") - udp = ns3_desc.create("ns3::UdpL4Protocol") - tcp = ns3_desc.create("ns3::TcpL4Protocol") - node.connector("protos").connect(ipv4.connector("node")) - node.connector("protos").connect(arp.connector("node")) - node.connector("protos").connect(icmp.connector("node")) - node.connector("protos").connect(udp.connector("node")) - node.connector("protos").connect(tcp.connector("node")) - return node - - def add_ns3_wimax_bs(self, ns3_desc, node, channel): - bs = ns3_desc.create("ns3::BaseStationNetDevice") - node.connector("devs").connect(bs.connector("node")) - bs.connector("chan").connect(channel.connector("devs")) - phy = ns3_desc.create("ns3::SimpleOfdmWimaxPhy") - bs.connector("phy").connect(phy.connector("dev")) - uplink = ns3_desc.create("ns3::UplinkSchedulerSimple") - bs.connector("uplnk").connect(uplink.connector("dev")) - bssched = ns3_desc.create("ns3::BSSchedulerSimple") - bs.connector("dwnlnk").connect(bssched.connector("dev")) - bs.enable_trace("WimaxPcapTrace") - bs.enable_trace("WimaxAsciiTrace") - return bs - - def add_ns3_wimax_ss(self, ns3_desc, node, channel): - ss = ns3_desc.create("ns3::SubscriberStationNetDevice") - node.connector("devs").connect(ss.connector("node")) - ss.connector("chan").connect(channel.connector("devs")) - phy = ns3_desc.create("ns3::SimpleOfdmWimaxPhy") - ss.connector("phy").connect(phy.connector("dev")) - ss.enable_trace("WimaxPcapTrace") - ss.enable_trace("WimaxAsciiTrace") - return ss - - def add_ns3_p2p(self, ns3_desc, node, channel): - iface = ns3_desc.create("ns3::PointToPointNetDevice") - queue = ns3_desc.create("ns3::DropTailQueue") - node.connector("devs").connect(iface.connector("node")) - iface.connector("queue").connect(queue.connector("dev")) - trace = iface.enable_trace("P2PAsciiTrace") - iface.connector("chan").connect(channel.connector("dev2")) - return iface - - def add_ns3_service_flow(self, ns3_desc, ss, src_address, src_mask, - dst_address, dst_mask, src_portlow, src_porthigh, dst_portlow, - dst_porthigh, protocol, priority, direction, scheduling_type): - classifier = ns3_desc.create("ns3::IpcsClassifierRecord") - classifier.set_attribute_value("SrcAddress", src_address) - classifier.set_attribute_value("SrcMask", src_mask) - classifier.set_attribute_value("DstAddress", dst_address) - classifier.set_attribute_value("DstMask", dst_mask) - classifier.set_attribute_value("SrcPortLow", src_portlow) - classifier.set_attribute_value("SrcPortHigh",src_porthigh) - classifier.set_attribute_value("DstPortLow", dst_portlow) - classifier.set_attribute_value("DstPortHigh", dst_porthigh) - classifier.set_attribute_value("Protocol", protocol) - classifier.set_attribute_value("Priority", priority) - sflow = ns3_desc.create("ns3::ServiceFlow") - sflow.set_attribute_value("Direction", direction) - sflow.set_attribute_value("SchedulingType", scheduling_type) - sflow.connector("classif").connect(classifier.connector("sflow")) - ss.connector("sflows").connect(sflow.connector("dev")) - - def add_netns_tap(self, netns_desc, node): - tap = netns_desc.create("TapNodeInterface") - tap.set_attribute_value("up", True) - node.connector("devs").connect(tap.connector("node")) - return tap - - def add_ns3_fdnd(self, ns3_desc, node): - fdnd = ns3_desc.create("ns3::FdNetDevice") - node.connector("devs").connect(fdnd.connector("node")) - fdnd.enable_trace("FdPcapTrace") - return fdnd - - def add_ip_address(self, iface, address, netprefix): - ip = iface.add_address() - ip.set_attribute_value("Address", address) - ip.set_attribute_value("NetPrefix", netprefix) - - def add_route(self, node, destination, netprefix, nexthop): - route = node.add_route() - route.set_attribute_value("Destination", destination) - route.set_attribute_value("NetPrefix", netprefix) - route.set_attribute_value("NextHop", nexthop) - - def run(self): - base_addr = "192.168.4.%d" - exp_desc = ExperimentDescription() - - # NS3 - ns3_provider = FactoriesProvider("ns3") - ns3_desc = exp_desc.add_testbed_description(ns3_provider) - ns3_desc.set_attribute_value("homeDirectory", self.root_dir) - ns3_desc.set_attribute_value("SimulatorImplementationType", "ns3::RealtimeSimulatorImpl") - ns3_desc.set_attribute_value("ChecksumEnabled", True) - - ## WIMAX network 32/27 - node_bs = self.add_ns3_node(ns3_desc) - node_ss1 = self.add_ns3_node(ns3_desc) - node_ss2 = self.add_ns3_node(ns3_desc) - node_ss3 = self.add_ns3_node(ns3_desc) - node_ss4 = self.add_ns3_node(ns3_desc) - node_ss5 = self.add_ns3_node(ns3_desc) - node_ss6 = self.add_ns3_node(ns3_desc) - - wimax_channel = ns3_desc.create("ns3::SimpleOfdmWimaxChannel") - - bs = self.add_ns3_wimax_bs(ns3_desc, node_bs, wimax_channel) - ss1 = self.add_ns3_wimax_ss(ns3_desc, node_ss1, wimax_channel) - ss2 = self.add_ns3_wimax_ss(ns3_desc, node_ss2, wimax_channel) - ss3 = self.add_ns3_wimax_ss(ns3_desc, node_ss3, wimax_channel) - ss4 = self.add_ns3_wimax_ss(ns3_desc, node_ss4, wimax_channel) - ss5 = self.add_ns3_wimax_ss(ns3_desc, node_ss5, wimax_channel) - ss6 = self.add_ns3_wimax_ss(ns3_desc, node_ss6, wimax_channel) - - self.add_ip_address(bs, (base_addr%33), 27) - self.add_ip_address(ss1, (base_addr%34), 27) - self.add_ip_address(ss2, (base_addr%35), 27) - self.add_ip_address(ss3, (base_addr%36), 27) - self.add_ip_address(ss4, (base_addr%37), 27) - self.add_ip_address(ss5, (base_addr%38), 27) - self.add_ip_address(ss6, (base_addr%39), 27) - - #self.add_ns3_service_flow(ns3_desc, ss1, "0.0.0.0", "0.0.0.0", - # "10.1.1.1", "255.255.255.255", 0, 65000, 100, 100, - # "UdpL4Protocol", 1, "SF_DIRECTION_DOWN", "SF_TYPE_RTPS") - #self.add_ns3_service_flow(ns3_desc, ss2, "10.1.1.2", "255.255.255.255", - # "0.0.0.0", "0.0.0.0", 0, 65000, 100, 100, "UdpL4Protocol", - # 1, "SF_DIRECTION_UP", "SF_TYPE_RTPS") - - self.add_ns3_service_flow(ns3_desc, ss1, "0.0.0.0", "0.0.0.0", - "192.168.4.35", "255.255.255.225", 0, 65000, 11, 11, "Icmpv4L4Protocol", - 1, "SF_DIRECTION_DOWN", "SF_TYPE_RTPS") - - self.add_ns3_service_flow(ns3_desc, ss2, "192.168.4.34", "255.255.255.255", - "0.0.0.0", "0.0.0.0", 0, 65000, 11, 11, "Icmpv4L4Protocol", - 1, "SF_DIRECTION_UP", "SF_TYPE_RTPS") - - ## Point-to-Point wimax/fdnd 224/30 - node_fdnd = self.add_ns3_node(ns3_desc) - p2p_channel = ns3_desc.create("ns3::PointToPointChannel") - - p2p1 = self.add_ns3_p2p(ns3_desc, node_ss1, p2p_channel) - p2p2 = self.add_ns3_p2p(ns3_desc, node_fdnd, p2p_channel) - - self.add_ip_address(p2p1, (base_addr%225), 30) - self.add_ip_address(p2p2, (base_addr%226), 30) - - # NETNS - netns_provider = FactoriesProvider("netns") - netns_desc = exp_desc.add_testbed_description(netns_provider) - netns_desc.set_attribute_value("homeDirectory", self.root_dir) - netns_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) - netns_root_dir = os.path.join(self.root_dir, "netns_instance") - os.mkdir(netns_root_dir) - netns_desc.set_attribute_value(DC.ROOT_DIRECTORY, netns_root_dir) - netns_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) - netns_desc.set_attribute_value(DC.USE_SUDO, True) - - node_netns = netns_desc.create("Node") - node_netns.set_attribute_value("forward_X11", True) - tap = self.add_netns_tap(netns_desc, node_netns) - - command = "xterm" - app = netns_desc.create("Application") - app.set_attribute_value("command", command) - app.set_attribute_value("user", self.user) - app.connector("node").connect(node_netns.connector("apps")) - - ## Point-to-Point NS3::fdnd/NETNS::tap 228/30 - fdnd = self.add_ns3_fdnd(ns3_desc, node_fdnd) - - fdnd.connector("->fd").connect(tap.connector("fd->")) - - self.add_ip_address(fdnd, (base_addr%229), 30) - self.add_ip_address(tap, (base_addr%230), 30) - - # ROUTES - self.add_route(node_netns, (base_addr%32), 27, (base_addr%229)) - self.add_route(node_netns, (base_addr%224), 30, (base_addr%229)) - - self.add_route(node_fdnd, (base_addr%32), 27, (base_addr%225)) - self.add_route(node_ss1, (base_addr%228), 30, (base_addr%226)) - - self.add_route(node_ss2, (base_addr%224), 30, (base_addr%34)) - self.add_route(node_ss2, (base_addr%228), 30, (base_addr%34)) - self.add_route(node_bs, (base_addr%224), 30, (base_addr%34)) - self.add_route(node_bs, (base_addr%228), 30, (base_addr%34)) - - - xml = exp_desc.to_xml() - controller = ExperimentController(xml, self.root_dir) - controller.start() - while not controller.is_finished(app.guid): - time.sleep(0.5) - time.sleep(0.1) - controller.stop() - controller.shutdown() - - def clean(self): - #shutil.rmtree(self.root_dir) - print self.root_dir - pass - -if __name__ == '__main__': - example = WimaxOverlayExample() - example.run() - example.clean() - diff --git a/examples/wireless_overlay.py b/examples/wireless_overlay.py deleted file mode 100755 index d735f560..00000000 --- a/examples/wireless_overlay.py +++ /dev/null @@ -1,430 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -from nepi.core.design import ExperimentDescription, FactoriesProvider -from nepi.core.execute import ExperimentController -from optparse import OptionParser, SUPPRESS_HELP -from nepi.util import proxy -from nepi.util.constants import DeploymentConfiguration as DC, ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP -import test_util -import os -import shutil -import tempfile -import itertools -import time -import math - -""" - - ___________________________________________________________ - | NETNS | - | | - | __________ | - | |netns_node| VLC_SERVER | - | |__________| | - | | - | 1/30 | - | ----------- | - |_________________________|_________________________________| - | - | 0/30 - _________________________|_________________________________ - | PL1 | | - | ------------ | - | 2/30 | - | | - | 5/30 | - | ------------- | - |_________________________|_________________________________| - | - | 4/30 - _________________________|_________________________________ - | NS-3 | | - | -------- | - | 6/30 | - | ______ | - | | AP | | - | |______| | - | 33/27 | - | -------- | - | ((*)) | - | | - | | - | ((*)) ((*)) ((*)) ((*)) | - | ------- -------- ------- ------- | - | 34/27 35/27 36/27 37/27 | - | +-----+ +-----+ +-----+ +-----+ | - | |sta0 | |sta1 | |sta2 | |sta3 | | - | +-----+ +-----+ +-----+ +-----+ | - | 66/30 70/30 74/30 78/30 | - | ------- ------- ------- ------- | - |_______|___________|__________|__________|_________________| - | | | | - ______|____ ____|____ ___|____ ___|____ - | PL2 | | |PL3 | | |PL4| | |PL5| | - | | | | | | | | | | | | - | ------- | | ------- | | ------ | |------- | - | 65/30 | | 69/30 | | 73/30 | | 77/30 | - |___________| |_________| |________| |________| - -""" - -class WirelessOverlay(object): - def __init__(self): - usage = "usage: %prog -n number_sta -m movie -u user" - parser = OptionParser(usage=usage) - parser.add_option("-u", "--user", dest="user", help="Valid linux system user (not root).", type="str") - parser.add_option("-m", "--movie", dest="movie", help="Path to movie file to play", type="str") - parser.add_option("-n", "--nsta", dest="nsta", help="Number of wifi stations", type="int") - parser.add_option("-a", "--base_addr", dest="base_addr", help="Base address segment for the experiment", type="str") - parser.add_option("-s", "--slicename", dest="slicename", help="PlanetLab slice", type="str") - (options, args) = parser.parse_args() - if not options.movie: - parser.error("Missing 'movie' option.") - if options.user == 'root': - parser.error("Missing or invalid 'user' option.") - if options.user == 'root': - parser.error("Missing or invalid 'user' option.") - if options.nsta and options.nsta > 8: - parser.error("Try a number of stations under 9.") - - self.user = options.user if options.user else os.getlogin() - self.movie = options.movie - self.nsta = options.nsta if options.nsta else 3 - self.slicename = options.slicename if options.slicename else "inria_nepi3" - base = options.base_addr if options.base_addr else "192.168.4" - self.base_addr = base + ".%d" - self.root_dir = tempfile.mkdtemp() - - def add_ip_address(self, iface, address, netprefix): - ip = iface.add_address() - ip.set_attribute_value("Address", address) - ip.set_attribute_value("NetPrefix", netprefix) - - def add_route(self, node, destination, netprefix, nexthop): - route = node.add_route() - route.set_attribute_value("Destination", destination) - route.set_attribute_value("NetPrefix", netprefix) - route.set_attribute_value("NextHop", nexthop) - - def add_ns3_fdnd(self, ns3_desc, node): - fdnd = ns3_desc.create("ns3::FdNetDevice") - node.connector("devs").connect(fdnd.connector("node")) - #fdnd.enable_trace("FdPcapTrace") - return fdnd - - def add_ns3_node(self, ns3_desc): - node = ns3_desc.create("ns3::Node") - ipv4 = ns3_desc.create("ns3::Ipv4L3Protocol") - arp = ns3_desc.create("ns3::ArpL3Protocol") - icmp = ns3_desc.create("ns3::Icmpv4L4Protocol") - udp = ns3_desc.create("ns3::UdpL4Protocol") - node.connector("protos").connect(ipv4.connector("node")) - node.connector("protos").connect(arp.connector("node")) - node.connector("protos").connect(icmp.connector("node")) - node.connector("protos").connect(udp.connector("node")) - return node - - def add_ns3_wifi(self, ns3_desc, node, access_point = False): - wifi = ns3_desc.create("ns3::WifiNetDevice") - node.connector("devs").connect(wifi.connector("node")) - - phy = ns3_desc.create("ns3::YansWifiPhy") - error = ns3_desc.create("ns3::NistErrorRateModel") - manager = ns3_desc.create("ns3::ArfWifiManager") - if access_point: - mac = ns3_desc.create("ns3::ApWifiMac") - else: - mac = ns3_desc.create("ns3::StaWifiMac") - - phy.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a") - mac.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a") - phy.connector("err").connect(error.connector("phy")) - wifi.connector("phy").connect(phy.connector("dev")) - wifi.connector("mac").connect(mac.connector("dev")) - wifi.connector("manager").connect(manager.connector("dev")) - - #phy.enable_trace("YansWifiPhyPcapTrace") - return wifi, phy - - def add_ns3_constant_mobility(self, ns3_desc, node, x, y, z): - mobility = ns3_desc.create("ns3::ConstantPositionMobilityModel") - position = "%d:%d:%d" % (x, y, z) - mobility.set_attribute_value("Position", position) - node.connector("mobility").connect(mobility.connector("node")) - return mobility - - def add_ns3_wifi_channel(self, ns3_desc): - channel = ns3_desc.create("ns3::YansWifiChannel") - delay = ns3_desc.create("ns3::ConstantSpeedPropagationDelayModel") - loss = ns3_desc.create("ns3::LogDistancePropagationLossModel") - channel.connector("delay").connect(delay.connector("chan")) - channel.connector("loss").connect(loss.connector("prev")) - return channel - - def add_pl_testbed(self, exp_desc): - plchost = "nepiplc.pl.sophia.inria.fr" - port_base = 2000 + (os.getpid() % 1000) * 13 - pl_ssh_key = os.environ.get( - "PL_SSH_KEY", - "%s/.ssh/id_rsa_planetlab" % (os.environ['HOME'],) ) - pl_user, pl_pwd = test_util.pl_auth() - - pl_provider = FactoriesProvider("planetlab") - pl_desc = exp_desc.add_testbed_description(pl_provider) - pl_desc.set_attribute_value("homeDirectory", self.root_dir) - pl_desc.set_attribute_value("slice", self.slicename) - pl_desc.set_attribute_value("sliceSSHKey", pl_ssh_key) - pl_desc.set_attribute_value("authUser", pl_user) - pl_desc.set_attribute_value("authPass", pl_pwd) - pl_desc.set_attribute_value("plcHost", plchost) - pl_desc.set_attribute_value("tapPortBase", port_base) - pl_desc.set_attribute_value("p2pDeployment", False) # it's interactive, we don't want it in tests - pl_desc.set_attribute_value("dedicatedSlice", True) - pl_desc.set_attribute_value("plLogLevel", "DEBUG") - return pl_desc - - def add_pl_node(self, pl_desc, inet, label_prefix): - node = pl_desc.create("Node") - node.set_attribute_value("label", label_prefix) - iface = pl_desc.create("NodeInterface") - iface.set_attribute_value("label", label_prefix+"iface") - iface.connector("inet").connect(inet.connector("devs")) - node.connector("devs").connect(iface.connector("node")) - forwarder = pl_desc.create("MulticastForwarder") - forwarder.enable_trace("stderr") - node.connector("apps").connect(forwarder.connector("node")) - return node, iface - - def add_ns3_in_pl(self, exp_desc, pl_desc, pl_node, pl_iface, root): - # Add NS3 support in node - plnepi = pl_desc.create("NepiDependency") - plns3 = pl_desc.create("NS3Dependency") - plnepi.connector("node").connect(pl_node.connector("deps")) - plns3.connector("node").connect(pl_node.connector("deps")) - - # Create NS3 testbed running in pl_node - ns3_provider = FactoriesProvider("ns3") - ns3_desc = exp_desc.add_testbed_description(ns3_provider) - ns3_desc.set_attribute_value("rootDirectory", root) - ns3_desc.set_attribute_value("SimulatorImplementationType", "ns3::RealtimeSimulatorImpl") - ns3_desc.set_attribute_value("ChecksumEnabled", True) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_HOST, "{#[%s].addr[0].[Address]#}" % ( - pl_iface.get_attribute_value("label"),)) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_USER, - pl_desc.get_attribute_value("slice")) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_KEY, - pl_desc.get_attribute_value("sliceSSHKey")) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH) - ns3_desc.set_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP, - "{#[%s].[%s]#}" % ( - pl_node.get_attribute_value("label"), - ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP,)) - ns3_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) - return ns3_desc - - def add_netns_testbed(self, exp_desc): - netns_provider = FactoriesProvider("netns") - netns_desc = exp_desc.add_testbed_description(netns_provider) - netns_desc.set_attribute_value("homeDirectory", self.root_dir) - netns_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) - netns_root_dir = os.path.join(self.root_dir, "netns") - os.mkdir(netns_root_dir) - netns_desc.set_attribute_value(DC.ROOT_DIRECTORY, netns_root_dir) - netns_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) - netns_desc.set_attribute_value(DC.USE_SUDO, True) - return netns_desc - - def add_netns_node(self, netns_desc): - node = netns_desc.create("Node") - node.set_attribute_value("forward_X11", True) - return node - - def add_pl_ns3_connection(self, pl_desc, pl_node, pl_addr, - ns3_desc, ns3_node, ns3_addr): - pl_tap = pl_desc.create("TapInterface") - pl_tap.set_attribute_value("tun_cipher", "PLAIN") - self.add_ip_address(pl_tap, pl_addr, 30) - pl_node.connector("devs").connect(pl_tap.connector("node")) - ns3_fdnd = ns3_desc.create("ns3::FdNetDevice") - ns3_node.connector("devs").connect(ns3_fdnd.connector("node")) - self.add_ip_address(ns3_fdnd, ns3_addr, 30) - pl_tap.connector("fd->").connect(ns3_fdnd.connector("->fd")) - - def add_pl_ns3_tunchan_connection(self, pl_desc, pl_node, pl_addr, - ns3_desc, ns3_node, ns3_addr): - pl_tap = pl_desc.create("TunInterface") - self.add_ip_address(pl_tap, pl_addr, 30) - pl_node.connector("devs").connect(pl_tap.connector("node")) - ns3_fdnd = ns3_desc.create("ns3::FdNetDevice") - ns3_fdnd.enable_trace("FdPcapTrace") - self.add_ip_address(ns3_fdnd, ns3_addr, 30) - ns3_node.connector("devs").connect(ns3_fdnd.connector("node")) - ns3_tc = ns3_desc.create("ns3::Nepi::TunChannel") - ns3_tc.connector("fd->").connect(ns3_fdnd.connector("->fd")) - pl_tap.connector("tcp").connect(ns3_tc.connector("tcp")) - - def add_pl_netns_connection(self, pl_desc, pl_node, pl_addr, - netns_desc, netns_node, netns_addr): - pl_tap = pl_desc.create("TunInterface") - #pl_tap.set_attribute_value("tun_cipher", "PLAIN") - pl_tap.set_attribute_value("multicast", True) - #pl_tap.enable_trace("pcap") - #pl_tap.enable_trace("packets") - self.add_ip_address(pl_tap, pl_addr, 30) - pl_node.connector("devs").connect(pl_tap.connector("node")) - netns_tap = netns_desc.create("TunNodeInterface") - netns_tap.set_attribute_value("up", True) - netns_tap.set_attribute_value("mtu", 1448) - self.add_ip_address(netns_tap, netns_addr, 30) - netns_node.connector("devs").connect(netns_tap.connector("node")) - netns_tunchannel = netns_desc.create("TunChannel") - #netns_tunchannel.set_attribute_value("tun_cipher", "PLAIN") - netns_tunchannel.connector("->fd").connect(netns_tap.connector("fd->")) - pl_tap.connector("tcp").connect(netns_tunchannel.connector("tcp")) - - def run(self): - exp_desc = ExperimentDescription() - - ## PL ## - pl_desc = self.add_pl_testbed(exp_desc) - pl_inet = pl_desc.create("Internet") - pl_node1, pl_iface1 = self.add_pl_node(pl_desc, pl_inet, - "node1_pl") - - ## NETNS ## - netns_desc = self.add_netns_testbed(exp_desc) - netns_node = self.add_netns_node(netns_desc) - - ## NS3 ## - ns3_desc = self.add_ns3_in_pl(exp_desc, pl_desc, pl_node1, pl_iface1, "ns3") - wifi_chan = self.add_ns3_wifi_channel(ns3_desc) - - # AP node - ap_node = self.add_ns3_node(ns3_desc) - self.add_ns3_constant_mobility(ns3_desc, ap_node, 0, 0, 0) - ap_wifi, ap_phy = self.add_ns3_wifi(ns3_desc, ap_node, access_point = True) - self.add_ip_address(ap_wifi, (self.base_addr%33), 27) - ap_phy.connector("chan").connect(wifi_chan.connector("phys")) - - # wifi network 32/27 - r = 50 - # STA nodes - for i in xrange(0, self.nsta): - stai = self.add_ns3_node(ns3_desc) - angi = (360/self.nsta)*i - xi = r*math.cos(angi) - yi = r*math.sin(angi) - self.add_ns3_constant_mobility(ns3_desc, stai, xi, yi, 0) - wifi, phy= self.add_ns3_wifi(ns3_desc, stai, access_point = False) - wifi_addr = self.base_addr%(34 + i) - self.add_ip_address(wifi, wifi_addr, 27) - phy.connector("chan").connect(wifi_chan.connector("phys")) - - self.add_route(stai, (self.base_addr%0), 30, (self.base_addr%33)) - self.add_route(stai, (self.base_addr%4), 30, (self.base_addr%33)) - - net = 64 + i*4 - pl_nodei, pl_ifacei = self.add_pl_node(pl_desc, pl_inet, - "node2%d_pl"%i) - - pl_addr = (self.base_addr%(net+1)) - ns3_addr = (self.base_addr%(net+2)) - self.add_pl_ns3_tunchan_connection(pl_desc, pl_nodei, pl_addr, - ns3_desc, stai, ns3_addr) - self.add_route(pl_nodei, (self.base_addr%32), 27, ns3_addr) - self.add_route(pl_nodei, (self.base_addr%0), 30, ns3_addr) - self.add_route(pl_nodei, (self.base_addr%4), 30, ns3_addr) - - network = (self.base_addr%net) - self.add_route(netns_node, network, 30, (self.base_addr%2)) - self.add_route(pl_node1, network, 30, (self.base_addr%6)) - self.add_route(ap_node, network, 30, wifi_addr) - - # connection PL1/NETNS - pl_addr = (self.base_addr%2) - netns_addr = (self.base_addr%1) - self.add_pl_netns_connection(pl_desc, pl_node1, pl_addr, - netns_desc, netns_node, netns_addr) - - # connection PL1/NS3 - pl_addr = (self.base_addr%5) - ns3_addr = (self.base_addr%6) - self.add_pl_ns3_connection(pl_desc, pl_node1, pl_addr, - ns3_desc, ap_node, ns3_addr) - - # APPLICATIONS - command = "xterm" - app = netns_desc.create("Application") - app.set_attribute_value("command", command) - app.set_attribute_value("user", self.user) - app.connector("node").connect(netns_node.connector("apps")) - - # applications - #target = "{#[%s].addr[0].[Address]#}" % label - servers = [] - clients = [] - net = 0 - target = self.base_addr%2 - local = self.base_addr%1 - port = 5065 - command = "sleep 2; vlc -I dummy %s --miface-addr=%s --sout '#udp{dst=%s:%d}' vlc://quit" \ - % (local,self.movie, target, port) - vlc_server = netns_desc.create("Application") - vlc_server.set_attribute_value("command", command) - vlc_server.set_attribute_value("user", self.user) - vlc_server.connector("node").connect(netns_node.connector("apps")) - servers.append(vlc_server.guid) - - command = "sudo dbus-uuidgen --ensure; vlc -vvv -I dummy udp://@%s:%d --sout '#std{access=file,mux=ts,dst=big_buck_bunny_stream.ts}' " % (target, port) - vlc_client = pl_desc.create("Application") - vlc_client.set_attribute_value("buildDepends", "vlc") - vlc_client.set_attribute_value("rpmFusion", True) - vlc_client.set_attribute_value("command", command) - vlc_client.enable_trace("stdout") - vlc_client.enable_trace("stderr") - vlc_client.connector("node").connect(pl_node1.connector("apps")) - clients.append(vlc_client.guid) - - # ROUTES - self.add_route(netns_node, (self.base_addr%32), 27, (self.base_addr%2)) - self.add_route(netns_node, (self.base_addr%4), 30, (self.base_addr%2)) - - self.add_route(pl_node1, (self.base_addr%32), 27, (self.base_addr%6)) - - self.add_route(ap_node, (self.base_addr%0), 30, (self.base_addr%5)) - - xml = exp_desc.to_xml() - controller = ExperimentController(xml, self.root_dir) - controller.start() - while not controller.is_finished(app.guid): - time.sleep(0.5) - time.sleep(0.1) - controller.stop() - controller.shutdown() - - """ - xml = exp_desc.to_xml() - controller = ExperimentController(xml, self.root_dir) - controller.start() - stop = False - while not stop: - time.sleep(0.5) - stop = True - for guid in clients: - if not controller.is_finished(guid): - stop = False - time.sleep(0.1) - controller.stop() - controller.shutdown() - """ - - def clean(self): - shutil.rmtree(self.root_dir) - -if __name__ == '__main__': - example = WirelessOverlay() - example.run() - example.clean() -