test/resources/linux/ns3/ns3simulation.py

   1 #!/usr/bin/env python
   2 #
   3 #    NEPI, a framework to manage network experiments
   4 #    Copyright (C) 2013 INRIA
   5 #
   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.
  10 #
  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.
  15 #
  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/>.
  18 #
  19 # Author: Alina Quereilhac <alina.quereilhac@inria.fr>
  20
  21
  22 #
  23 # Network topology
  24 #
  25 #       n0    n1   n2   n3
  26 #       |     |    |    |
  27 #       -----------------
  28 #
  29 #  node n0 sends IGMP traffic to node n3
  30
  31
  32 from nepi.execution.ec import ExperimentController
  33 from nepi.execution.trace import TraceAttr
  34
  35 import os
  36 import time
  37 import unittest
  38
  39 def add_ns3_node(ec, simu):
  40     node = ec.register_resource("ns3::Node")
  41     ec.register_connection(node, simu)
  42
  43     ipv4 = ec.register_resource("ns3::Ipv4L3Protocol")
  44     ec.register_connection(node, ipv4)
  45
  46     arp = ec.register_resource("ns3::ArpL3Protocol")
  47     ec.register_connection(node, arp)
  48
  49     icmp = ec.register_resource("ns3::Icmpv4L4Protocol")
  50     ec.register_connection(node, icmp)
  51
  52     return node
  53
  54 def add_point2point_device(ec, node, address = None,  prefix = None):
  55     dev = ec.register_resource("ns3::PointToPointNetDevice")
  56     if address:
  57        ec.set(dev, "ip", address)
  58     if prefix:
  59        ec.set(dev, "prefix", prefix)
  60     ec.register_connection(node, dev)
  61
  62     queue = ec.register_resource("ns3::DropTailQueue")
  63     ec.register_connection(dev, queue)
  64
  65     return dev
  66
  67 def add_csma_device(ec, node, address = None, prefix = None):
  68     dev = ec.register_resource("ns3::CsmaNetDevice")
  69     if address:
  70         ec.set(dev, "ip", address)
  71     if prefix:
  72         ec.set(dev, "prefix", prefix)
  73     ec.register_connection(node, dev)
  74
  75     queue = ec.register_resource("ns3::DropTailQueue")
  76     ec.register_connection(dev, queue)
  77
  78     return dev
  79
  80 def add_wifi_device(ec, node, address = None, prefix = None,
  81         access_point = False):
  82     dev = ec.register_resource("ns3::WifiNetDevice")
  83     if address:
  84         ec.set(dev, "ip", address)
  85     if prefix:
  86         ec.set(dev, "prefix", prefix)
  87     ec.register_connection(node, dev)
  88
  89     phy = ec.register_resource("ns3::YansWifiPhy")
  90     ec.set(phy, "Standard", "WIFI_PHY_STANDARD_80211a")
  91     ec.register_connection(dev, phy)
  92
  93     error = ec.register_resource("ns3::NistErrorRateModel")
  94     ec.register_connection(phy, error)
  95
  96     manager = ec.register_resource("ns3::ArfWifiManager")
  97     ec.register_connection(dev, manager)
  98
  99     if access_point:
 100         mac = ec.register_resource("ns3::ApWifiMac")
 101     else:
 102         mac = ec.register_resource("ns3::StaWifiMac")
 103
 104     ec.set(mac, "Standard", "WIFI_PHY_STANDARD_80211a")
 105     ec.register_connection(dev, mac)
 106
 107     return dev, phy
 108
 109 def add_random_mobility(ec, node, x, y, z, speed, bounds_width,
 110         bounds_height):
 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]"
 115
 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)
 122     return mobility
 123
 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)
 129     return mobility
 130
 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)
 135
 136     loss  = ec.register_resource("ns3::LogDistancePropagationLossModel")
 137     ec.register_connection(channel, loss)
 138
 139     return channel
 140
 141 class LinuxNS3ClientTest(unittest.TestCase):
 142     def setUp(self):
 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'])
 148
 149     def test_local_p2p_ping(self):
 150         ec = ExperimentController(exp_id = "test-ns3-local-p2p")
 151
 152         node = ec.register_resource("LinuxNode")
 153         ec.set(node, "hostname", "localhost")
 154
 155         simu = ec.register_resource("LinuxNS3Simulation")
 156         ec.register_connection(simu, node)
 157
 158         nsnode1 = add_ns3_node(ec, simu)
 159         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 160
 161         nsnode2 = add_ns3_node(ec, simu)
 162         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 163
 164         # Create channel
 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)
 169
 170         ### create pinger
 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)
 178
 179         ec.deploy()
 180
 181         ec.wait_finished([ping])
 182
 183         stdout = ec.trace(simu, "stdout")
 184
 185         expected = "20 packets transmitted, 20 received, 0% packet loss"
 186         self.assertTrue(stdout.find(expected) > -1)
 187
 188         ec.shutdown()
 189
 190     def test_simple_p2p_ping(self):
 191         ec = ExperimentController(exp_id = "test-ns3-p2p-ping")
 192
 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)
 199
 200         simu = ec.register_resource("LinuxNS3Simulation")
 201         ec.register_connection(simu, node)
 202
 203         nsnode1 = add_ns3_node(ec, simu)
 204         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 205
 206         nsnode2 = add_ns3_node(ec, simu)
 207         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 208
 209         # Create channel
 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)
 214
 215         ### create pinger
 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)
 223
 224         ec.deploy()
 225
 226         ec.wait_finished([ping])
 227
 228         stdout = ec.trace(simu, "stdout")
 229
 230         expected = "20 packets transmitted, 20 received, 0% packet loss"
 231         self.assertTrue(stdout.find(expected) > -1)
 232
 233         ec.shutdown()
 234
 235     def test_simple_cmsa_ping(self):
 236         ec = ExperimentController(exp_id = "test-ns3-csma-ping")
 237
 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)
 244
 245         simu = ec.register_resource("LinuxNS3Simulation")
 246         ec.register_connection(simu, node)
 247
 248         nsnode1 = add_ns3_node(ec, simu)
 249         dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
 250
 251         nsnode2 = add_ns3_node(ec, simu)
 252         dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
 253
 254         # Create channel
 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)
 259
 260         ### create pinger
 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)
 268
 269         ec.deploy()
 270
 271         ec.wait_finished([ping])
 272
 273         stdout = ec.trace(simu, "stdout")
 274
 275         expected = "20 packets transmitted, 20 received, 0% packet loss"
 276         self.assertTrue(stdout.find(expected) > -1)
 277
 278         ec.shutdown()
 279
 280     def test_compile_local_source(self):
 281         ec = ExperimentController(exp_id = "test-ns3-local-source")
 282
 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)
 289
 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)
 295
 296         nsnode1 = add_ns3_node(ec, simu)
 297         dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
 298
 299         nsnode2 = add_ns3_node(ec, simu)
 300         dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
 301
 302         # Create channel
 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)
 307
 308         ### create pinger
 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)
 316
 317         ec.deploy()
 318
 319         ec.wait_finished([ping])
 320
 321         stdout = ec.trace(simu, "stdout")
 322
 323         expected = "20 packets transmitted, 20 received, 0% packet loss"
 324         self.assertTrue(stdout.find(expected) > -1)
 325
 326         ec.shutdown()
 327
 328     def test_compile_debug_mode(self):
 329         ec = ExperimentController(exp_id = "test-ns3-debug-mode")
 330
 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)
 337
 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)
 343
 344         nsnode1 = add_ns3_node(ec, simu)
 345         dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
 346
 347         nsnode2 = add_ns3_node(ec, simu)
 348         dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
 349
 350         # Create channel
 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)
 355
 356         ### create pinger
 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)
 364
 365         ec.deploy()
 366
 367         ec.wait_finished([ping])
 368
 369         stdout = ec.trace(simu, "stdout")
 370
 371         expected = "20 packets transmitted, 20 received, 0% packet loss"
 372         self.assertTrue(stdout.find(expected) > -1)
 373
 374         stderr = ec.trace(simu, "stderr")
 375         expected = "V4Ping:Read32"
 376         self.assertTrue(stderr.find(expected) > -1)
 377
 378         ec.shutdown()
 379
 380     def test_real_time(self):
 381         ec = ExperimentController(exp_id = "test-ns3-real-time")
 382
 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)
 389
 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)
 395
 396         nsnode1 = add_ns3_node(ec, simu)
 397         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 398
 399         nsnode2 = add_ns3_node(ec, simu)
 400         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 401
 402         # Create channel
 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)
 407
 408         ### create pinger
 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)
 416
 417         ec.deploy()
 418
 419         ec.wait_finished([ping])
 420
 421         stdout = ec.trace(simu, "stdout")
 422
 423         expected = "20 packets transmitted, 20 received, 0% packet loss"
 424         self.assertTrue(stdout.find(expected) > -1)
 425
 426         rm = ec.get_resource(ping)
 427         start_time = rm.start_time
 428         stop_time = rm.stop_time
 429         delta = stop_time - start_time
 430
 431         self.assertTrue(delta.seconds >= 20, "Time elapsed %d" % delta.seconds)
 432         self.assertTrue(delta.seconds < 25, "Time elapsed %d" % delta.seconds)
 433
 434         ec.shutdown()
 435
 436     def test_traces(self):
 437         ec = ExperimentController(exp_id = "test-ns3-traces")
 438
 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)
 445
 446         simu = ec.register_resource("LinuxNS3Simulation")
 447         ec.register_connection(simu, node)
 448
 449         nsnode1 = add_ns3_node(ec, simu)
 450         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 451
 452         nsnode2 = add_ns3_node(ec, simu)
 453         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 454
 455         # Create channel
 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)
 460
 461         ### create pinger
 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)
 469
 470         # enable traces
 471         ec.enable_trace(dev1, "pcap")
 472         ec.enable_trace(dev1, "promiscPcap")
 473         ec.enable_trace(dev1, "ascii")
 474
 475         ec.enable_trace(dev2, "pcap")
 476         ec.enable_trace(dev2, "promiscPcap")
 477         ec.enable_trace(dev2, "ascii")
 478
 479         ec.deploy()
 480
 481         ec.wait_finished([ping])
 482
 483         # Trace verification
 484         rm_simu = ec.get_resource(simu)
 485
 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.
 489         #
 490         #for trace in ["pcap", "promiscPcap", "ascii"]:
 491         for trace in ["ascii"]:
 492             for guid in [dev1, dev2]:
 493                 output = ec.trace(guid, trace)
 494
 495                 size = ec.trace(guid, trace, attr = TraceAttr.SIZE)
 496                 self.assertEquals(size, len(output))
 497                 self.assertTrue(size > 100)
 498
 499                 block = ec.trace(guid, trace, attr = TraceAttr.STREAM, block = 5, offset = 1)
 500                 self.assertEquals(block, output[5:10])
 501
 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)
 506
 507         ec.shutdown()
 508
 509     def test_simple_wifi_ping(self):
 510         bounds_width = bounds_height = 200
 511         x = y = 100
 512         speed = 1
 513
 514         ec = ExperimentController(exp_id = "test-ns3-wifi-ping")
 515
 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)
 522
 523         simu = ec.register_resource("LinuxNS3Simulation")
 524         ec.set(simu, "verbose", True)
 525         ec.register_connection(simu, node)
 526
 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)
 530
 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)
 535
 536         # Create channel
 537         chan = add_wifi_channel(ec)
 538         ec.register_connection(chan, phy1)
 539         ec.register_connection(chan, phy2)
 540
 541         ### create pinger
 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)
 549
 550         ec.deploy()
 551
 552         ec.wait_finished([ping])
 553
 554         stdout = ec.trace(simu, "stdout")
 555
 556         expected = "20 packets transmitted, 20 received, 0% packet loss"
 557         self.assertTrue(stdout.find(expected) > -1)
 558
 559         ec.shutdown()
 560
 561     def test_routing(self):
 562         """
 563         network topology:
 564                                 n4
 565                                 |
 566            n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
 567            |                    |
 568            ping n6              n3
 569
 570
 571         """
 572         ec = ExperimentController(exp_id = "test-ns3-routes")
 573
 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)
 580
 581         simu = ec.register_resource("LinuxNS3Simulation")
 582         ec.set(simu, "verbose", True)
 583         ec.register_connection(simu, node)
 584
 585         nsnode1 = add_ns3_node(ec, simu)
 586         p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 587
 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")
 591
 592         nsnode3 = add_ns3_node(ec, simu)
 593         csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
 594
 595         nsnode4 = add_ns3_node(ec, simu)
 596         csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
 597
 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")
 601
 602         nsnode6 = add_ns3_node(ec, simu)
 603         p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
 604
 605         # P2P chan1
 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)
 610
 611         # CSMA chan
 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)
 618
 619         # P2P chan2
 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)
 624
 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)
 631
 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)
 638
 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)
 645
 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)
 652
 653         ### create pinger
 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)
 661
 662         ec.deploy()
 663
 664         ec.wait_finished([ping])
 665
 666         stdout = ec.trace(simu, "stdout")
 667
 668         expected = "20 packets transmitted, 20 received, 0% packet loss"
 669         self.assertTrue(stdout.find(expected) > -1)
 670
 671         ec.shutdown()
 672
 673     def ztest_automatic_routing(self):
 674         """
 675         network topology:
 676                                 n4
 677                                 |
 678            n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
 679            |                    |
 680            ping n6              n3
 681
 682
 683         """
 684         ec = ExperimentController(exp_id = "test-ns3-auto-routes")
 685
 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)
 692
 693         simu = ec.register_resource("LinuxNS3Simulation")
 694         ec.set(simu, "verbose", True)
 695         ec.set(simu, "populateRoutingTables", True)
 696         ec.register_connection(simu, node)
 697
 698         nsnode1 = add_ns3_node(ec, simu)
 699         p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 700
 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")
 704
 705         nsnode3 = add_ns3_node(ec, simu)
 706         csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
 707
 708         nsnode4 = add_ns3_node(ec, simu)
 709         csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
 710
 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")
 714
 715         nsnode6 = add_ns3_node(ec, simu)
 716         p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
 717
 718         # P2P chan1
 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)
 723
 724         # CSMA chan
 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)
 731
 732         # P2P chan2
 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)
 737
 738         ### create pinger
 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)
 746
 747         ec.deploy()
 748
 749         ec.wait_finished([ping])
 750
 751         stdout = ec.trace(simu, "stdout")
 752
 753         print stdout
 754
 755         expected = "20 packets transmitted, 20 received, 0% packet loss"
 756         self.assertTrue(stdout.find(expected) > -1)
 757
 758         ec.shutdown()
 759
 760
 761 if __name__ == '__main__':
 762     unittest.main()
 763