examples/planetlab_ccnd.py

   1 #!/usr/bin/env python
   2
   3 from nepi.core.design import ExperimentDescription, FactoriesProvider
   4 from nepi.core.execute import ExperimentController
   5 import ipaddr
   6 import math
   7 from optparse import OptionParser, SUPPRESS_HELP
   8 import os
   9 import signal
  10 import string
  11 import tempfile
  12 import time
  13
  14 # Trak SIGTERM, and set global termination flag instead of dying
  15 TERMINATE = []
  16 def _finalize(sig,frame):
  17     global TERMINATE
  18     TERMINATE.append(None)
  19 signal.signal(signal.SIGTERM, _finalize)
  20 signal.signal(signal.SIGINT, _finalize)
  21
  22 def create_slice_desc(slicename, plc_host, pl_user, pl_pwd, pl_ssh_key,
  23         port_base, root_dir, exp_desc):
  24     pl_provider = FactoriesProvider("planetlab")
  25     slice_desc = exp_desc.add_testbed_description(pl_provider)
  26     slice_desc.set_attribute_value("homeDirectory", root_dir)
  27     slice_desc.set_attribute_value("slice", slicename)
  28     slice_desc.set_attribute_value("sliceSSHKey", pl_ssh_key)
  29     slice_desc.set_attribute_value("authUser", pl_user)
  30     slice_desc.set_attribute_value("authPass", pl_pwd)
  31     slice_desc.set_attribute_value("plcHost", plc_host)
  32     slice_desc.set_attribute_value("tapPortBase", port_base)
  33     # Kills all running processes before starting the experiment
  34     slice_desc.set_attribute_value("dedicatedSlice", True)
  35     # Delets all directories in the slice's home directory of each node
  36     # ATTENTION: This will remove result files from previous runs!!
  37     slice_desc.set_attribute_value("cleanRoot", True)
  38     slice_desc.set_attribute_value("plLogLevel", "DEBUG")
  39     return slice_desc
  40
  41 def create_node(hostname, pl_inet, slice_desc):
  42     pl_node = slice_desc.create("Node")
  43     pl_node.set_attribute_value("hostname", hostname)
  44     pl_node.set_attribute_value("label", hostname)
  45     pl_iface = slice_desc.create("NodeInterface")
  46     #pl_iface.set_attribute_value("label", "iface_%s" % node)
  47     pl_iface.connector("inet").connect(pl_inet.connector("devs"))
  48     pl_node.connector("devs").connect(pl_iface.connector("node"))
  49     return pl_node
  50
  51 def create_tunnel(node, peer, pl_nodes, slice_desc, subnet):
  52     pl_node = pl_nodes[node]
  53     pl_peer = pl_nodes[peer]
  54
  55     pl_tun = slice_desc.create("TunInterface")
  56     pl_tun.set_attribute_value("label", "tun_%s%s" % (node, peer))
  57     pl_node.connector("devs").connect(pl_tun.connector("node"))
  58
  59     pl_tunpeer = slice_desc.create("TunInterface")
  60     pl_tunpeer.set_attribute_value("label", "tun_%s%s" % (peer, node))
  61     pl_peer.connector("devs").connect(pl_tunpeer.connector("node"))
  62
  63     pl_tun.connector("udp").connect(pl_tunpeer.connector("udp"))
  64
  65     iterhosts = subnet.iterhosts()
  66     addr = iterhosts.next()
  67     ip = pl_tun.add_address()
  68     ip.set_attribute_value("Address", addr.exploded)
  69     ip.set_attribute_value("NetPrefix", subnet.prefixlen)
  70
  71     peeraddr = iterhosts.next()
  72     peerip = pl_tunpeer.add_address()
  73     peerip.set_attribute_value("Address", peeraddr.exploded)
  74     peerip.set_attribute_value("NetPrefix", subnet.prefixlen)
  75
  76 def create_ccnd(pl_node, slice_desc):
  77     pl_app = slice_desc.create("CCNxDaemon")
  78     # Add multicast ccn route
  79     pl_app.set_attribute_value("ccnroutes", "udp 224.0.0.204 2869")
  80     pl_app.enable_trace("stdout")
  81     pl_app.enable_trace("stderr")
  82     pl_app.connector("node").connect(pl_node.connector("apps"))
  83
  84 def create_ccnpoke(pl_node, slice_desc):
  85     pl_app = slice_desc.create("Application")
  86     path_to_video = os.path.join(os.path.dirname(os.path.abspath(__file__)),
  87         "big_buck_bunny_240p_mpeg4_lq.ts")
  88     pl_app.set_attribute_value("stdin", path_to_video)
  89     #pl_app.set_attribute_value("command", "ccnsendchunks ccnx:/VIDEO")
  90     pl_app.set_attribute_value("command", "ccnpoke ccnx:/VIDEO")
  91     pl_app.enable_trace("stdout")
  92     pl_app.enable_trace("stderr")
  93     pl_app.connector("node").connect(pl_node.connector("apps"))
  94
  95 def create_local_ccncatchunks(hostname, ccn_bin):
  96     path = os.path.join(os.getcwd(), "ccncatchunks.sh")
  97     exec_ = ( "export PATH=$PATH:%(path_to_ccn_bin)s ; "
  98               "ccndstart ; "
  99               "ccndc add ccnx:/ udp %(hostname)s ; "
 100               "ccncatchunks2 ccnx:/VIDEO | vlc -"
 101             ) % dict(
 102                     hostname = hostname,
 103                     path_to_ccn_bin = ccn_bin,
 104                     )
 105
 106     f = open(path, "w")
 107     f.write(exec_)
 108     f.close()
 109
 110 def create_ed(hostnames, vsys_vnet, slicename, plc_host, pl_user, pl_pwd, pl_ssh_key,
 111         port_base, root_dir, ccn_bin):
 112
 113     # Create the experiment description object
 114     exp_desc = ExperimentDescription()
 115
 116     # Create the slice description object
 117     slice_desc = create_slice_desc(slicename, plc_host, pl_user, pl_pwd, pl_ssh_key,
 118         port_base, root_dir, exp_desc)
 119
 120     # Create the Internet box object
 121     pl_inet = slice_desc.create("Internet")
 122
 123     # Create the Node boxes
 124     pl_nodes = dict()
 125     for hostname in hostnames:
 126         pl_node = create_node(hostname, pl_inet, slice_desc)
 127         pl_nodes[hostname] = pl_node
 128
 129     # Get the base network segment (slice vsys_vnet) to assign all the IP addresses
 130     # to the virtual interfaces
 131     base = ipaddr.IPNetwork(vsys_vnet)
 132
 133     # Calculate the number of virtual networks required to connect all the nodes
 134     # with all other nodes as the binomial coeficient C(n, 2), with n = #nodes
 135     n = len(hostnames)
 136     c = math.factorial(n) / (2 * math.factorial(n-2))
 137
 138     # Validate that we can get 'c' /30 subnetworks
 139     if c > math.pow(2, (30 - base.prefixlen)):
 140         raise RuntimeError("Insufficient address segment %s for experiment", vsys_vnet)
 141
 142     # Create the subnetwors iterator
 143     iter_sub = base.iter_subnets(new_prefix=30)
 144
 145     # Create tunnels between nodes
 146     for i, node in enumerate(hostnames):
 147         peers = hostnames[i+1:]
 148         for peer in peers:
 149             subnet = iter_sub.next()
 150             create_tunnel(node, peer, pl_nodes, slice_desc, subnet)
 151
 152     # Create ccnd daemons in all nodes
 153     for pl_node in pl_nodes.values():
 154         create_ccnd(pl_node, slice_desc)
 155
 156     # Create a ccnpoke in a chosen node to publish some content
 157     hostname = pl_nodes.keys()[0]
 158     pl_node = pl_nodes[hostname]
 159     create_ccnpoke(pl_node, slice_desc)
 160
 161     create_local_ccncatchunks(hostname, ccn_bin)
 162
 163     return exp_desc
 164
 165 def run(hostnames, vsys_vnet, slicename, plc_host, pl_user, pl_pwd, pl_ssh_key,
 166         port_base, root_dir, ccn_bin):
 167
 168     exp_desc = create_ed(hostnames, vsys_vnet, slicename, plc_host, pl_user,
 169             pl_pwd, pl_ssh_key, port_base, root_dir, ccn_bin)
 170
 171     xml = exp_desc.to_xml()
 172     controller = ExperimentController(xml, root_dir)
 173     controller.start()
 174     while not TERMINATE:
 175         time.sleep(0.5)
 176
 177     controller.stop()
 178     controller.shutdown()
 179
 180
 181 if __name__ == '__main__':
 182     root_dir = tempfile.mkdtemp()
 183     slicename = os.environ.get("PL_SLICE")
 184     pl_host = os.environ.get("PL_HOST", "www.planet-lab.eu")
 185     port_base = 2000 + (os.getpid() % 1000) * 13
 186     pl_ssh_key = os.environ.get(
 187         "PL_SSH_KEY",
 188         "%s/.ssh/id_rsa_planetlab" % (os.environ['HOME'],) )
 189     pl_user = os.environ.get('PL_USER')
 190     pl_pwd = os.environ.get('PL_PASS')
 191     vsys_vnet = os.environ.get('PL_VSYS_NET')
 192     pl_ccn_bin = os.environ.get('PL_CCN_BIN')
 193     pl_hostnames = os.environ.get('PL_HOSTNAMES')
 194     default_hostnames = ['openlab02.pl.sophia.inria.fr',
 195                  'ple4.ipv6.lip6.fr',
 196                  'planetlab2.di.unito.it',
 197                  'merkur.planetlab.haw-hamburg.de',
 198                  #'planetlab1.cs.uit.no',
 199                  #'planetlab3.cs.st-andrews.ac.uk',
 200                  #'planetlab2.cs.uoi.gr',
 201                  #'planetlab3.xeno.cl.cam.ac.uk',
 202                  #'planet2.inf.tu-dresden.de',
 203                  #'planetlab2.csg.uzh.ch',
 204                  #'planetlab2.upm.ro',
 205                  #'planetlab-um00.di.uminho.pt',
 206                  #'planetlabpc2.upf.edu',
 207                  #'planet2.elte.hu',
 208                  'planetlab2.esprit-tn.com' ]
 209
 210
 211     usage = "usage: %prog -s <pl_slice> -H <pl_host> -b <ccn_bin> -k <ssh_key> -u <pl_user> -p <pl_password> -v <vsys_vnet> -N <host_names> "
 212     parser = OptionParser(usage=usage)
 213     parser.add_option("-s", "--slicename", dest="slicename", help="PlanetLab slicename", default=slicename, type="str")
 214     parser.add_option("-H", "--pl-host", dest="pl_host", help="PlanetLab site (e.g. www.planet-lab.eu)", default=pl_host, type="str")
 215     parser.add_option("-b", "--ccn-bin", dest="ccn_bin", help="Path to ccnx bin directory", default=pl_ccn_bin, type="str")
 216     parser.add_option("-k", "--ssh-key", dest="pl_ssh_key", help="Path to private ssh key used for PlanetLab authentication", default=pl_ssh_key, type="str")
 217     parser.add_option("-u", "--pl-user", dest="pl_user", help="PlanetLab account user (i.e. Registration email address)", default=pl_user, type="str")
 218     parser.add_option("-p", "--pl-pwd", dest="pl_pwd", help="PlanetLab account password", default=pl_pwd, type="str")
 219     parser.add_option("-v", "--vsys-vnet", dest="vsys_vnet", help="Value of the vsys_vnet tag addigned to your slice. (e.g. 192.168.3.0/16)", default=vsys_vnet, type="str")
 220     parser.add_option("-N", "--host-names", dest="hostnames", help="Comma separated list of PlanetLab hostnames to use", default=pl_hostnames, type="str")
 221     (options, args) = parser.parse_args()
 222
 223     hostnames = map(string.strip, options.hostnames.split(",")) if options.hostnames else default_hostnames
 224     vsys_vnet = options.vsys_vnet
 225     slicename = options.slicename
 226     pl_host = options.pl_host
 227     pl_user= options.pl_user
 228     pl_pwd = options.pl_pwd
 229     pl_ssh_key = options.pl_ssh_key
 230     ccn_bin = options.ccn_bin
 231
 232     run(hostnames, vsys_vnet, slicename, pl_host, pl_user, pl_pwd, pl_ssh_key,
 233             port_base, root_dir, ccn_bin)
 234