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)
54 def add_point2point_device(ec, node, address = None, prefix = None):
55 dev = ec.register_resource("ns3::PointToPointNetDevice")
57 ec.set(dev, "ip", address)
59 ec.set(dev, "prefix", prefix)
60 ec.register_connection(node, dev)
62 queue = ec.register_resource("ns3::DropTailQueue")
63 ec.register_connection(dev, queue)
67 def add_csma_device(ec, node, address = None, prefix = None):
68 dev = ec.register_resource("ns3::CsmaNetDevice")
70 ec.set(dev, "ip", address)
72 ec.set(dev, "prefix", prefix)
73 ec.register_connection(node, dev)
75 queue = ec.register_resource("ns3::DropTailQueue")
76 ec.register_connection(dev, queue)
80 def add_wifi_device(ec, node, address = None, prefix = None,
81 access_point = False):
82 dev = ec.register_resource("ns3::WifiNetDevice")
84 ec.set(dev, "ip", address)
86 ec.set(dev, "prefix", prefix)
87 ec.register_connection(node, dev)
89 phy = ec.register_resource("ns3::YansWifiPhy")
90 ec.set(phy, "Standard", "WIFI_PHY_STANDARD_80211a")
91 ec.register_connection(dev, phy)
93 error = ec.register_resource("ns3::NistErrorRateModel")
94 ec.register_connection(phy, error)
96 manager = ec.register_resource("ns3::ArfWifiManager")
97 ec.register_connection(dev, manager)
100 mac = ec.register_resource("ns3::ApWifiMac")
102 mac = ec.register_resource("ns3::StaWifiMac")
104 ec.set(mac, "Standard", "WIFI_PHY_STANDARD_80211a")
105 ec.register_connection(dev, mac)
109 def add_random_mobility(ec, node, x, y, z, speed, bounds_width,
111 position = "%d:%d:%d" % (x, y, z)
112 bounds = "0|%d|0|%d" % (bounds_width, bounds_height)
113 speed = "ns3::UniformRandomVariable[Min=%d|Max=%s]" % (speed, speed)
114 pause = "ns3::ConstantRandomVariable[Constant=1.0]"
116 mobility = ec.register_resource("ns3::RandomDirection2dMobilityModel")
117 ec.set(mobility, "Position", position)
118 ec.set(mobility, "Bounds", bounds)
119 ec.set(mobility, "Speed", speed)
120 ec.set(mobility, "Pause", pause)
121 ec.register_connection(node, mobility)
124 def add_constant_mobility(ec, node, x, y, z):
125 mobility = ec.register_resource("ns3::ConstantPositionMobilityModel")
126 position = "%d:%d:%d" % (x, y, z)
127 ec.set(mobility, "Position", position)
128 ec.register_connection(node, mobility)
131 def add_wifi_channel(ec):
132 channel = ec.register_resource("ns3::YansWifiChannel")
133 delay = ec.register_resource("ns3::ConstantSpeedPropagationDelayModel")
134 ec.register_connection(channel, delay)
136 loss = ec.register_resource("ns3::LogDistancePropagationLossModel")
137 ec.register_connection(channel, loss)
141 class LinuxNS3ClientTest(unittest.TestCase):
143 #self.fedora_host = "nepi2.pl.sophia.inria.fr"
144 self.fedora_host = "planetlabpc1.upf.edu"
145 #self.fedora_host = "peeramide.irisa.fr"
146 self.fedora_user = "inria_nepi"
147 self.fedora_identity = "%s/.ssh/id_rsa_planetlab" % (os.environ['HOME'])
149 def test_local_p2p_ping(self):
150 ec = ExperimentController(exp_id = "test-ns3-local-p2p")
152 node = ec.register_resource("LinuxNode")
153 ec.set(node, "hostname", "localhost")
155 simu = ec.register_resource("LinuxNS3Simulation")
156 ec.register_connection(simu, node)
158 nsnode1 = add_ns3_node(ec, simu)
159 dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
161 nsnode2 = add_ns3_node(ec, simu)
162 dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
165 chan = ec.register_resource("ns3::PointToPointChannel")
166 ec.set(chan, "Delay", "0s")
167 ec.register_connection(chan, dev1)
168 ec.register_connection(chan, dev2)
171 ping = ec.register_resource("ns3::V4Ping")
172 ec.set (ping, "Remote", "10.0.0.2")
173 ec.set (ping, "Interval", "1s")
174 ec.set (ping, "Verbose", True)
175 ec.set (ping, "StartTime", "0s")
176 ec.set (ping, "StopTime", "20s")
177 ec.register_connection(ping, nsnode1)
181 ec.wait_finished([ping])
183 stdout = ec.trace(simu, "stdout")
185 expected = "20 packets transmitted, 20 received, 0% packet loss"
186 self.assertTrue(stdout.find(expected) > -1)
190 def test_simple_p2p_ping(self):
191 ec = ExperimentController(exp_id = "test-ns3-p2p-ping")
193 node = ec.register_resource("LinuxNode")
194 ec.set(node, "hostname", self.fedora_host)
195 ec.set(node, "username", self.fedora_user)
196 ec.set(node, "identity", self.fedora_identity)
197 ec.set(node, "cleanProcesses", True)
198 #ec.set(node, "cleanHome", True)
200 simu = ec.register_resource("LinuxNS3Simulation")
201 ec.register_connection(simu, node)
203 nsnode1 = add_ns3_node(ec, simu)
204 dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
206 nsnode2 = add_ns3_node(ec, simu)
207 dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
210 chan = ec.register_resource("ns3::PointToPointChannel")
211 ec.set(chan, "Delay", "0s")
212 ec.register_connection(chan, dev1)
213 ec.register_connection(chan, dev2)
216 ping = ec.register_resource("ns3::V4Ping")
217 ec.set (ping, "Remote", "10.0.0.2")
218 ec.set (ping, "Interval", "1s")
219 ec.set (ping, "Verbose", True)
220 ec.set (ping, "StartTime", "0s")
221 ec.set (ping, "StopTime", "20s")
222 ec.register_connection(ping, nsnode1)
226 ec.wait_finished([ping])
228 stdout = ec.trace(simu, "stdout")
230 expected = "20 packets transmitted, 20 received, 0% packet loss"
231 self.assertTrue(stdout.find(expected) > -1)
235 def test_simple_cmsa_ping(self):
236 ec = ExperimentController(exp_id = "test-ns3-csma-ping")
238 node = ec.register_resource("LinuxNode")
239 ec.set(node, "hostname", self.fedora_host)
240 ec.set(node, "username", self.fedora_user)
241 ec.set(node, "identity", self.fedora_identity)
242 ec.set(node, "cleanProcesses", True)
243 #ec.set(node, "cleanHome", True)
245 simu = ec.register_resource("LinuxNS3Simulation")
246 ec.register_connection(simu, node)
248 nsnode1 = add_ns3_node(ec, simu)
249 dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
251 nsnode2 = add_ns3_node(ec, simu)
252 dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
255 chan = ec.register_resource("ns3::CsmaChannel")
256 ec.set(chan, "Delay", "0s")
257 ec.register_connection(chan, dev1)
258 ec.register_connection(chan, dev2)
261 ping = ec.register_resource("ns3::V4Ping")
262 ec.set (ping, "Remote", "10.0.0.2")
263 ec.set (ping, "Interval", "1s")
264 ec.set (ping, "Verbose", True)
265 ec.set (ping, "StartTime", "0s")
266 ec.set (ping, "StopTime", "20s")
267 ec.register_connection(ping, nsnode1)
271 ec.wait_finished([ping])
273 stdout = ec.trace(simu, "stdout")
275 expected = "20 packets transmitted, 20 received, 0% packet loss"
276 self.assertTrue(stdout.find(expected) > -1)
280 def test_compile_local_source(self):
281 ec = ExperimentController(exp_id = "test-ns3-local-source")
283 node = ec.register_resource("LinuxNode")
284 ec.set(node, "hostname", self.fedora_host)
285 ec.set(node, "username", self.fedora_user)
286 ec.set(node, "identity", self.fedora_identity)
287 ec.set(node, "cleanProcesses", True)
288 #ec.set(node, "cleanHome", True)
290 simu = ec.register_resource("LinuxNS3Simulation")
291 sources = os.path.join(os.path.dirname(os.path.realpath(__file__)),
292 "ns-3.18-user.tar.gz")
293 ec.set(simu, "sources", sources)
294 ec.register_connection(simu, node)
296 nsnode1 = add_ns3_node(ec, simu)
297 dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
299 nsnode2 = add_ns3_node(ec, simu)
300 dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
303 chan = ec.register_resource("ns3::CsmaChannel")
304 ec.set(chan, "Delay", "0s")
305 ec.register_connection(chan, dev1)
306 ec.register_connection(chan, dev2)
309 ping = ec.register_resource("ns3::V4Ping")
310 ec.set (ping, "Remote", "10.0.0.2")
311 ec.set (ping, "Interval", "1s")
312 ec.set (ping, "Verbose", True)
313 ec.set (ping, "StartTime", "0s")
314 ec.set (ping, "StopTime", "20s")
315 ec.register_connection(ping, nsnode1)
319 ec.wait_finished([ping])
321 stdout = ec.trace(simu, "stdout")
323 expected = "20 packets transmitted, 20 received, 0% packet loss"
324 self.assertTrue(stdout.find(expected) > -1)
328 def test_compile_debug_mode(self):
329 ec = ExperimentController(exp_id = "test-ns3-debug-mode")
331 node = ec.register_resource("LinuxNode")
332 ec.set(node, "hostname", self.fedora_host)
333 ec.set(node, "username", self.fedora_user)
334 ec.set(node, "identity", self.fedora_identity)
335 ec.set(node, "cleanProcesses", True)
336 #ec.set(node, "cleanHome", True)
338 simu = ec.register_resource("LinuxNS3Simulation")
339 ec.set(simu, "verbose", True)
340 ec.set(simu, "nsLog", "V4Ping:Node")
341 ec.set(simu, "buildMode", "debug")
342 ec.register_connection(simu, node)
344 nsnode1 = add_ns3_node(ec, simu)
345 dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
347 nsnode2 = add_ns3_node(ec, simu)
348 dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
351 chan = ec.register_resource("ns3::CsmaChannel")
352 ec.set(chan, "Delay", "0s")
353 ec.register_connection(chan, dev1)
354 ec.register_connection(chan, dev2)
357 ping = ec.register_resource("ns3::V4Ping")
358 ec.set (ping, "Remote", "10.0.0.2")
359 ec.set (ping, "Interval", "1s")
360 ec.set (ping, "Verbose", True)
361 ec.set (ping, "StartTime", "0s")
362 ec.set (ping, "StopTime", "20s")
363 ec.register_connection(ping, nsnode1)
367 ec.wait_finished([ping])
369 stdout = ec.trace(simu, "stdout")
371 expected = "20 packets transmitted, 20 received, 0% packet loss"
372 self.assertTrue(stdout.find(expected) > -1)
374 stderr = ec.trace(simu, "stderr")
375 expected = "V4Ping:Read32"
376 self.assertTrue(stderr.find(expected) > -1)
380 def test_real_time(self):
381 ec = ExperimentController(exp_id = "test-ns3-real-time")
383 node = ec.register_resource("LinuxNode")
384 ec.set(node, "hostname", self.fedora_host)
385 ec.set(node, "username", self.fedora_user)
386 ec.set(node, "identity", self.fedora_identity)
387 ec.set(node, "cleanProcesses", True)
388 #ec.set(node, "cleanHome", True)
390 simu = ec.register_resource("LinuxNS3Simulation")
391 ec.set(simu, "simulatorImplementationType", "ns3::RealtimeSimulatorImpl")
392 ec.set(simu, "checksumEnabled", True)
393 ec.set(simu, "verbose", True)
394 ec.register_connection(simu, node)
396 nsnode1 = add_ns3_node(ec, simu)
397 dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
399 nsnode2 = add_ns3_node(ec, simu)
400 dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
403 chan = ec.register_resource("ns3::PointToPointChannel")
404 ec.set(chan, "Delay", "0s")
405 ec.register_connection(chan, dev1)
406 ec.register_connection(chan, dev2)
409 ping = ec.register_resource("ns3::V4Ping")
410 ec.set (ping, "Remote", "10.0.0.2")
411 ec.set (ping, "Interval", "1s")
412 ec.set (ping, "Verbose", True)
413 ec.set (ping, "StartTime", "0s")
414 ec.set (ping, "StopTime", "20s")
415 ec.register_connection(ping, nsnode1)
419 ec.wait_finished([ping])
421 stdout = ec.trace(simu, "stdout")
423 expected = "20 packets transmitted, 20 received, 0% packet loss"
424 self.assertTrue(stdout.find(expected) > -1)
426 rm = ec.get_resource(ping)
427 start_time = rm.start_time
428 stop_time = rm.stop_time
429 delta = stop_time - start_time
431 self.assertTrue(delta.seconds >= 20, "Time elapsed %d" % delta.seconds)
432 self.assertTrue(delta.seconds < 25, "Time elapsed %d" % delta.seconds)
436 def test_traces(self):
437 ec = ExperimentController(exp_id = "test-ns3-traces")
439 node = ec.register_resource("LinuxNode")
440 ec.set(node, "hostname", self.fedora_host)
441 ec.set(node, "username", self.fedora_user)
442 ec.set(node, "identity", self.fedora_identity)
443 ec.set(node, "cleanProcesses", True)
444 #ec.set(node, "cleanHome", True)
446 simu = ec.register_resource("LinuxNS3Simulation")
447 ec.register_connection(simu, node)
449 nsnode1 = add_ns3_node(ec, simu)
450 dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
452 nsnode2 = add_ns3_node(ec, simu)
453 dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
456 chan = ec.register_resource("ns3::PointToPointChannel")
457 ec.set(chan, "Delay", "0s")
458 ec.register_connection(chan, dev1)
459 ec.register_connection(chan, dev2)
462 ping = ec.register_resource("ns3::V4Ping")
463 ec.set (ping, "Remote", "10.0.0.2")
464 ec.set (ping, "Interval", "1s")
465 ec.set (ping, "Verbose", True)
466 ec.set (ping, "StartTime", "0s")
467 ec.set (ping, "StopTime", "20s")
468 ec.register_connection(ping, nsnode1)
471 ec.enable_trace(dev1, "pcap")
472 ec.enable_trace(dev1, "promiscPcap")
473 ec.enable_trace(dev1, "ascii")
475 ec.enable_trace(dev2, "pcap")
476 ec.enable_trace(dev2, "promiscPcap")
477 ec.enable_trace(dev2, "ascii")
481 ec.wait_finished([ping])
484 rm_simu = ec.get_resource(simu)
486 # TODO: Fix this in ns-3: pcap traces do not flush until the Simulator
487 # process is ended, so we can't get the traces of the 'pcap' and
488 # 'promiscPcap' traces.
490 #for trace in ["pcap", "promiscPcap", "ascii"]:
491 for trace in ["ascii"]:
492 for guid in [dev1, dev2]:
493 output = ec.trace(guid, trace)
495 size = ec.trace(guid, trace, attr = TraceAttr.SIZE)
496 self.assertEquals(size, len(output))
497 self.assertTrue(size > 100)
499 block = ec.trace(guid, trace, attr = TraceAttr.STREAM, block = 5, offset = 1)
500 self.assertEquals(block, output[5:10])
502 trace_path = ec.trace(guid, trace, attr = TraceAttr.PATH)
503 rm = ec.get_resource(guid)
504 path = os.path.join(rm_simu.run_home, rm._trace_filename.get(trace))
505 self.assertEquals(trace_path, path)
509 def test_simple_wifi_ping(self):
510 bounds_width = bounds_height = 200
514 ec = ExperimentController(exp_id = "test-ns3-wifi-ping")
516 node = ec.register_resource("LinuxNode")
517 ec.set(node, "hostname", self.fedora_host)
518 ec.set(node, "username", self.fedora_user)
519 ec.set(node, "identity", self.fedora_identity)
520 ec.set(node, "cleanProcesses", True)
521 #ec.set(node, "cleanHome", True)
523 simu = ec.register_resource("LinuxNS3Simulation")
524 ec.set(simu, "verbose", True)
525 ec.register_connection(simu, node)
527 nsnode1 = add_ns3_node(ec, simu)
528 dev1, phy1 = add_wifi_device(ec, nsnode1, "10.0.0.1", "24", access_point = True)
529 mobility1 = add_constant_mobility(ec, nsnode1, x, y, 0)
531 nsnode2 = add_ns3_node(ec, simu)
532 dev2, phy2 = add_wifi_device(ec, nsnode2, "10.0.0.2", "24", access_point = False)
533 mobility1 = add_constant_mobility(ec, nsnode2, x, y, 0)
534 #mobility2 = add_random_mobility(ec, nsnode2, x, y, 0, speed, bounds_width, bounds_height)
537 chan = add_wifi_channel(ec)
538 ec.register_connection(chan, phy1)
539 ec.register_connection(chan, phy2)
542 ping = ec.register_resource("ns3::V4Ping")
543 ec.set (ping, "Remote", "10.0.0.1")
544 ec.set (ping, "Interval", "1s")
545 ec.set (ping, "Verbose", True)
546 ec.set (ping, "StartTime", "1s")
547 ec.set (ping, "StopTime", "21s")
548 ec.register_connection(ping, nsnode2)
552 ec.wait_finished([ping])
554 stdout = ec.trace(simu, "stdout")
556 expected = "20 packets transmitted, 20 received, 0% packet loss"
557 self.assertTrue(stdout.find(expected) > -1)
561 def test_routing(self):
566 n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
572 ec = ExperimentController(exp_id = "test-ns3-routes")
574 node = ec.register_resource("LinuxNode")
575 ec.set(node, "hostname", self.fedora_host)
576 ec.set(node, "username", self.fedora_user)
577 ec.set(node, "identity", self.fedora_identity)
578 ec.set(node, "cleanProcesses", True)
579 #ec.set(node, "cleanHome", True)
581 simu = ec.register_resource("LinuxNS3Simulation")
582 ec.set(simu, "verbose", True)
583 ec.register_connection(simu, node)
585 nsnode1 = add_ns3_node(ec, simu)
586 p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
588 nsnode2 = add_ns3_node(ec, simu)
589 p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
590 csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
592 nsnode3 = add_ns3_node(ec, simu)
593 csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
595 nsnode4 = add_ns3_node(ec, simu)
596 csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
598 nsnode5 = add_ns3_node(ec, simu)
599 p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
600 csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
602 nsnode6 = add_ns3_node(ec, simu)
603 p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
606 p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
607 ec.set(p2p_chan1, "Delay", "0s")
608 ec.register_connection(p2p_chan1, p2p12)
609 ec.register_connection(p2p_chan1, p2p21)
612 csma_chan = ec.register_resource("ns3::CsmaChannel")
613 ec.set(csma_chan, "Delay", "0s")
614 ec.register_connection(csma_chan, csma2)
615 ec.register_connection(csma_chan, csma3)
616 ec.register_connection(csma_chan, csma4)
617 ec.register_connection(csma_chan, csma5)
620 p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
621 ec.set(p2p_chan2, "Delay", "0s")
622 ec.register_connection(p2p_chan2, p2p56)
623 ec.register_connection(p2p_chan2, p2p65)
625 # Add routes - n1 - n6
626 r1 = ec.register_resource("ns3::Route")
627 ec.set(r1, "network", "10.0.2.0")
628 ec.set(r1, "prefix", "30")
629 ec.set(r1, "nexthop", "10.0.0.2")
630 ec.register_connection(r1, nsnode1)
632 # Add routes - n2 - n6
633 r2 = ec.register_resource("ns3::Route")
634 ec.set(r2, "network", "10.0.2.0")
635 ec.set(r2, "prefix", "30")
636 ec.set(r2, "nexthop", "10.0.1.4")
637 ec.register_connection(r2, nsnode2)
639 # Add routes - n5 - n1
640 r5 = ec.register_resource("ns3::Route")
641 ec.set(r5, "network", "10.0.0.0")
642 ec.set(r5, "prefix", "30")
643 ec.set(r5, "nexthop", "10.0.1.1")
644 ec.register_connection(r5, nsnode5)
646 # Add routes - n6 - n1
647 r6 = ec.register_resource("ns3::Route")
648 ec.set(r6, "network", "10.0.0.0")
649 ec.set(r6, "prefix", "30")
650 ec.set(r6, "nexthop", "10.0.2.1")
651 ec.register_connection(r6, nsnode6)
654 ping = ec.register_resource("ns3::V4Ping")
655 ec.set (ping, "Remote", "10.0.2.2")
656 ec.set (ping, "Interval", "1s")
657 ec.set (ping, "Verbose", True)
658 ec.set (ping, "StartTime", "1s")
659 ec.set (ping, "StopTime", "21s")
660 ec.register_connection(ping, nsnode1)
664 ec.wait_finished([ping])
666 stdout = ec.trace(simu, "stdout")
668 expected = "20 packets transmitted, 20 received, 0% packet loss"
669 self.assertTrue(stdout.find(expected) > -1)
673 def ztest_automatic_routing(self):
678 n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
684 ec = ExperimentController(exp_id = "test-ns3-auto-routes")
686 node = ec.register_resource("LinuxNode")
687 ec.set(node, "hostname", self.fedora_host)
688 ec.set(node, "username", self.fedora_user)
689 ec.set(node, "identity", self.fedora_identity)
690 ec.set(node, "cleanProcesses", True)
691 #ec.set(node, "cleanHome", True)
693 simu = ec.register_resource("LinuxNS3Simulation")
694 ec.set(simu, "verbose", True)
695 ec.set(simu, "populateRoutingTables", True)
696 ec.register_connection(simu, node)
698 nsnode1 = add_ns3_node(ec, simu)
699 p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
701 nsnode2 = add_ns3_node(ec, simu)
702 p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
703 csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
705 nsnode3 = add_ns3_node(ec, simu)
706 csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
708 nsnode4 = add_ns3_node(ec, simu)
709 csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
711 nsnode5 = add_ns3_node(ec, simu)
712 p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
713 csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
715 nsnode6 = add_ns3_node(ec, simu)
716 p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
719 p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
720 ec.set(p2p_chan1, "Delay", "0s")
721 ec.register_connection(p2p_chan1, p2p12)
722 ec.register_connection(p2p_chan1, p2p21)
725 csma_chan = ec.register_resource("ns3::CsmaChannel")
726 ec.set(csma_chan, "Delay", "0s")
727 ec.register_connection(csma_chan, csma2)
728 ec.register_connection(csma_chan, csma3)
729 ec.register_connection(csma_chan, csma4)
730 ec.register_connection(csma_chan, csma5)
733 p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
734 ec.set(p2p_chan2, "Delay", "0s")
735 ec.register_connection(p2p_chan2, p2p56)
736 ec.register_connection(p2p_chan2, p2p65)
739 ping = ec.register_resource("ns3::V4Ping")
740 ec.set (ping, "Remote", "10.0.1.2")
741 ec.set (ping, "Interval", "1s")
742 ec.set (ping, "Verbose", True)
743 ec.set (ping, "StartTime", "1s")
744 ec.set (ping, "StopTime", "21s")
745 ec.register_connection(ping, nsnode1)
749 ec.wait_finished([ping])
751 stdout = ec.trace(simu, "stdout")
755 expected = "20 packets transmitted, 20 received, 0% packet loss"
756 self.assertTrue(stdout.find(expected) > -1)
761 if __name__ == '__main__':