3 # NEPI, a framework to manage network experiments
4 # Copyright (C) 2013 INRIA
6 # This program is free software: you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation, either version 3 of the License, or
9 # (at your option) any later version.
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 # GNU General Public License for more details.
16 # You should have received a copy of the GNU General Public License
17 # along with this program. If not, see <http://www.gnu.org/licenses/>.
19 # Author: Alina Quereilhac <alina.quereilhac@inria.fr>
29 # node n0 sends IGMP traffic to node n3
32 from nepi.execution.ec import ExperimentController
33 from nepi.execution.trace import TraceAttr
39 def add_ns3_node(ec, simu):
40 node = ec.register_resource("ns3::Node")
41 ec.register_connection(node, simu)
43 ipv4 = ec.register_resource("ns3::Ipv4L3Protocol")
44 ec.register_connection(node, ipv4)
46 arp = ec.register_resource("ns3::ArpL3Protocol")
47 ec.register_connection(node, arp)
49 icmp = ec.register_resource("ns3::Icmpv4L4Protocol")
50 ec.register_connection(node, icmp)
52 udp = ec.register_resource("ns3::UdpL4Protocol")
53 ec.register_connection(node, udp)
57 def add_point2point_device(ec, node, address = None, prefix = None):
58 dev = ec.register_resource("ns3::PointToPointNetDevice")
60 ec.set(dev, "ip", address)
62 ec.set(dev, "prefix", prefix)
63 ec.register_connection(node, dev)
65 queue = ec.register_resource("ns3::DropTailQueue")
66 ec.register_connection(dev, queue)
70 def add_csma_device(ec, node, address = None, prefix = None):
71 dev = ec.register_resource("ns3::CsmaNetDevice")
73 ec.set(dev, "ip", address)
75 ec.set(dev, "prefix", prefix)
76 ec.register_connection(node, dev)
78 queue = ec.register_resource("ns3::DropTailQueue")
79 ec.register_connection(dev, queue)
83 def add_wifi_device(ec, node, address = None, prefix = None,
84 access_point = False):
85 dev = ec.register_resource("ns3::WifiNetDevice")
87 ec.set(dev, "ip", address)
89 ec.set(dev, "prefix", prefix)
90 ec.register_connection(node, dev)
92 phy = ec.register_resource("ns3::YansWifiPhy")
93 ec.set(phy, "Standard", "WIFI_PHY_STANDARD_80211a")
94 ec.register_connection(dev, phy)
96 error = ec.register_resource("ns3::NistErrorRateModel")
97 ec.register_connection(phy, error)
99 manager = ec.register_resource("ns3::ArfWifiManager")
100 ec.register_connection(dev, manager)
103 mac = ec.register_resource("ns3::ApWifiMac")
105 mac = ec.register_resource("ns3::StaWifiMac")
107 ec.set(mac, "Standard", "WIFI_PHY_STANDARD_80211a")
108 ec.register_connection(dev, mac)
112 def add_random_mobility(ec, node, x, y, z, speed, bounds_width,
114 position = "%d:%d:%d" % (x, y, z)
115 bounds = "0|%d|0|%d" % (bounds_width, bounds_height)
116 speed = "ns3::UniformRandomVariable[Min=%d|Max=%s]" % (speed, speed)
117 pause = "ns3::ConstantRandomVariable[Constant=1.0]"
119 mobility = ec.register_resource("ns3::RandomDirection2dMobilityModel")
120 ec.set(mobility, "Position", position)
121 ec.set(mobility, "Bounds", bounds)
122 ec.set(mobility, "Speed", speed)
123 ec.set(mobility, "Pause", pause)
124 ec.register_connection(node, mobility)
127 def add_constant_mobility(ec, node, x, y, z):
128 mobility = ec.register_resource("ns3::ConstantPositionMobilityModel")
129 position = "%d:%d:%d" % (x, y, z)
130 ec.set(mobility, "Position", position)
131 ec.register_connection(node, mobility)
134 def add_wifi_channel(ec):
135 channel = ec.register_resource("ns3::YansWifiChannel")
136 delay = ec.register_resource("ns3::ConstantSpeedPropagationDelayModel")
137 ec.register_connection(channel, delay)
139 loss = ec.register_resource("ns3::LogDistancePropagationLossModel")
140 ec.register_connection(channel, loss)
144 class LinuxNS3ClientTest(unittest.TestCase):
146 #elf.fedora_host = "nepi2.pl.sophia.inria.fr"
147 #self.fedora_host = "planetlabpc1.upf.edu"
148 self.fedora_host = "peeramide.irisa.fr"
149 self.fedora_user = "inria_nepi"
150 #self.fedora_user = "inria_alina"
151 self.fedora_identity = "%s/.ssh/id_rsa_planetlab" % (os.environ['HOME'])
153 def test_local_p2p_ping(self):
154 ec = ExperimentController(exp_id = "test-ns3-local-p2p")
156 node = ec.register_resource("LinuxNode")
157 ec.set(node, "hostname", "localhost")
159 simu = ec.register_resource("LinuxNS3Simulation")
160 ec.set(simu, "verbose", True)
161 ec.register_connection(simu, node)
163 nsnode1 = add_ns3_node(ec, simu)
164 dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
166 nsnode2 = add_ns3_node(ec, simu)
167 dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
170 chan = ec.register_resource("ns3::PointToPointChannel")
171 ec.set(chan, "Delay", "0s")
172 ec.register_connection(chan, dev1)
173 ec.register_connection(chan, dev2)
176 ping = ec.register_resource("ns3::V4Ping")
177 ec.set (ping, "Remote", "10.0.0.2")
178 ec.set (ping, "Interval", "1s")
179 ec.set (ping, "Verbose", True)
180 ec.set (ping, "StartTime", "0s")
181 ec.set (ping, "StopTime", "20s")
182 ec.register_connection(ping, nsnode1)
186 ec.wait_finished([ping])
188 stdout = ec.trace(simu, "stdout")
190 expected = "20 packets transmitted, 20 received, 0% packet loss"
191 self.assertTrue(stdout.find(expected) > -1)
195 def test_simple_p2p_ping(self):
196 ec = ExperimentController(exp_id = "test-ns3-p2p-ping")
198 node = ec.register_resource("LinuxNode")
199 ec.set(node, "hostname", self.fedora_host)
200 ec.set(node, "username", self.fedora_user)
201 ec.set(node, "identity", self.fedora_identity)
202 ec.set(node, "cleanProcesses", True)
203 #ec.set(node, "cleanHome", True)
205 simu = ec.register_resource("LinuxNS3Simulation")
206 ec.set(simu, "verbose", True)
207 ec.register_connection(simu, node)
209 nsnode1 = add_ns3_node(ec, simu)
210 dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
212 nsnode2 = add_ns3_node(ec, simu)
213 dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
216 chan = ec.register_resource("ns3::PointToPointChannel")
217 ec.set(chan, "Delay", "0s")
218 ec.register_connection(chan, dev1)
219 ec.register_connection(chan, dev2)
222 ping = ec.register_resource("ns3::V4Ping")
223 ec.set (ping, "Remote", "10.0.0.2")
224 ec.set (ping, "Interval", "1s")
225 ec.set (ping, "Verbose", True)
226 ec.set (ping, "StartTime", "0s")
227 ec.set (ping, "StopTime", "20s")
228 ec.register_connection(ping, nsnode1)
232 ec.wait_finished([ping])
234 stdout = ec.trace(simu, "stdout")
236 expected = "20 packets transmitted, 20 received, 0% packet loss"
237 self.assertTrue(stdout.find(expected) > -1)
241 def test_simple_cmsa_ping(self):
242 ec = ExperimentController(exp_id = "test-ns3-csma-ping")
244 node = ec.register_resource("LinuxNode")
245 ec.set(node, "hostname", self.fedora_host)
246 ec.set(node, "username", self.fedora_user)
247 ec.set(node, "identity", self.fedora_identity)
248 ec.set(node, "cleanProcesses", True)
249 #ec.set(node, "cleanHome", True)
251 simu = ec.register_resource("LinuxNS3Simulation")
252 ec.set(simu, "verbose", True)
253 ec.register_connection(simu, node)
255 nsnode1 = add_ns3_node(ec, simu)
256 dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
258 nsnode2 = add_ns3_node(ec, simu)
259 dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
262 chan = ec.register_resource("ns3::CsmaChannel")
263 ec.set(chan, "Delay", "0s")
264 ec.register_connection(chan, dev1)
265 ec.register_connection(chan, dev2)
268 ping = ec.register_resource("ns3::V4Ping")
269 ec.set (ping, "Remote", "10.0.0.2")
270 ec.set (ping, "Interval", "1s")
271 ec.set (ping, "Verbose", True)
272 ec.set (ping, "StartTime", "0s")
273 ec.set (ping, "StopTime", "20s")
274 ec.register_connection(ping, nsnode1)
278 ec.wait_finished([ping])
280 stdout = ec.trace(simu, "stdout")
282 expected = "20 packets transmitted, 20 received, 0% packet loss"
283 self.assertTrue(stdout.find(expected) > -1)
287 def test_compile_local_source(self):
288 ec = ExperimentController(exp_id = "test-ns3-local-source")
290 node = ec.register_resource("LinuxNode")
291 ec.set(node, "hostname", self.fedora_host)
292 ec.set(node, "username", self.fedora_user)
293 ec.set(node, "identity", self.fedora_identity)
294 ec.set(node, "cleanProcesses", True)
295 #ec.set(node, "cleanHome", True)
297 simu = ec.register_resource("LinuxNS3Simulation")
298 ec.set(simu, "verbose", True)
299 sources = os.path.join(os.path.dirname(os.path.realpath(__file__)),
300 "ns-3.18-user.tar.gz")
301 ec.set(simu, "sources", sources)
302 ec.register_connection(simu, node)
304 nsnode1 = add_ns3_node(ec, simu)
305 dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
307 nsnode2 = add_ns3_node(ec, simu)
308 dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
311 chan = ec.register_resource("ns3::CsmaChannel")
312 ec.set(chan, "Delay", "0s")
313 ec.register_connection(chan, dev1)
314 ec.register_connection(chan, dev2)
317 ping = ec.register_resource("ns3::V4Ping")
318 ec.set (ping, "Remote", "10.0.0.2")
319 ec.set (ping, "Interval", "1s")
320 ec.set (ping, "Verbose", True)
321 ec.set (ping, "StartTime", "0s")
322 ec.set (ping, "StopTime", "20s")
323 ec.register_connection(ping, nsnode1)
327 ec.wait_finished([ping])
329 stdout = ec.trace(simu, "stdout")
331 expected = "20 packets transmitted, 20 received, 0% packet loss"
332 self.assertTrue(stdout.find(expected) > -1)
336 def test_compile_debug_mode(self):
337 ec = ExperimentController(exp_id = "test-ns3-debug-mode")
339 node = ec.register_resource("LinuxNode")
340 ec.set(node, "hostname", self.fedora_host)
341 ec.set(node, "username", self.fedora_user)
342 ec.set(node, "identity", self.fedora_identity)
343 ec.set(node, "cleanProcesses", True)
344 #ec.set(node, "cleanHome", True)
346 simu = ec.register_resource("LinuxNS3Simulation")
347 ec.set(simu, "verbose", True)
348 ec.set(simu, "nsLog", "V4Ping:Node")
349 ec.set(simu, "buildMode", "debug")
350 ec.register_connection(simu, node)
352 nsnode1 = add_ns3_node(ec, simu)
353 dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
355 nsnode2 = add_ns3_node(ec, simu)
356 dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
359 chan = ec.register_resource("ns3::CsmaChannel")
360 ec.set(chan, "Delay", "0s")
361 ec.register_connection(chan, dev1)
362 ec.register_connection(chan, dev2)
365 ping = ec.register_resource("ns3::V4Ping")
366 ec.set (ping, "Remote", "10.0.0.2")
367 ec.set (ping, "Interval", "1s")
368 ec.set (ping, "Verbose", True)
369 ec.set (ping, "StartTime", "0s")
370 ec.set (ping, "StopTime", "20s")
371 ec.register_connection(ping, nsnode1)
375 ec.wait_finished([ping])
377 stdout = ec.trace(simu, "stdout")
379 expected = "20 packets transmitted, 20 received, 0% packet loss"
380 self.assertTrue(stdout.find(expected) > -1)
382 stderr = ec.trace(simu, "stderr")
383 expected = "V4Ping:Read32"
384 self.assertTrue(stderr.find(expected) > -1)
388 def test_real_time(self):
389 ec = ExperimentController(exp_id = "test-ns3-real-time")
391 node = ec.register_resource("LinuxNode")
392 ec.set(node, "hostname", self.fedora_host)
393 ec.set(node, "username", self.fedora_user)
394 ec.set(node, "identity", self.fedora_identity)
395 ec.set(node, "cleanProcesses", True)
396 #ec.set(node, "cleanHome", True)
398 simu = ec.register_resource("LinuxNS3Simulation")
399 ec.set(simu, "simulatorImplementationType", "ns3::RealtimeSimulatorImpl")
400 ec.set(simu, "checksumEnabled", True)
401 ec.set(simu, "verbose", True)
402 ec.register_connection(simu, node)
404 nsnode1 = add_ns3_node(ec, simu)
405 dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
407 nsnode2 = add_ns3_node(ec, simu)
408 dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
411 chan = ec.register_resource("ns3::PointToPointChannel")
412 ec.set(chan, "Delay", "0s")
413 ec.register_connection(chan, dev1)
414 ec.register_connection(chan, dev2)
417 ping = ec.register_resource("ns3::V4Ping")
418 ec.set (ping, "Remote", "10.0.0.2")
419 ec.set (ping, "Interval", "1s")
420 ec.set (ping, "Verbose", True)
421 ec.set (ping, "StartTime", "0s")
422 ec.set (ping, "StopTime", "20s")
423 ec.register_connection(ping, nsnode1)
427 ec.wait_finished([ping])
429 stdout = ec.trace(simu, "stdout")
431 expected = "20 packets transmitted, 20 received, 0% packet loss"
432 self.assertTrue(stdout.find(expected) > -1)
434 rm = ec.get_resource(ping)
435 start_time = rm.start_time
436 stop_time = rm.stop_time
437 delta = stop_time - start_time
439 self.assertTrue(delta.seconds >= 20, "Time elapsed %d" % delta.seconds)
440 self.assertTrue(delta.seconds < 25, "Time elapsed %d" % delta.seconds)
444 def test_traces(self):
445 ec = ExperimentController(exp_id = "test-ns3-traces")
447 node = ec.register_resource("LinuxNode")
448 ec.set(node, "hostname", self.fedora_host)
449 ec.set(node, "username", self.fedora_user)
450 ec.set(node, "identity", self.fedora_identity)
451 ec.set(node, "cleanProcesses", True)
452 #ec.set(node, "cleanHome", True)
454 simu = ec.register_resource("LinuxNS3Simulation")
455 ec.set(simu, "verbose", True)
456 ec.register_connection(simu, node)
458 nsnode1 = add_ns3_node(ec, simu)
459 dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
461 nsnode2 = add_ns3_node(ec, simu)
462 dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
465 chan = ec.register_resource("ns3::PointToPointChannel")
466 ec.set(chan, "Delay", "0s")
467 ec.register_connection(chan, dev1)
468 ec.register_connection(chan, dev2)
471 ping = ec.register_resource("ns3::V4Ping")
472 ec.set (ping, "Remote", "10.0.0.2")
473 ec.set (ping, "Interval", "1s")
474 ec.set (ping, "Verbose", True)
475 ec.set (ping, "StartTime", "0s")
476 ec.set (ping, "StopTime", "20s")
477 ec.register_connection(ping, nsnode1)
480 ec.enable_trace(dev1, "pcap")
481 ec.enable_trace(dev1, "promiscPcap")
482 ec.enable_trace(dev1, "ascii")
484 ec.enable_trace(dev2, "pcap")
485 ec.enable_trace(dev2, "promiscPcap")
486 ec.enable_trace(dev2, "ascii")
490 ec.wait_finished([ping])
493 rm_simu = ec.get_resource(simu)
495 # TODO: Fix this in ns-3: pcap traces do not flush until the Simulator
496 # process is ended, so we can't get the traces of the 'pcap' and
497 # 'promiscPcap' traces.
499 #for trace in ["pcap", "promiscPcap", "ascii"]:
500 for trace in ["ascii"]:
501 for guid in [dev1, dev2]:
502 output = ec.trace(guid, trace)
504 size = ec.trace(guid, trace, attr = TraceAttr.SIZE)
505 self.assertEquals(size, len(output))
506 self.assertTrue(size > 100)
508 block = ec.trace(guid, trace, attr = TraceAttr.STREAM, block = 5, offset = 1)
509 self.assertEquals(block, output[5:10])
511 trace_path = ec.trace(guid, trace, attr = TraceAttr.PATH)
512 rm = ec.get_resource(guid)
513 path = os.path.join(rm_simu.run_home, rm._trace_filename.get(trace))
514 self.assertEquals(trace_path, path)
518 def test_simple_wifi_ping(self):
519 bounds_width = bounds_height = 200
523 ec = ExperimentController(exp_id = "test-ns3-wifi-ping")
525 node = ec.register_resource("LinuxNode")
526 ec.set(node, "hostname", self.fedora_host)
527 ec.set(node, "username", self.fedora_user)
528 ec.set(node, "identity", self.fedora_identity)
529 ec.set(node, "cleanProcesses", True)
530 #ec.set(node, "cleanHome", True)
532 simu = ec.register_resource("LinuxNS3Simulation")
533 ec.set(simu, "verbose", True)
534 ec.register_connection(simu, node)
536 nsnode1 = add_ns3_node(ec, simu)
537 dev1, phy1 = add_wifi_device(ec, nsnode1, "10.0.0.1", "24", access_point = True)
538 mobility1 = add_constant_mobility(ec, nsnode1, x, y, 0)
540 nsnode2 = add_ns3_node(ec, simu)
541 dev2, phy2 = add_wifi_device(ec, nsnode2, "10.0.0.2", "24", access_point = False)
542 mobility1 = add_constant_mobility(ec, nsnode2, x, y, 0)
543 #mobility2 = add_random_mobility(ec, nsnode2, x, y, 0, speed, bounds_width, bounds_height)
546 chan = add_wifi_channel(ec)
547 ec.register_connection(chan, phy1)
548 ec.register_connection(chan, phy2)
551 ping = ec.register_resource("ns3::V4Ping")
552 ec.set (ping, "Remote", "10.0.0.1")
553 ec.set (ping, "Interval", "1s")
554 ec.set (ping, "Verbose", True)
555 ec.set (ping, "StartTime", "1s")
556 ec.set (ping, "StopTime", "21s")
557 ec.register_connection(ping, nsnode2)
561 ec.wait_finished([ping])
563 stdout = ec.trace(simu, "stdout")
565 expected = "20 packets transmitted, 20 received, 0% packet loss"
566 self.assertTrue(stdout.find(expected) > -1)
570 def test_routing(self):
575 n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
581 ec = ExperimentController(exp_id = "test-ns3-routes")
583 node = ec.register_resource("LinuxNode")
584 ec.set(node, "hostname", self.fedora_host)
585 ec.set(node, "username", self.fedora_user)
586 ec.set(node, "identity", self.fedora_identity)
587 ec.set(node, "cleanProcesses", True)
588 #ec.set(node, "cleanHome", True)
590 simu = ec.register_resource("LinuxNS3Simulation")
591 ec.set(simu, "verbose", True)
592 ec.register_connection(simu, node)
594 nsnode1 = add_ns3_node(ec, simu)
595 p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
597 nsnode2 = add_ns3_node(ec, simu)
598 p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
599 csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
601 nsnode3 = add_ns3_node(ec, simu)
602 csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
604 nsnode4 = add_ns3_node(ec, simu)
605 csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
607 nsnode5 = add_ns3_node(ec, simu)
608 p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
609 csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
611 nsnode6 = add_ns3_node(ec, simu)
612 p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
615 p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
616 ec.set(p2p_chan1, "Delay", "0s")
617 ec.register_connection(p2p_chan1, p2p12)
618 ec.register_connection(p2p_chan1, p2p21)
621 csma_chan = ec.register_resource("ns3::CsmaChannel")
622 ec.set(csma_chan, "Delay", "0s")
623 ec.register_connection(csma_chan, csma2)
624 ec.register_connection(csma_chan, csma3)
625 ec.register_connection(csma_chan, csma4)
626 ec.register_connection(csma_chan, csma5)
629 p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
630 ec.set(p2p_chan2, "Delay", "0s")
631 ec.register_connection(p2p_chan2, p2p56)
632 ec.register_connection(p2p_chan2, p2p65)
634 # Add routes - n1 - n6
635 r1 = ec.register_resource("ns3::Route")
636 ec.set(r1, "network", "10.0.2.0")
637 ec.set(r1, "prefix", "30")
638 ec.set(r1, "nexthop", "10.0.0.2")
639 ec.register_connection(r1, nsnode1)
641 # Add routes - n2 - n6
642 r2 = ec.register_resource("ns3::Route")
643 ec.set(r2, "network", "10.0.2.0")
644 ec.set(r2, "prefix", "30")
645 ec.set(r2, "nexthop", "10.0.1.4")
646 ec.register_connection(r2, nsnode2)
648 # Add routes - n5 - n1
649 r5 = ec.register_resource("ns3::Route")
650 ec.set(r5, "network", "10.0.0.0")
651 ec.set(r5, "prefix", "30")
652 ec.set(r5, "nexthop", "10.0.1.1")
653 ec.register_connection(r5, nsnode5)
655 # Add routes - n6 - n1
656 r6 = ec.register_resource("ns3::Route")
657 ec.set(r6, "network", "10.0.0.0")
658 ec.set(r6, "prefix", "30")
659 ec.set(r6, "nexthop", "10.0.2.1")
660 ec.register_connection(r6, nsnode6)
663 ping = ec.register_resource("ns3::V4Ping")
664 ec.set (ping, "Remote", "10.0.2.2")
665 ec.set (ping, "Interval", "1s")
666 ec.set (ping, "Verbose", True)
667 ec.set (ping, "StartTime", "1s")
668 ec.set (ping, "StopTime", "21s")
669 ec.register_connection(ping, nsnode1)
673 ec.wait_finished([ping])
675 stdout = ec.trace(simu, "stdout")
677 expected = "20 packets transmitted, 20 received, 0% packet loss"
678 self.assertTrue(stdout.find(expected) > -1)
682 def ztest_automatic_routing(self):
687 n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
693 ec = ExperimentController(exp_id = "test-ns3-routing")
695 node = ec.register_resource("LinuxNode")
696 ec.set(node, "hostname", self.fedora_host)
697 ec.set(node, "username", self.fedora_user)
698 ec.set(node, "identity", self.fedora_identity)
699 ec.set(node, "cleanProcesses", True)
700 #ec.set(node, "cleanHome", True)
702 simu = ec.register_resource("LinuxNS3Simulation")
703 ec.set(simu, "verbose", True)
704 ec.set(simu, "populateRoutingTables", True)
705 ec.register_connection(simu, node)
707 nsnode1 = add_ns3_node(ec, simu)
708 p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
710 nsnode2 = add_ns3_node(ec, simu)
711 p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
712 csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
714 nsnode3 = add_ns3_node(ec, simu)
715 csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
717 nsnode4 = add_ns3_node(ec, simu)
718 csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
720 nsnode5 = add_ns3_node(ec, simu)
721 p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
722 csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
724 nsnode6 = add_ns3_node(ec, simu)
725 p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
728 p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
729 ec.set(p2p_chan1, "Delay", "0s")
730 ec.register_connection(p2p_chan1, p2p12)
731 ec.register_connection(p2p_chan1, p2p21)
734 csma_chan = ec.register_resource("ns3::CsmaChannel")
735 ec.set(csma_chan, "Delay", "0s")
736 ec.register_connection(csma_chan, csma2)
737 ec.register_connection(csma_chan, csma3)
738 ec.register_connection(csma_chan, csma4)
739 ec.register_connection(csma_chan, csma5)
742 p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
743 ec.set(p2p_chan2, "Delay", "0s")
744 ec.register_connection(p2p_chan2, p2p56)
745 ec.register_connection(p2p_chan2, p2p65)
748 ping = ec.register_resource("ns3::V4Ping")
749 ec.set (ping, "Remote", "10.0.1.2")
750 ec.set (ping, "Interval", "1s")
751 ec.set (ping, "Verbose", True)
752 ec.set (ping, "StartTime", "1s")
753 ec.set (ping, "StopTime", "21s")
754 ec.register_connection(ping, nsnode1)
758 ec.wait_finished([ping])
760 stdout = ec.trace(simu, "stdout")
764 expected = "20 packets transmitted, 20 received, 0% packet loss"
765 self.assertTrue(stdout.find(expected) > -1)
770 ec = ExperimentController(exp_id = "test-ns3-dce")
772 node = ec.register_resource("LinuxNode")
773 ec.set(node, "hostname", self.fedora_host)
774 ec.set(node, "username", self.fedora_user)
775 ec.set(node, "identity", self.fedora_identity)
776 ec.set(node, "cleanProcesses", True)
777 #ec.set(node, "cleanHome", True)
779 simu = ec.register_resource("LinuxNS3Simulation")
780 ec.set(simu, "verbose", True)
781 ec.set(simu, "enableDCE", True)
782 ec.set(simu, "buildMode", "debug")
783 ec.set(simu, "nsLog", "DceApplication")
784 ec.register_connection(simu, node)
786 nsnode1 = add_ns3_node(ec, simu)
787 ec.set(nsnode1, "enableDCE", True)
788 p2p1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
789 ec.set(p2p1, "DataRate", "5Mbps")
791 nsnode2 = add_ns3_node(ec, simu)
792 ec.set(nsnode2, "enableDCE", True)
793 p2p2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
794 ec.set(p2p2, "DataRate", "5Mbps")
797 chan = ec.register_resource("ns3::PointToPointChannel")
798 ec.set(chan, "Delay", "2ms")
800 ec.register_connection(chan, p2p1)
801 ec.register_connection(chan, p2p2)
803 ### create applications
804 udp_perf = ec.register_resource("ns3::DceApplication")
805 ec.set (udp_perf, "binary", "udp-perf")
806 ec.set (udp_perf, "stackSize", 1<<20)
807 ec.set (udp_perf, "arguments", "--duration=10;--nodes=2")
808 ec.set (udp_perf, "StartTime", "1s")
809 ec.set (udp_perf, "StopTime", "20s")
810 ec.register_connection(udp_perf, nsnode1)
812 udp_perf_client = ec.register_resource("ns3::DceApplication")
813 ec.set (udp_perf_client, "binary", "udp-perf")
814 ec.set (udp_perf_client, "stackSize", 1<<20)
815 ec.set (udp_perf_client, "arguments", "--client;--nodes=2;--host=10.0.0.1;--duration=10")
816 ec.set (udp_perf_client, "StartTime", "2s")
817 ec.set (udp_perf_client, "StopTime", "20s")
818 ec.register_connection(udp_perf_client, nsnode2)
822 ec.wait_finished([udp_perf_client])
824 expected = "udp-perf --duration=10 --nodes=2"
825 cmdline = ec.trace(udp_perf, "cmdline")
826 self.assertTrue(cmdline.find(expected) > -1, cmdline)
828 expected = "Start Time: NS3 Time: 1s ("
829 status = ec.trace(udp_perf, "status")
830 self.assertTrue(status.find(expected) > -1, status)
832 expected = "received=1500 bytes, 1 reads (@1500 bytes) 1500"
833 stdout = ec.trace(udp_perf, "stdout")
834 self.assertTrue(stdout.find(expected) > -1, stdout)
836 stderr = ec.trace(simu, "stderr")
837 expected = "DceApplication:StartApplication"
838 self.assertTrue(stderr.find(expected) > -1, stderr)
843 if __name__ == '__main__':