2 # -*- coding: utf-8 -*-
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
17 user = os.environ.get('PL_USER')
18 pwd = os.environ.get('PL_PASS')
25 class Roads09Ns3PLExample(object):
26 testbed_id = "planetlab"
27 testbed_version = "01"
28 slicename = "inria_nepi"
29 plchost = "nepiplc.pl.sophia.inria.fr"
31 host1 = "nepi1.pl.sophia.inria.fr"
32 host2 = "nepi2.pl.sophia.inria.fr"
33 host3 = "nepi3.pl.sophia.inria.fr"
34 host4 = "nepi5.pl.sophia.inria.fr"
37 #usage = "usage: %prog -m movie -u user"
38 #parser = OptionParser(usage=usage)
39 #parser.add_option("-u", "--user", dest="user", help="Valid linux system user (not root).", type="str")
40 #parser.add_option("-m", "--movie", dest="movie", help="Path to movie file to play", type="str")
41 #(options, args) = parser.parse_args()
42 #if not options.movie:
43 # parser.error("Missing 'movie' option.")
44 #if options.user == 'root':
45 # parser.error("Missing or invalid 'user' option.")
47 #self.user = options.user if options.user else os.getlogin()
48 #self.movie = options.movie
51 print "Example requires PlanetLab authentication info (PL_USER and PL_PASS environment variables)"
54 self.root_dir = tempfile.mkdtemp()
57 def make_experiment_desc(self):
58 testbed_id = self.testbed_id
59 testbed_version = self.testbed_version
60 slicename = self.slicename
61 plchost = self.plchost
62 pl_ssh_key = os.environ.get(
64 "%s/.ssh/id_rsa_planetlab" % (os.environ['HOME'],) )
65 pl_user, pl_pwd = pl_auth()
67 exp_desc = ExperimentDescription()
68 pl_provider = FactoriesProvider(testbed_id, testbed_version)
69 pl_desc = exp_desc.add_testbed_description(pl_provider)
70 pl_desc.set_attribute_value("homeDirectory", self.root_dir)
71 pl_desc.set_attribute_value("slice", slicename)
72 pl_desc.set_attribute_value("sliceSSHKey", pl_ssh_key)
73 pl_desc.set_attribute_value("authUser", pl_user)
74 pl_desc.set_attribute_value("authPass", pl_pwd)
75 pl_desc.set_attribute_value("plcHost", plchost)
77 return pl_desc, exp_desc
79 def make_ns_in_pl(self, pl, exp, node1, iface1, root):
80 ns3_testbed_id = "ns3"
81 ns3_testbed_version = "3_9_RC3"
83 # Add NS3 support in node1
84 plnepi = pl.create("NepiDependency")
85 plns3 = pl.create("NS3Dependency")
86 plnepi.connector("node").connect(node1.connector("deps"))
87 plns3.connector("node").connect(node1.connector("deps"))
89 # Create NS3 testbed running in node1
90 ns3_provider = FactoriesProvider(ns3_testbed_id, ns3_testbed_version)
91 ns3_desc = exp.add_testbed_description(ns3_provider)
92 ns3_desc.set_attribute_value("rootDirectory", root)
93 ns3_desc.set_attribute_value("SimulatorImplementationType", "ns3::RealtimeSimulatorImpl")
94 ns3_desc.set_attribute_value("ChecksumEnabled", True)
95 ns3_desc.set_attribute_value(DC.DEPLOYMENT_HOST, "{#[%s].addr[0].[Address]#}" % (
96 iface1.get_attribute_value("label"),))
97 ns3_desc.set_attribute_value(DC.DEPLOYMENT_USER,
98 pl.get_attribute_value("slice"))
99 ns3_desc.set_attribute_value(DC.DEPLOYMENT_KEY,
100 pl.get_attribute_value("sliceSSHKey"))
101 ns3_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
102 ns3_desc.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH)
103 ns3_desc.set_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP,
105 node1.get_attribute_value("label"),
106 ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP,))
107 ns3_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
113 def add_ns3_fdnd(self, node, ns3_desc):
114 fdnd = ns3_desc.create("ns3::FileDescriptorNetDevice")
115 node.connector("devs").connect(fdnd.connector("node"))
116 fdnd.enable_trace("FileDescriptorPcapTrace")
119 def add_ns3_node(self, ns3_desc):
120 node = ns3_desc.create("ns3::Node")
121 ipv4 = ns3_desc.create("ns3::Ipv4L3Protocol")
122 arp = ns3_desc.create("ns3::ArpL3Protocol")
123 icmp = ns3_desc.create("ns3::Icmpv4L4Protocol")
124 udp = ns3_desc.create("ns3::UdpL4Protocol")
125 node.connector("protos").connect(ipv4.connector("node"))
126 node.connector("protos").connect(arp.connector("node"))
127 node.connector("protos").connect(icmp.connector("node"))
128 node.connector("protos").connect(udp.connector("node"))
131 def add_ns3_wifi(self, node, ns3_desc, access_point = False, ip = None, prefix = 24):
132 wifi = ns3_desc.create("ns3::WifiNetDevice")
133 node.connector("devs").connect(wifi.connector("node"))
135 phy = ns3_desc.create("ns3::YansWifiPhy")
136 error = ns3_desc.create("ns3::NistErrorRateModel")
137 manager = ns3_desc.create("ns3::ArfWifiManager")
139 mac = ns3_desc.create("ns3::QapWifiMac")
141 mac = ns3_desc.create("ns3::QstaWifiMac")
143 phy.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a")
144 mac.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211a")
145 phy.connector("err").connect(error.connector("phy"))
146 wifi.connector("phy").connect(phy.connector("dev"))
147 wifi.connector("mac").connect(mac.connector("dev"))
148 wifi.connector("manager").connect(manager.connector("dev"))
151 self.add_ip_address(wifi, ip, prefix)
153 phy.enable_trace("YansWifiPhyPcapTrace")
156 def add_ns3_random_mobility(self, node, ns3_desc, x, y, z, speed,
157 bounds_width, bounds_height):
158 position = "%f:%f:%f" % (x, y, z)
159 bounds = "0|%f|0|%f" % (bounds_width, bounds_height)
160 speed = "Constant:%f" % speed
161 mobility = ns3_desc.create("ns3::RandomDirection2dMobilityModel")
162 mobility.set_attribute_value("Position", position)
163 mobility.set_attribute_value("Bounds", bounds)
164 mobility.set_attribute_value("Speed", speed)
165 mobility.set_attribute_value("Pause", "Constant:1")
166 node.connector("mobility").connect(mobility.connector("node"))
169 def add_ns3_constant_mobility(self, node, ns3_desc, x, y, z):
170 mobility = ns3_desc.create("ns3::ConstantPositionMobilityModel")
171 position = "%f:%f:%f" % (x, y, z)
172 mobility.set_attribute_value("Position", position)
173 node.connector("mobility").connect(mobility.connector("node"))
176 def add_ns3_wifi_channel(self, ns3_desc):
177 channel = ns3_desc.create("ns3::YansWifiChannel")
178 delay = ns3_desc.create("ns3::ConstantSpeedPropagationDelayModel")
179 loss = ns3_desc.create("ns3::LogDistancePropagationLossModel")
180 channel.connector("delay").connect(delay.connector("chan"))
181 channel.connector("loss").connect(loss.connector("prev"))
184 def add_ip_address(self, iface, address, prefix = 24):
185 ip = iface.add_address()
186 ip.set_attribute_value("Address", address)
187 ip.set_attribute_value("Broadcast", True)
188 ip.set_attribute_value("NetPrefix", prefix)
191 def add_route(self, nodes, destination, netprefix, nexthop):
193 route = node.add_route()
194 route.set_attribute_value("Destination", destination)
195 route.set_attribute_value("NetPrefix", netprefix)
196 route.set_attribute_value("NextHop", nexthop)
198 def make_pl_router(self, pl, hostname, label, ip, inet = None):
199 pl1 = pl.create("Node")
200 pl1.set_attribute_value("hostname", hostname)
201 pl1.set_attribute_value("label", label)
202 pl1.set_attribute_value("emulation", True)
203 pl1if = pl.create("NodeInterface")
204 pl1if.set_attribute_value("label", label+"if")
205 pl1tap = pl.create("TapInterface")
206 pl1tap.enable_trace("packets") # for error output
207 pl1tap.set_attribute_value("label", label+"tap")
208 pl1tap.set_attribute_value("snat", False)
209 inet = inet or pl.create("Internet")
210 pl1.connector("devs").connect(pl1if.connector("node"))
211 pl1.connector("devs").connect(pl1tap.connector("node"))
212 pl1if.connector("inet").connect(inet.connector("devs"))
214 pl1tapip = pl1tap.add_address()
215 pl1tapip.set_attribute_value("Address", ip)
216 pl1tapip.set_attribute_value("NetPrefix", 24)
217 pl1tapip.set_attribute_value("Broadcast", False)
219 return pl1, pl1if, pl1tap, pl1tapip, inet
221 def make_mesh(self, pl, exp, inet):
226 # Router 1 & NS3 host in PL
227 pl1, pl1if, pl1tap, pl1tapip, inet = self.make_pl_router(pl,
228 self.host1, "mesh_pl1", "192.168.2.2", inet)
230 # Add NS3 support in pl1
231 ns3 = self.make_ns_in_pl(pl, exp, pl1, pl1if, "tb-ns3-roads09-1")
234 chan = self.add_ns3_wifi_channel(ns3)
237 ap1 = self.add_ns3_node(ns3)
238 ap2 = self.add_ns3_node(ns3)
239 ap3 = self.add_ns3_node(ns3)
240 ap4 = self.add_ns3_node(ns3)
241 ap1wifi, ap1phy = self.add_ns3_wifi(ap1, ns3, False, "192.168.2.3", 26)
242 ap2wifi, ap2phy = self.add_ns3_wifi(ap2, ns3, True, "192.168.2.4", 26)
243 ap3wifi, ap3phy = self.add_ns3_wifi(ap3, ns3, False, "192.168.2.5", 26)
244 ap4wifi, ap4phy = self.add_ns3_wifi(ap4, ns3, False, "192.168.2.6", 26)
245 self.add_ns3_constant_mobility(ap1, ns3, -scale, -scale, 0.0)
246 self.add_ns3_constant_mobility(ap2, ns3, +scale, -scale, 0.0)
247 self.add_ns3_constant_mobility(ap3, ns3, -scale, +scale, 0.0)
248 self.add_ns3_constant_mobility(ap4, ns3, +scale, +scale, 0.0)
251 wnode1 = self.add_ns3_node(ns3)
252 wnode2 = self.add_ns3_node(ns3)
253 wnode3 = self.add_ns3_node(ns3)
254 wnode4 = self.add_ns3_node(ns3)
255 wnode5 = self.add_ns3_node(ns3)
256 wnode1wifi, wnode1phy = self.add_ns3_wifi(wnode1, ns3, False, "192.168.2.7", 26)
257 wnode2wifi, wnode2phy = self.add_ns3_wifi(wnode2, ns3, False, "192.168.2.8", 26)
258 wnode3wifi, wnode3phy = self.add_ns3_wifi(wnode3, ns3, False, "192.168.2.9", 26)
259 wnode4wifi, wnode4phy = self.add_ns3_wifi(wnode4, ns3, False, "192.168.2.10", 26)
260 wnode5wifi, wnode5phy = self.add_ns3_wifi(wnode5, ns3, False, "192.168.2.11", 26)
261 self.add_ns3_random_mobility(wnode1, ns3, -2*scale, -2*scale, 0.0,
262 walkspeed, walkdistance, walkdistance)
263 self.add_ns3_random_mobility(wnode2, ns3, -2*scale, +scale, 0.0,
264 walkspeed, walkdistance, walkdistance)
265 self.add_ns3_random_mobility(wnode3, ns3, -scale, +2*scale, 0.0,
266 walkspeed, walkdistance, walkdistance)
267 self.add_ns3_random_mobility(wnode4, ns3, +scale, +2*scale, 0.0,
268 walkspeed, walkdistance, walkdistance)
269 self.add_ns3_random_mobility(wnode5, ns3, +2*scale, +2*scale, 0.0,
270 walkspeed, walkdistance, walkdistance)
272 # Connect all WiFi phys to the channel
273 ap1phy.connector("chan").connect(chan.connector("phys"))
274 ap2phy.connector("chan").connect(chan.connector("phys"))
275 ap3phy.connector("chan").connect(chan.connector("phys"))
276 ap4phy.connector("chan").connect(chan.connector("phys"))
277 wnode1phy.connector("chan").connect(chan.connector("phys"))
278 wnode2phy.connector("chan").connect(chan.connector("phys"))
279 wnode3phy.connector("chan").connect(chan.connector("phys"))
280 wnode4phy.connector("chan").connect(chan.connector("phys"))
281 wnode5phy.connector("chan").connect(chan.connector("phys"))
283 # Add inet connection to AP
284 ap2fdnd = self.add_ns3_fdnd(ap2, ns3)
285 ap2fdndip = self.add_ip_address(ap2fdnd, "192.168.2.20")
286 ap2fdndip.set_attribute_value("NetPrefix", 32) # p2p
287 pl1tap.connector("fd->").connect(ap2fdnd.connector("->fd"))
288 pl1tap.set_attribute_value("pointopoint", "192.168.2.20")
290 r.set_attribute_value("Destination", "192.168.2.2")
291 r.set_attribute_value("NetPrefix", 32)
292 r.set_attribute_value("NextHop", "192.168.2.20")
296 pl1, pl1if, pl1tap, pl1tapip,
297 (wnode1, wnode2, wnode3, wnode4, wnode5),
298 (wnode1wifi, wnode2wifi, wnode3wifi, wnode4wifi, wnode5wifi),
299 (ap1, ap2, ap3, ap4),
300 (ap1wifi, ap2wifi, ap3wifi, ap4wifi),
305 def make_wifi_hotspot(self, pl, exp, inet):
310 # Router 1 & NS3 host in PL
311 pl1, pl1if, pl1tap, pl1tapip, inet = self.make_pl_router(pl,
312 self.host2, "hs_pl1", "192.168.2.65", inet)
314 # Add NS3 support in pl1
315 ns3 = self.make_ns_in_pl(pl, exp, pl1, pl1if, "tb-ns3-roads09-2")
318 chan = self.add_ns3_wifi_channel(ns3)
321 ap1 = self.add_ns3_node(ns3)
322 ap1wifi, ap1phy = self.add_ns3_wifi(ap1, ns3, True, "192.168.2.66", 26)
323 self.add_ns3_constant_mobility(ap1, ns3, 0.0, 0.0, 0.0)
326 wnode1 = self.add_ns3_node(ns3)
327 wnode2 = self.add_ns3_node(ns3)
328 wnode3 = self.add_ns3_node(ns3)
329 wnode4 = self.add_ns3_node(ns3)
330 wnode1wifi, wnode1phy = self.add_ns3_wifi(wnode1, ns3, False, "192.168.2.67", 26)
331 wnode2wifi, wnode2phy = self.add_ns3_wifi(wnode2, ns3, False, "192.168.2.68", 26)
332 wnode3wifi, wnode3phy = self.add_ns3_wifi(wnode3, ns3, False, "192.168.2.69", 26)
333 wnode4wifi, wnode4phy = self.add_ns3_wifi(wnode4, ns3, False, "192.168.2.70", 26)
334 self.add_ns3_random_mobility(wnode1, ns3, +scale, -2*scale, 0.0,
335 walkspeed, walkdistance, walkdistance)
336 self.add_ns3_random_mobility(wnode2, ns3, -scale, -2*scale, 0.0,
337 walkspeed, walkdistance, walkdistance)
338 self.add_ns3_random_mobility(wnode3, ns3, -2*scale, +scale, 0.0,
339 walkspeed, walkdistance, walkdistance)
340 self.add_ns3_random_mobility(wnode4, ns3, -2*scale, +2*scale, 0.0,
341 walkspeed, walkdistance, walkdistance)
343 # Connect all WiFi phys to the channel
344 ap1phy.connector("chan").connect(chan.connector("phys"))
345 wnode1phy.connector("chan").connect(chan.connector("phys"))
346 wnode2phy.connector("chan").connect(chan.connector("phys"))
347 wnode3phy.connector("chan").connect(chan.connector("phys"))
348 wnode4phy.connector("chan").connect(chan.connector("phys"))
350 # Add inet connection to AP2
351 ap1fdnd = self.add_ns3_fdnd(ap1, ns3)
352 ap1fdndip = self.add_ip_address(ap1fdnd, "192.168.2.80")
353 ap1fdndip.set_attribute_value("NetPrefix", 32) # p2p
354 pl1tap.connector("fd->").connect(ap1fdnd.connector("->fd"))
355 pl1tap.set_attribute_value("pointopoint", "192.168.2.80")
357 r.set_attribute_value("Destination", "192.168.2.65")
358 r.set_attribute_value("NetPrefix", 32)
359 r.set_attribute_value("NextHop", "192.168.2.80")
363 pl1, pl1if, pl1tap, pl1tapip,
364 (wnode1, wnode2, wnode3, wnode4),
365 (wnode1wifi, wnode2wifi, wnode3wifi, wnode4wifi),
372 pl, exp = self.make_experiment_desc()
374 pl1, pl1if, pl1tap, pl1tapip, \
375 mesh_nodes, mesh_node_ifs, \
376 mesh_aps, mesh_ap_ifs, \
378 inet = self.make_mesh(pl, exp, None)
379 pl2, pl2if, pl2tap, pl2tapip, \
380 hs_nodes, hs_node_ifs, \
383 inet = self.make_wifi_hotspot(pl, exp, inet)
385 # Connect the routers
386 pl1etap = pl.create("TapInterface")
387 pl1etap.enable_trace("packets") # for error output
388 pl1etap.set_attribute_value("label", "pl1etap")
389 pl1etapip = pl1etap.add_address()
390 pl1etapip.set_attribute_value("Address", "192.168.2.1")
391 pl1etapip.set_attribute_value("NetPrefix", 24)
392 pl1etapip.set_attribute_value("Broadcast", False)
394 pl2etap = pl.create("TapInterface")
395 pl2etap.enable_trace("packets") # for error output
396 pl2etap.set_attribute_value("label", "pl2etap")
397 pl2etapip = pl2etap.add_address()
398 pl2etapip.set_attribute_value("Address", "192.168.2.81")
399 pl2etapip.set_attribute_value("NetPrefix", 24)
400 pl2etapip.set_attribute_value("Broadcast", False)
402 pl1etap.connector("node").connect(pl1.connector("devs"))
403 pl2etap.connector("node").connect(pl2.connector("devs"))
404 pl1etap.connector("udp").connect(pl2etap.connector("udp"))
405 pl1etap.set_attribute_value("pointopoint", "192.168.2.81")
406 pl2etap.set_attribute_value("pointopoint", "192.168.2.1")
408 # Connect the networks
410 # apn -> ap2 (n != 2)
411 for ap in mesh_aps[:1] + mesh_aps[2:]:
413 r.set_attribute_value("Destination", "192.168.2.64")
414 r.set_attribute_value("NetPrefix", 26)
415 r.set_attribute_value("NextHop",
416 mesh_ap_ifs[1].addresses[0].get_attribute_value("Address") )
418 for wn in mesh_nodes:
419 apif = mesh_ap_ifs[ random.randint(0,len(mesh_aps)-1) ]
421 r.set_attribute_value("Destination", "192.168.2.64")
422 r.set_attribute_value("NetPrefix", 26)
423 r.set_attribute_value("NextHop",
424 apif.addresses[0].get_attribute_value("Address"))
426 r = mesh_aps[1].add_route()
427 r.set_attribute_value("Destination", "192.168.2.64")
428 r.set_attribute_value("NetPrefix", 26)
429 r.set_attribute_value("NextHop", "192.168.2.2")
432 r.set_attribute_value("Destination", "192.168.2.64")
433 r.set_attribute_value("NetPrefix", 26)
434 r.set_attribute_value("NextHop", "192.168.2.81")
437 r.set_attribute_value("Destination", "192.168.2.64")
438 r.set_attribute_value("NetPrefix", 26)
439 r.set_attribute_value("NextHop", "192.168.2.80")
443 r.set_attribute_value("Destination", "192.168.2.0")
444 r.set_attribute_value("NetPrefix", 26)
445 r.set_attribute_value("NextHop", "192.168.2.66")
447 r = hs_ap.add_route()
448 r.set_attribute_value("Destination", "192.168.2.0")
449 r.set_attribute_value("NetPrefix", 26)
450 r.set_attribute_value("NextHop", "192.168.2.65")
453 r.set_attribute_value("Destination", "192.168.2.0")
454 r.set_attribute_value("NetPrefix", 26)
455 r.set_attribute_value("NextHop", "192.168.2.1")
458 r.set_attribute_value("Destination", "192.168.2.0")
459 r.set_attribute_value("NetPrefix", 26)
460 r.set_attribute_value("NextHop", "192.168.2.20")
462 # Add pinger app inside the mesh
463 hs_node_ifs[0].set_attribute_value("label", "hotspot_node_1if")
464 mesh_node_ifs[0].set_attribute_value("label", "mesh_node_1if")
465 ping = mesh_ns.create("ns3::V4Ping")
466 ping.set_attribute_value("Remote", "192.168.2.67") #"{#[hotspot_node_1if].addr[0].[Address]#}")
467 ping.set_attribute_value("StartTime", "0s")
468 ping.set_attribute_value("StopTime", "10s")
469 ping.connector("node").connect(mesh_aps[0].connector("apps"))
476 controller = ExperimentController(xml, self.root_dir)
479 while not controller.is_finished(ping.guid):
482 taptrace = controller.trace(pl.guid, pl1tap.guid, "packets")
486 controller.shutdown()
488 print "Pakcets at router:"
492 shutil.rmtree(self.root_dir)
494 if __name__ == '__main__':
495 example = Roads09Ns3PLExample()