examples/wireless_overlay.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from nepi.core.design import ExperimentDescription, FactoriesProvider
   5 from nepi.core.execute import ExperimentController
   6 from optparse import OptionParser, SUPPRESS_HELP
   7 from nepi.util import proxy
   8 from nepi.util.constants import DeploymentConfiguration as DC, ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP
   9 import test_util
  10 import os
  11 import shutil
  12 import tempfile
  13 import itertools
  14 import time
  15 import math
  16
  17 """
  18
  19    ___________________________________________________________
  20   |   NETNS                                                   |
  21   |                                                           |
  22   |                    __________                             |
  23   |                   |netns_node|  VLC_SERVER                |
  24   |                   |__________|                            |
  25   |                                                           |
  26   |                       1/30                                |
  27   |                    -----------                            |
  28   |_________________________|_________________________________|
  29                             |
  30                             |  0/30
  31    _________________________|_________________________________
  32   |    PL1                  |                                 |
  33   |                   ------------                            |
  34   |                       2/30                                |
  35   |                                                           |
  36   |                       5/30                                |
  37   |                  -------------                            |
  38   |_________________________|_________________________________|
  39                             |
  40                             |   4/30
  41    _________________________|_________________________________
  42   |    NS-3                 |                                 |
  43   |                     --------                              |
  44   |                       6/30                                |
  45   |                      ______                               |
  46   |                     |  AP  |                              |
  47   |                     |______|                              |
  48   |                       33/27                               |
  49   |                     --------                              |
  50   |                       ((*))                               |
  51   |                                                           |
  52   |                                                           |
  53   |     ((*))       ((*))       ((*))     ((*))               |
  54   |    -------     --------    -------   -------              |
  55   |     34/27       35/27      36/27      37/27               |
  56   |    +-----+     +-----+    +-----+    +-----+              |
  57   |    |sta0 |     |sta1 |    |sta2 |    |sta3 |              |
  58   |    +-----+     +-----+    +-----+    +-----+              |
  59   |     66/30       70/30      74/30      78/30               |
  60   |    -------     -------    -------    -------              |
  61   |_______|___________|__________|__________|_________________|
  62           |           |          |          |
  63     ______|____   ____|____   ___|____   ___|____
  64    | PL2  |    | |PL3 |    | |PL4|    | |PL5|    |
  65    |      |    | |    |    | |   |    | |   |    |
  66    | -------   | | ------- | | ------ | |------- |
  67    |  65/30    | |  69/30  | | 73/30  | | 77/30  |
  68    |___________| |_________| |________| |________|
  69
  70 """
  71
  72 class WirelessOverlay(object):
  73     def __init__(self):
  74         usage = "usage: %prog -n number_sta -m movie -u user"
  75         parser = OptionParser(usage=usage)
  76         parser.add_option("-u", "--user", dest="user", help="Valid linux system user (not root).", type="str")
  77         parser.add_option("-m", "--movie", dest="movie", help="Path to movie file to play", type="str")
  78         parser.add_option("-n", "--nsta", dest="nsta", help="Number of wifi stations", type="int")
  79         parser.add_option("-a", "--base_addr", dest="base_addr", help="Base address segment for the experiment", type="str")
  80         parser.add_option("-s", "--slicename", dest="slicename", help="PlanetLab slice", type="str")
  81         (options, args) = parser.parse_args()
  82         if not options.movie:
  83             parser.error("Missing 'movie' option.")
  84         if options.user == 'root':
  85             parser.error("Missing or invalid 'user' option.")
  86         if options.user == 'root':
  87             parser.error("Missing or invalid 'user' option.")
  88         if options.nsta and options.nsta > 8:
  89             parser.error("Try a number of stations under 9.")
  90
  91         self.user = options.user if options.user else os.getlogin()
  92         self.movie = options.movie
  93         self.nsta = options.nsta if options.nsta else 3
  94         self.slicename = options.slicename if options.slicename else "inria_nepi3"
  95         base = options.base_addr if options.base_addr else "192.168.4"
  96         self.base_addr = base + ".%d"
  97         self.root_dir = tempfile.mkdtemp()
  98
  99     def add_ip_address(self, iface, address, netprefix):
 100         ip = iface.add_address()
 101         ip.set_attribute_value("Address", address)
 102         ip.set_attribute_value("NetPrefix", netprefix)
 103
 104     def add_route(self, node, destination, netprefix, nexthop):
 105         route = node.add_route()
 106         route.set_attribute_value("Destination", destination)
 107         route.set_attribute_value("NetPrefix", netprefix)
 108         route.set_attribute_value("NextHop", nexthop)
 109
 110     def add_ns3_fdnd(self, ns3_desc, node):
 111         fdnd = ns3_desc.create("ns3::FdNetDevice")
 112         node.connector("devs").connect(fdnd.connector("node"))
 113         #fdnd.enable_trace("FdPcapTrace")
 114         return fdnd
 115
 116     def add_ns3_node(self, ns3_desc):
 117         node = ns3_desc.create("ns3::Node")
 118         ipv4 = ns3_desc.create("ns3::Ipv4L3Protocol")
 119         arp  = ns3_desc.create("ns3::ArpL3Protocol")
 120         icmp = ns3_desc.create("ns3::Icmpv4L4Protocol")
 121         udp = ns3_desc.create("ns3::UdpL4Protocol")
 122         node.connector("protos").connect(ipv4.connector("node"))
 123         node.connector("protos").connect(arp.connector("node"))
 124         node.connector("protos").connect(icmp.connector("node"))
 125         node.connector("protos").connect(udp.connector("node"))
 126         return node
 127
 128     def add_ns3_wifi(self, ns3_desc, node, access_point = False):
 129         wifi = ns3_desc.create("ns3::WifiNetDevice")
 130         node.connector("devs").connect(wifi.connector("node"))
 131
 132         phy = ns3_desc.create("ns3::YansWifiPhy")
 133         error = ns3_desc.create("ns3::NistErrorRateModel")
 134         manager = ns3_desc.create("ns3::ArfWifiManager")
 135         if access_point:
 136             mac = ns3_desc.create("ns3::ApWifiMac")
 137         else:
 138             mac = ns3_desc.create("ns3::StaWifiMac")
 139
 140         phy.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a")
 141         mac.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a")
 142         phy.connector("err").connect(error.connector("phy"))
 143         wifi.connector("phy").connect(phy.connector("dev"))
 144         wifi.connector("mac").connect(mac.connector("dev"))
 145         wifi.connector("manager").connect(manager.connector("dev"))
 146
 147         #phy.enable_trace("YansWifiPhyPcapTrace")
 148         return wifi, phy
 149
 150     def add_ns3_constant_mobility(self, ns3_desc, node, x, y, z):
 151         mobility = ns3_desc.create("ns3::ConstantPositionMobilityModel")
 152         position = "%d:%d:%d" % (x, y, z)
 153         mobility.set_attribute_value("Position", position)
 154         node.connector("mobility").connect(mobility.connector("node"))
 155         return mobility
 156
 157     def add_ns3_wifi_channel(self, ns3_desc):
 158         channel = ns3_desc.create("ns3::YansWifiChannel")
 159         delay = ns3_desc.create("ns3::ConstantSpeedPropagationDelayModel")
 160         loss  = ns3_desc.create("ns3::LogDistancePropagationLossModel")
 161         channel.connector("delay").connect(delay.connector("chan"))
 162         channel.connector("loss").connect(loss.connector("prev"))
 163         return channel
 164
 165     def add_pl_testbed(self, exp_desc):
 166         plchost = "nepiplc.pl.sophia.inria.fr"
 167         port_base = 2000 + (os.getpid() % 1000) * 13
 168         pl_ssh_key = os.environ.get(
 169             "PL_SSH_KEY",
 170             "%s/.ssh/id_rsa_planetlab" % (os.environ['HOME'],) )
 171         pl_user, pl_pwd = test_util.pl_auth()
 172
 173         pl_provider = FactoriesProvider("planetlab")
 174         pl_desc = exp_desc.add_testbed_description(pl_provider)
 175         pl_desc.set_attribute_value("homeDirectory", self.root_dir)
 176         pl_desc.set_attribute_value("slice", self.slicename)
 177         pl_desc.set_attribute_value("sliceSSHKey", pl_ssh_key)
 178         pl_desc.set_attribute_value("authUser", pl_user)
 179         pl_desc.set_attribute_value("authPass", pl_pwd)
 180         pl_desc.set_attribute_value("plcHost", plchost)
 181         pl_desc.set_attribute_value("tapPortBase", port_base)
 182         pl_desc.set_attribute_value("p2pDeployment", False) # it's interactive, we don't want it in tests
 183         #pl_desc.set_attribute_value("dedicatedSlice", True)
 184         pl_desc.set_attribute_value("plLogLevel", "DEBUG")
 185         return pl_desc
 186
 187     def add_pl_node(self, pl_desc, inet, label_prefix):
 188         node = pl_desc.create("Node")
 189         node.set_attribute_value("label", label_prefix)
 190         iface = pl_desc.create("NodeInterface")
 191         iface.set_attribute_value("label", label_prefix+"iface")
 192         iface.connector("inet").connect(inet.connector("devs"))
 193         node.connector("devs").connect(iface.connector("node"))
 194         return node, iface
 195
 196     def add_ns3_in_pl(self, exp_desc, pl_desc, pl_node, pl_iface, root):
 197         # Add NS3 support in node
 198         plnepi = pl_desc.create("NepiDependency")
 199         plns3 = pl_desc.create("NS3Dependency")
 200         plnepi.connector("node").connect(pl_node.connector("deps"))
 201         plns3.connector("node").connect(pl_node.connector("deps"))
 202
 203         # Create NS3 testbed running in pl_node
 204         ns3_provider = FactoriesProvider("ns3")
 205         ns3_desc = exp_desc.add_testbed_description(ns3_provider)
 206         ns3_desc.set_attribute_value("rootDirectory", root)
 207         ns3_desc.set_attribute_value("SimulatorImplementationType", "ns3::RealtimeSimulatorImpl")
 208         ns3_desc.set_attribute_value("ChecksumEnabled", True)
 209         ns3_desc.set_attribute_value(DC.DEPLOYMENT_HOST, "{#[%s].addr[0].[Address]#}" % (
 210             pl_iface.get_attribute_value("label"),))
 211         ns3_desc.set_attribute_value(DC.DEPLOYMENT_USER,
 212             pl_desc.get_attribute_value("slice"))
 213         ns3_desc.set_attribute_value(DC.DEPLOYMENT_KEY,
 214             pl_desc.get_attribute_value("sliceSSHKey"))
 215         ns3_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 216         ns3_desc.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH)
 217         ns3_desc.set_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP,
 218             "{#[%s].[%s]#}" % (
 219                 pl_node.get_attribute_value("label"),
 220                 ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP,))
 221         ns3_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
 222         return ns3_desc
 223
 224     def add_netns_testbed(self, exp_desc):
 225         netns_provider = FactoriesProvider("netns")
 226         netns_desc = exp_desc.add_testbed_description(netns_provider)
 227         netns_desc.set_attribute_value("homeDirectory", self.root_dir)
 228         netns_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
 229         netns_root_dir = os.path.join(self.root_dir, "netns")
 230         os.mkdir(netns_root_dir)
 231         netns_desc.set_attribute_value(DC.ROOT_DIRECTORY, netns_root_dir)
 232         netns_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
 233         netns_desc.set_attribute_value(DC.USE_SUDO, True)
 234         return netns_desc
 235
 236     def add_netns_node(self, netns_desc):
 237         node = netns_desc.create("Node")
 238         node.set_attribute_value("forward_X11", True)
 239         return node
 240
 241     def add_pl_ns3_connection(self, pl_desc, pl_node, pl_addr,
 242             ns3_desc, ns3_node, ns3_addr):
 243         pl_tap = pl_desc.create("TunInterface")
 244         pl_tap.set_attribute_value("tun_cipher", "PLAIN")
 245         self.add_ip_address(pl_tap, pl_addr, 30)
 246         pl_node.connector("devs").connect(pl_tap.connector("node"))
 247         ns3_fdnd = ns3_desc.create("ns3::FdNetDevice")
 248         ns3_node.connector("devs").connect(ns3_fdnd.connector("node"))
 249         self.add_ip_address(ns3_fdnd, ns3_addr, 30)
 250         pl_tap.connector("fd->").connect(ns3_fdnd.connector("->fd"))
 251
 252     def add_pl_ns3_tunchan_connection(self, pl_desc, pl_node, pl_addr,
 253             ns3_desc, ns3_node, ns3_addr):
 254         pl_tap = pl_desc.create("TunInterface")
 255         self.add_ip_address(pl_tap, pl_addr, 30)
 256         pl_node.connector("devs").connect(pl_tap.connector("node"))
 257         ns3_fdnd = ns3_desc.create("ns3::FdNetDevice")
 258         self.add_ip_address(ns3_fdnd, ns3_addr, 30)
 259         ns3_node.connector("devs").connect(ns3_fdnd.connector("node"))
 260         ns3_tc = ns3_desc.create("ns3::Nepi::TunChannel")
 261         ns3_tc.connector("fd->").connect(ns3_fdnd.connector("->fd"))
 262         pl_tap.connector("tcp").connect(ns3_tc.connector("tcp"))
 263
 264     def add_pl_netns_connection(self, pl_desc, pl_node, pl_addr,
 265             netns_desc, netns_node, netns_addr):
 266         pl_tap = pl_desc.create("TunInterface")
 267         pl_tap.set_attribute_value("tun_cipher", "PLAIN")
 268         #pl_tap.enable_trace("pcap")
 269         #pl_tap.enable_trace("packets")
 270         self.add_ip_address(pl_tap, pl_addr, 30)
 271         pl_node.connector("devs").connect(pl_tap.connector("node"))
 272         netns_tap = netns_desc.create("TunNodeInterface")
 273         netns_tap.set_attribute_value("up", True)
 274         netns_tap.set_attribute_value("mtu", 1448)
 275         self.add_ip_address(netns_tap, netns_addr, 30)
 276         netns_node.connector("devs").connect(netns_tap.connector("node"))
 277         netns_tunchannel = netns_desc.create("TunChannel")
 278         netns_tunchannel.set_attribute_value("tun_cipher", "PLAIN")
 279         netns_tunchannel.connector("->fd").connect(netns_tap.connector("fd->"))
 280         pl_tap.connector("tcp").connect(netns_tunchannel.connector("tcp"))
 281
 282     def run(self):
 283         exp_desc = ExperimentDescription()
 284
 285         ## PL ##
 286         pl_desc = self.add_pl_testbed(exp_desc)
 287         pl_inet = pl_desc.create("Internet")
 288         pl_node1, pl_iface1 = self.add_pl_node(pl_desc, pl_inet,
 289                 "node1_pl")
 290
 291         ## NETNS ##
 292         netns_desc = self.add_netns_testbed(exp_desc)
 293         netns_node = self.add_netns_node(netns_desc)
 294
 295         """
 296         ## NS3 ##
 297         ns3_desc = self.add_ns3_in_pl(exp_desc, pl_desc, pl_node1, pl_iface1, "ns3")
 298         wifi_chan = self.add_ns3_wifi_channel(ns3_desc)
 299
 300         # AP node
 301         ap_node = self.add_ns3_node(ns3_desc)
 302         self.add_ns3_constant_mobility(ns3_desc, ap_node, 0, 0, 0)
 303         ap_wifi, ap_phy = self.add_ns3_wifi(ns3_desc, ap_node, access_point = True)
 304         self.add_ip_address(ap_wifi, (self.base_addr%33), 27)
 305         ap_phy.connector("chan").connect(wifi_chan.connector("phys"))
 306
 307         # wifi network 32/27
 308         r = 50
 309         # STA nodes
 310         for i in xrange(0, self.nsta):
 311             stai = self.add_ns3_node(ns3_desc)
 312             angi = (360/self.nsta)*i
 313             xi = r*math.cos(angi)
 314             yi = r*math.sin(angi)
 315             self.add_ns3_constant_mobility(ns3_desc, stai, xi, yi, 0)
 316             wifi, phy= self.add_ns3_wifi(ns3_desc, stai, access_point = False)
 317             wifi_addr = self.base_addr%(34 + i)
 318             self.add_ip_address(wifi, wifi_addr, 27)
 319             phy.connector("chan").connect(wifi_chan.connector("phys"))
 320
 321             self.add_route(stai, (self.base_addr%0), 30, (self.base_addr%33))
 322             self.add_route(stai, (self.base_addr%4), 30, (self.base_addr%33))
 323
 324             net = 64 + i*4
 325             pl_nodei, pl_ifacei = self.add_pl_node(pl_desc, pl_inet,
 326                     "node2%d_pl"%i)
 327
 328             pl_addr = (self.base_addr%(net+1))
 329             ns3_addr = (self.base_addr%(net+2))
 330             self.add_pl_ns3_tunchan_connection(pl_desc, pl_nodei, pl_addr,
 331                 ns3_desc, stai, ns3_addr)
 332             self.add_route(pl_nodei, (self.base_addr%32), 27, ns3_addr)
 333             self.add_route(pl_nodei, (self.base_addr%0), 30, ns3_addr)
 334             self.add_route(pl_nodei, (self.base_addr%4), 30, ns3_addr)
 335
 336             network = (self.base_addr%net)
 337             self.add_route(netns_node, network, 30, (self.base_addr%2))
 338             self.add_route(pl_node1, network, 30, (self.base_addr%6))
 339             self.add_route(ap_node, network, 30, wifi_addr)
 340         """
 341         # connection PL1/NETNS
 342         pl_addr = (self.base_addr%2)
 343         netns_addr = (self.base_addr%1)
 344         self.add_pl_netns_connection(pl_desc, pl_node1, pl_addr,
 345             netns_desc, netns_node, netns_addr)
 346         """
 347         # connection PL1/NS3
 348         pl_addr = (self.base_addr%5)
 349         ns3_addr = (self.base_addr%6)
 350         self.add_pl_ns3_connection(pl_desc, pl_node1, pl_addr,
 351             ns3_desc, ap_node, ns3_addr)
 352         """
 353         # APPLICATIONS
 354         command = "xterm"
 355         app = netns_desc.create("Application")
 356         app.set_attribute_value("command", command)
 357         app.set_attribute_value("user", self.user)
 358         app.connector("node").connect(netns_node.connector("apps"))
 359
 360         # applications
 361         #target = "{#[%s].addr[0].[Address]#}" % label
 362         servers = []
 363         clients = []
 364         net = 0
 365         target = self.base_addr%2
 366         port = 5065
 367         command = "sleep 2; vlc -I dummy %s --sout '#udp{dst=%s:%d}' vlc://quit" \
 368             % (self.movie, target, port)
 369         vlc_server = netns_desc.create("Application")
 370         vlc_server.set_attribute_value("command", command)
 371         vlc_server.set_attribute_value("user", self.user)
 372         vlc_server.connector("node").connect(netns_node.connector("apps"))
 373         servers.append(vlc_server.guid)
 374
 375         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)
 376         vlc_client = pl_desc.create("Application")
 377         vlc_client.set_attribute_value("buildDepends", "vlc")
 378         vlc_client.set_attribute_value("rpmFusion", True)
 379         vlc_client.set_attribute_value("command", command)
 380         vlc_client.enable_trace("stdout")
 381         vlc_client.enable_trace("stderr")
 382         vlc_client.connector("node").connect(pl_node1.connector("apps"))
 383         clients.append(vlc_client.guid)
 384
 385         """
 386         # ROUTES
 387         self.add_route(netns_node, (self.base_addr%32), 27, (self.base_addr%2))
 388         self.add_route(netns_node, (self.base_addr%4), 30, (self.base_addr%2))
 389
 390         self.add_route(pl_node1, (self.base_addr%32), 27, (self.base_addr%6))
 391
 392         self.add_route(ap_node, (self.base_addr%0), 30, (self.base_addr%5))
 393         """
 394         xml = exp_desc.to_xml()
 395         controller = ExperimentController(xml, self.root_dir)
 396         controller.start()
 397         while not controller.is_finished(app.guid):
 398             time.sleep(0.5)
 399         time.sleep(0.1)
 400         controller.stop()
 401         controller.shutdown()
 402
 403         """
 404         xml = exp_desc.to_xml()
 405         controller = ExperimentController(xml, self.root_dir)
 406         controller.start()
 407         stop = False
 408         while not stop:
 409             time.sleep(0.5)
 410             stop = True
 411             for guid in clients:
 412                 if not controller.is_finished(guid):
 413                     stop = False
 414         time.sleep(0.1)
 415         controller.stop()
 416         controller.shutdown()
 417         """
 418
 419     def clean(self):
 420         shutil.rmtree(self.root_dir)
 421
 422 if __name__ == '__main__':
 423     example = WirelessOverlay()
 424     example.run()
 425     example.clean()
 426