--- /dev/null
+#!/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
+
--- /dev/null
+#!/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
+
+++ /dev/null
-#!/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()
-
--- /dev/null
+#!/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
--- /dev/null
+#!/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()
--- /dev/null
+#!/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()
+++ /dev/null
-#!/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()
-
--- /dev/null
+#!/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()
+
+++ /dev/null
-#!/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()
-
+++ /dev/null
-#!/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()
-
+++ /dev/null
-#!/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()
-
+++ /dev/null
-#!/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()
-
git://git.onelab.eu / nepi.git / commitdiff