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_simple_p2p_ping(self):
 150         ec = ExperimentController(exp_id = "test-ns3-p2p-ping")
 151
 152         node = ec.register_resource("LinuxNode")
 153         ec.set(node, "hostname", self.fedora_host)
 154         ec.set(node, "username", self.fedora_user)
 155         ec.set(node, "identity", self.fedora_identity)
 156         ec.set(node, "cleanProcesses", True)
 157         #ec.set(node, "cleanHome", True)
 158
 159         simu = ec.register_resource("LinuxNS3Simulation")
 160         ec.register_connection(simu, node)
 161
 162         nsnode1 = add_ns3_node(ec, simu)
 163         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 164
 165         nsnode2 = add_ns3_node(ec, simu)
 166         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 167
 168         # Create channel
 169         chan = ec.register_resource("ns3::PointToPointChannel")
 170         ec.set(chan, "Delay", "0s")
 171         ec.register_connection(chan, dev1)
 172         ec.register_connection(chan, dev2)
 173
 174         ### create pinger
 175         ping = ec.register_resource("ns3::V4Ping")
 176         ec.set (ping, "Remote", "10.0.0.2")
 177         ec.set (ping, "Interval", "1s")
 178         ec.set (ping, "Verbose", True)
 179         ec.set (ping, "StartTime", "0s")
 180         ec.set (ping, "StopTime", "20s")
 181         ec.register_connection(ping, nsnode1)
 182
 183         ec.deploy()
 184
 185         ec.wait_finished([ping])
 186
 187         stdout = ec.trace(simu, "stdout")
 188
 189         expected = "20 packets transmitted, 20 received, 0% packet loss"
 190         self.assertTrue(stdout.find(expected) > -1)
 191
 192         ec.shutdown()
 193
 194     def test_simple_cmsa_ping(self):
 195         ec = ExperimentController(exp_id = "test-ns3-csma-ping")
 196
 197         node = ec.register_resource("LinuxNode")
 198         ec.set(node, "hostname", self.fedora_host)
 199         ec.set(node, "username", self.fedora_user)
 200         ec.set(node, "identity", self.fedora_identity)
 201         ec.set(node, "cleanProcesses", True)
 202         #ec.set(node, "cleanHome", True)
 203
 204         simu = ec.register_resource("LinuxNS3Simulation")
 205         ec.register_connection(simu, node)
 206
 207         nsnode1 = add_ns3_node(ec, simu)
 208         dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
 209
 210         nsnode2 = add_ns3_node(ec, simu)
 211         dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
 212
 213         # Create channel
 214         chan = ec.register_resource("ns3::CsmaChannel")
 215         ec.set(chan, "Delay", "0s")
 216         ec.register_connection(chan, dev1)
 217         ec.register_connection(chan, dev2)
 218
 219         ### create pinger
 220         ping = ec.register_resource("ns3::V4Ping")
 221         ec.set (ping, "Remote", "10.0.0.2")
 222         ec.set (ping, "Interval", "1s")
 223         ec.set (ping, "Verbose", True)
 224         ec.set (ping, "StartTime", "0s")
 225         ec.set (ping, "StopTime", "20s")
 226         ec.register_connection(ping, nsnode1)
 227
 228         ec.deploy()
 229
 230         ec.wait_finished([ping])
 231
 232         stdout = ec.trace(simu, "stdout")
 233
 234         expected = "20 packets transmitted, 20 received, 0% packet loss"
 235         self.assertTrue(stdout.find(expected) > -1)
 236
 237         ec.shutdown()
 238
 239     def test_compile_local_source(self):
 240         ec = ExperimentController(exp_id = "test-ns3-local-source")
 241
 242         node = ec.register_resource("LinuxNode")
 243         ec.set(node, "hostname", self.fedora_host)
 244         ec.set(node, "username", self.fedora_user)
 245         ec.set(node, "identity", self.fedora_identity)
 246         ec.set(node, "cleanProcesses", True)
 247         #ec.set(node, "cleanHome", True)
 248
 249         simu = ec.register_resource("LinuxNS3Simulation")
 250         sources = os.path.join(os.path.dirname(os.path.realpath(__file__)),
 251                 "ns-3.18-user.tar.gz")
 252         ec.set(simu, "sources", sources)
 253         ec.register_connection(simu, node)
 254
 255         nsnode1 = add_ns3_node(ec, simu)
 256         dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
 257
 258         nsnode2 = add_ns3_node(ec, simu)
 259         dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
 260
 261         # Create channel
 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)
 266
 267         ### create pinger
 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)
 275
 276         ec.deploy()
 277
 278         ec.wait_finished([ping])
 279
 280         stdout = ec.trace(simu, "stdout")
 281
 282         expected = "20 packets transmitted, 20 received, 0% packet loss"
 283         self.assertTrue(stdout.find(expected) > -1)
 284
 285         ec.shutdown()
 286
 287     def test_compile_debug_mode(self):
 288         ec = ExperimentController(exp_id = "test-ns3-debug-mode")
 289
 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)
 296
 297         simu = ec.register_resource("LinuxNS3Simulation")
 298         ec.set(simu, "verbose", True)
 299         ec.set(simu, "nsLog", "V4Ping:Node")
 300         ec.set(simu, "buildMode", "debug")
 301         ec.register_connection(simu, node)
 302
 303         nsnode1 = add_ns3_node(ec, simu)
 304         dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
 305
 306         nsnode2 = add_ns3_node(ec, simu)
 307         dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
 308
 309         # Create channel
 310         chan = ec.register_resource("ns3::CsmaChannel")
 311         ec.set(chan, "Delay", "0s")
 312         ec.register_connection(chan, dev1)
 313         ec.register_connection(chan, dev2)
 314
 315         ### create pinger
 316         ping = ec.register_resource("ns3::V4Ping")
 317         ec.set (ping, "Remote", "10.0.0.2")
 318         ec.set (ping, "Interval", "1s")
 319         ec.set (ping, "Verbose", True)
 320         ec.set (ping, "StartTime", "0s")
 321         ec.set (ping, "StopTime", "20s")
 322         ec.register_connection(ping, nsnode1)
 323
 324         ec.deploy()
 325
 326         ec.wait_finished([ping])
 327
 328         stdout = ec.trace(simu, "stdout")
 329
 330         expected = "20 packets transmitted, 20 received, 0% packet loss"
 331         self.assertTrue(stdout.find(expected) > -1)
 332
 333         stderr = ec.trace(simu, "stderr")
 334         expected = "V4Ping:Read32"
 335         self.assertTrue(stderr.find(expected) > -1)
 336
 337         ec.shutdown()
 338
 339     def test_real_time(self):
 340         ec = ExperimentController(exp_id = "test-ns3-real-time")
 341
 342         node = ec.register_resource("LinuxNode")
 343         ec.set(node, "hostname", self.fedora_host)
 344         ec.set(node, "username", self.fedora_user)
 345         ec.set(node, "identity", self.fedora_identity)
 346         ec.set(node, "cleanProcesses", True)
 347         #ec.set(node, "cleanHome", True)
 348
 349         simu = ec.register_resource("LinuxNS3Simulation")
 350         ec.set(simu, "simulatorImplementationType", "ns3::RealtimeSimulatorImpl")
 351         ec.set(simu, "checksumEnabled", True)
 352         ec.set(simu, "verbose", True)
 353         ec.register_connection(simu, node)
 354
 355         nsnode1 = add_ns3_node(ec, simu)
 356         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 357
 358         nsnode2 = add_ns3_node(ec, simu)
 359         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 360
 361         # Create channel
 362         chan = ec.register_resource("ns3::PointToPointChannel")
 363         ec.set(chan, "Delay", "0s")
 364         ec.register_connection(chan, dev1)
 365         ec.register_connection(chan, dev2)
 366
 367         ### create pinger
 368         ping = ec.register_resource("ns3::V4Ping")
 369         ec.set (ping, "Remote", "10.0.0.2")
 370         ec.set (ping, "Interval", "1s")
 371         ec.set (ping, "Verbose", True)
 372         ec.set (ping, "StartTime", "0s")
 373         ec.set (ping, "StopTime", "20s")
 374         ec.register_connection(ping, nsnode1)
 375
 376         ec.deploy()
 377
 378         ec.wait_finished([ping])
 379
 380         stdout = ec.trace(simu, "stdout")
 381
 382         expected = "20 packets transmitted, 20 received, 0% packet loss"
 383         self.assertTrue(stdout.find(expected) > -1)
 384
 385         rm = ec.get_resource(ping)
 386         start_time = rm.start_time
 387         stop_time = rm.stop_time
 388         delta =  stop_time - start_time
 389
 390         self.assertTrue(delta.seconds >= 20)
 391         self.assertTrue(delta.seconds < 25)
 392
 393         ec.shutdown()
 394
 395     def test_dev2p_traces(self):
 396         ec = ExperimentController(exp_id = "test-ns3-dev2p-traces")
 397
 398         node = ec.register_resource("LinuxNode")
 399         ec.set(node, "hostname", self.fedora_host)
 400         ec.set(node, "username", self.fedora_user)
 401         ec.set(node, "identity", self.fedora_identity)
 402         ec.set(node, "cleanProcesses", True)
 403         #ec.set(node, "cleanHome", True)
 404
 405         simu = ec.register_resource("LinuxNS3Simulation")
 406         ec.register_connection(simu, node)
 407
 408         nsnode1 = add_ns3_node(ec, simu)
 409         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 410
 411         nsnode2 = add_ns3_node(ec, simu)
 412         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 413
 414         # Create channel
 415         chan = ec.register_resource("ns3::PointToPointChannel")
 416         ec.set(chan, "Delay", "0s")
 417         ec.register_connection(chan, dev1)
 418         ec.register_connection(chan, dev2)
 419
 420         ### create pinger
 421         ping = ec.register_resource("ns3::V4Ping")
 422         ec.set (ping, "Remote", "10.0.0.2")
 423         ec.set (ping, "Interval", "1s")
 424         ec.set (ping, "Verbose", True)
 425         ec.set (ping, "StartTime", "0s")
 426         ec.set (ping, "StopTime", "20s")
 427         ec.register_connection(ping, nsnode1)
 428
 429         # enable traces
 430         ec.enable_trace(dev1, "pcap")
 431         ec.enable_trace(dev1, "promiscPcap")
 432         ec.enable_trace(dev1, "ascii")
 433
 434         ec.enable_trace(dev2, "pcap")
 435         ec.enable_trace(dev2, "promiscPcap")
 436         ec.enable_trace(dev2, "ascii")
 437
 438         ec.deploy()
 439
 440         ec.wait_finished([ping])
 441
 442         # Trace verification
 443         rm_simu = ec.get_resource(simu)
 444
 445         # TODO: Fix this in ns-3: pcap traces do not flush until the Simulator
 446         #   process is ended, so we can't get the traces of the 'pcap' and
 447         #   'promiscPcap' traces.
 448         #
 449         #for trace in ["pcap", "promiscPcap", "ascii"]:
 450         for trace in ["ascii"]:
 451             for guid in [dev1, dev2]:
 452                 output = ec.trace(guid, trace)
 453
 454                 size = ec.trace(guid, trace, attr = TraceAttr.SIZE)
 455                 self.assertEquals(size, len(output))
 456                 self.assertTrue(size > 100)
 457
 458                 block = ec.trace(guid, trace, attr = TraceAttr.STREAM, block = 5, offset = 1)
 459                 self.assertEquals(block, output[5:10])
 460
 461                 trace_path = ec.trace(guid, trace, attr = TraceAttr.PATH)
 462                 rm = ec.get_resource(guid)
 463                 path = os.path.join(rm_simu.run_home, rm._trace_filename.get(trace))
 464                 self.assertEquals(trace_path, path)
 465
 466         ec.shutdown()
 467
 468     def test_simple_wifi_ping(self):
 469         bounds_width = bounds_height = 200
 470         x = y = 100
 471         speed = 1
 472
 473         ec = ExperimentController(exp_id = "test-ns3-wifi-ping")
 474
 475         node = ec.register_resource("LinuxNode")
 476         ec.set(node, "hostname", self.fedora_host)
 477         ec.set(node, "username", self.fedora_user)
 478         ec.set(node, "identity", self.fedora_identity)
 479         ec.set(node, "cleanProcesses", True)
 480         #ec.set(node, "cleanHome", True)
 481
 482         simu = ec.register_resource("LinuxNS3Simulation")
 483         ec.set(simu, "verbose", True)
 484         ec.register_connection(simu, node)
 485
 486         nsnode1 = add_ns3_node(ec, simu)
 487         dev1, phy1 = add_wifi_device(ec, nsnode1, "10.0.0.1", "24", access_point = True)
 488         mobility1 = add_constant_mobility(ec, nsnode1, x, y, 0)
 489
 490         nsnode2 = add_ns3_node(ec, simu)
 491         dev2, phy2 = add_wifi_device(ec, nsnode2, "10.0.0.2", "24", access_point = False)
 492         mobility1 = add_constant_mobility(ec, nsnode2, x, y, 0)
 493         #mobility2 = add_random_mobility(ec, nsnode2, x, y, 0, speed, bounds_width, bounds_height)
 494
 495         # Create channel
 496         chan = add_wifi_channel(ec)
 497         ec.register_connection(chan, phy1)
 498         ec.register_connection(chan, phy2)
 499
 500         ### create pinger
 501         ping = ec.register_resource("ns3::V4Ping")
 502         ec.set (ping, "Remote", "10.0.0.1")
 503         ec.set (ping, "Interval", "1s")
 504         ec.set (ping, "Verbose", True)
 505         ec.set (ping, "StartTime", "1s")
 506         ec.set (ping, "StopTime", "21s")
 507         ec.register_connection(ping, nsnode2)
 508
 509         ec.deploy()
 510
 511         ec.wait_finished([ping])
 512
 513         stdout = ec.trace(simu, "stdout")
 514
 515         expected = "20 packets transmitted, 20 received, 0% packet loss"
 516         self.assertTrue(stdout.find(expected) > -1)
 517
 518         ec.shutdown()
 519
 520     def test_routing(self):
 521         """
 522         network topology:
 523                                 n4
 524                                 |
 525            n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
 526            |                    |
 527            ping n6              n3
 528
 529
 530         """
 531         ec = ExperimentController(exp_id = "test-ns3-routes")
 532
 533         node = ec.register_resource("LinuxNode")
 534         ec.set(node, "hostname", self.fedora_host)
 535         ec.set(node, "username", self.fedora_user)
 536         ec.set(node, "identity", self.fedora_identity)
 537         ec.set(node, "cleanProcesses", True)
 538         #ec.set(node, "cleanHome", True)
 539
 540         simu = ec.register_resource("LinuxNS3Simulation")
 541         ec.set(simu, "verbose", True)
 542         ec.register_connection(simu, node)
 543
 544         nsnode1 = add_ns3_node(ec, simu)
 545         p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 546
 547         nsnode2 = add_ns3_node(ec, simu)
 548         p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 549         csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
 550
 551         nsnode3 = add_ns3_node(ec, simu)
 552         csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
 553
 554         nsnode4 = add_ns3_node(ec, simu)
 555         csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
 556
 557         nsnode5 = add_ns3_node(ec, simu)
 558         p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
 559         csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
 560
 561         nsnode6 = add_ns3_node(ec, simu)
 562         p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
 563
 564         # P2P chan1
 565         p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
 566         ec.set(p2p_chan1, "Delay", "0s")
 567         ec.register_connection(p2p_chan1, p2p12)
 568         ec.register_connection(p2p_chan1, p2p21)
 569
 570         # CSMA chan
 571         csma_chan = ec.register_resource("ns3::CsmaChannel")
 572         ec.set(csma_chan, "Delay", "0s")
 573         ec.register_connection(csma_chan, csma2)
 574         ec.register_connection(csma_chan, csma3)
 575         ec.register_connection(csma_chan, csma4)
 576         ec.register_connection(csma_chan, csma5)
 577
 578         # P2P chan2
 579         p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
 580         ec.set(p2p_chan2, "Delay", "0s")
 581         ec.register_connection(p2p_chan2, p2p56)
 582         ec.register_connection(p2p_chan2, p2p65)
 583
 584         # Add routes - n1 - n6
 585         r1 = ec.register_resource("ns3::Route")
 586         ec.set(r1, "network", "10.0.2.0")
 587         ec.set(r1, "prefix", "30")
 588         ec.set(r1, "nexthop", "10.0.0.2")
 589         ec.register_connection(r1, nsnode1)
 590
 591         # Add routes - n2 - n6
 592         r2 = ec.register_resource("ns3::Route")
 593         ec.set(r2, "network", "10.0.2.0")
 594         ec.set(r2, "prefix", "30")
 595         ec.set(r2, "nexthop", "10.0.1.4")
 596         ec.register_connection(r2, nsnode2)
 597
 598         # Add routes - n5 - n1
 599         r5 = ec.register_resource("ns3::Route")
 600         ec.set(r5, "network", "10.0.0.0")
 601         ec.set(r5, "prefix", "30")
 602         ec.set(r5, "nexthop", "10.0.1.1")
 603         ec.register_connection(r5, nsnode5)
 604
 605         # Add routes - n6 - n1
 606         r6 = ec.register_resource("ns3::Route")
 607         ec.set(r6, "network", "10.0.0.0")
 608         ec.set(r6, "prefix", "30")
 609         ec.set(r6, "nexthop", "10.0.2.1")
 610         ec.register_connection(r6, nsnode6)
 611
 612         ### create pinger
 613         ping = ec.register_resource("ns3::V4Ping")
 614         ec.set (ping, "Remote", "10.0.2.2")
 615         ec.set (ping, "Interval", "1s")
 616         ec.set (ping, "Verbose", True)
 617         ec.set (ping, "StartTime", "1s")
 618         ec.set (ping, "StopTime", "21s")
 619         ec.register_connection(ping, nsnode1)
 620
 621         ec.deploy()
 622
 623         ec.wait_finished([ping])
 624
 625         stdout = ec.trace(simu, "stdout")
 626
 627         expected = "20 packets transmitted, 20 received, 0% packet loss"
 628         self.assertTrue(stdout.find(expected) > -1)
 629
 630         ec.shutdown()
 631
 632     def ztest_automatic_routing(self):
 633         """
 634         network topology:
 635                                 n4
 636                                 |
 637            n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
 638            |                    |
 639            ping n6              n3
 640
 641
 642         """
 643         ec = ExperimentController(exp_id = "test-ns3-auto-routes")
 644
 645         node = ec.register_resource("LinuxNode")
 646         ec.set(node, "hostname", self.fedora_host)
 647         ec.set(node, "username", self.fedora_user)
 648         ec.set(node, "identity", self.fedora_identity)
 649         ec.set(node, "cleanProcesses", True)
 650         #ec.set(node, "cleanHome", True)
 651
 652         simu = ec.register_resource("LinuxNS3Simulation")
 653         ec.set(simu, "verbose", True)
 654         ec.set(simu, "populateRoutingTables", True)
 655         ec.register_connection(simu, node)
 656
 657         nsnode1 = add_ns3_node(ec, simu)
 658         p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 659
 660         nsnode2 = add_ns3_node(ec, simu)
 661         p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 662         csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
 663
 664         nsnode3 = add_ns3_node(ec, simu)
 665         csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
 666
 667         nsnode4 = add_ns3_node(ec, simu)
 668         csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
 669
 670         nsnode5 = add_ns3_node(ec, simu)
 671         p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
 672         csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
 673
 674         nsnode6 = add_ns3_node(ec, simu)
 675         p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
 676
 677         # P2P chan1
 678         p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
 679         ec.set(p2p_chan1, "Delay", "0s")
 680         ec.register_connection(p2p_chan1, p2p12)
 681         ec.register_connection(p2p_chan1, p2p21)
 682
 683         # CSMA chan
 684         csma_chan = ec.register_resource("ns3::CsmaChannel")
 685         ec.set(csma_chan, "Delay", "0s")
 686         ec.register_connection(csma_chan, csma2)
 687         ec.register_connection(csma_chan, csma3)
 688         ec.register_connection(csma_chan, csma4)
 689         ec.register_connection(csma_chan, csma5)
 690
 691         # P2P chan2
 692         p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
 693         ec.set(p2p_chan2, "Delay", "0s")
 694         ec.register_connection(p2p_chan2, p2p56)
 695         ec.register_connection(p2p_chan2, p2p65)
 696
 697         ### create pinger
 698         ping = ec.register_resource("ns3::V4Ping")
 699         ec.set (ping, "Remote", "10.0.1.2")
 700         ec.set (ping, "Interval", "1s")
 701         ec.set (ping, "Verbose", True)
 702         ec.set (ping, "StartTime", "1s")
 703         ec.set (ping, "StopTime", "21s")
 704         ec.register_connection(ping, nsnode1)
 705
 706         ec.deploy()
 707
 708         ec.wait_finished([ping])
 709
 710         stdout = ec.trace(simu, "stdout")
 711
 712         print stdout
 713
 714         expected = "20 packets transmitted, 20 received, 0% packet loss"
 715         self.assertTrue(stdout.find(expected) > -1)
 716
 717         ec.shutdown()
 718
 719
 720 if __name__ == '__main__':
 721     unittest.main()
 722