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 from nepi.execution.ec import ExperimentController
  22 from nepi.execution.trace import TraceAttr
  23
  24 import os
  25 import time
  26 import unittest
  27
  28 def add_ns3_node(ec, simu):
  29     node = ec.register_resource("ns3::Node")
  30     ec.register_connection(node, simu)
  31
  32     ipv4 = ec.register_resource("ns3::Ipv4L3Protocol")
  33     ec.register_connection(node, ipv4)
  34
  35     arp = ec.register_resource("ns3::ArpL3Protocol")
  36     ec.register_connection(node, arp)
  37
  38     icmp = ec.register_resource("ns3::Icmpv4L4Protocol")
  39     ec.register_connection(node, icmp)
  40
  41     udp = ec.register_resource("ns3::UdpL4Protocol")
  42     ec.register_connection(node, udp)
  43
  44     return node
  45
  46 def add_point2point_device(ec, node, address = None,  prefix = None):
  47     dev = ec.register_resource("ns3::PointToPointNetDevice")
  48     if address:
  49        ec.set(dev, "ip", address)
  50     if prefix:
  51        ec.set(dev, "prefix", prefix)
  52     ec.register_connection(node, dev)
  53
  54     queue = ec.register_resource("ns3::DropTailQueue")
  55     ec.register_connection(dev, queue)
  56
  57     return dev
  58
  59 def add_csma_device(ec, node, address = None, prefix = None):
  60     dev = ec.register_resource("ns3::CsmaNetDevice")
  61     if address:
  62         ec.set(dev, "ip", address)
  63     if prefix:
  64         ec.set(dev, "prefix", prefix)
  65     ec.register_connection(node, dev)
  66
  67     queue = ec.register_resource("ns3::DropTailQueue")
  68     ec.register_connection(dev, queue)
  69
  70     return dev
  71
  72 def add_wifi_device(ec, node, address = None, prefix = None,
  73         access_point = False):
  74     dev = ec.register_resource("ns3::WifiNetDevice")
  75     if address:
  76         ec.set(dev, "ip", address)
  77     if prefix:
  78         ec.set(dev, "prefix", prefix)
  79     ec.register_connection(node, dev)
  80
  81     phy = ec.register_resource("ns3::YansWifiPhy")
  82     ec.set(phy, "Standard", "WIFI_PHY_STANDARD_80211a")
  83     ec.register_connection(dev, phy)
  84
  85     error = ec.register_resource("ns3::NistErrorRateModel")
  86     ec.register_connection(phy, error)
  87
  88     manager = ec.register_resource("ns3::ArfWifiManager")
  89     ec.register_connection(dev, manager)
  90
  91     if access_point:
  92         mac = ec.register_resource("ns3::ApWifiMac")
  93     else:
  94         mac = ec.register_resource("ns3::StaWifiMac")
  95
  96     ec.set(mac, "Standard", "WIFI_PHY_STANDARD_80211a")
  97     ec.register_connection(dev, mac)
  98
  99     return dev, phy
 100
 101 def add_random_mobility(ec, node, x, y, z, speed, bounds_width,
 102         bounds_height):
 103     position = "%d:%d:%d" % (x, y, z)
 104     bounds = "0|%d|0|%d" % (bounds_width, bounds_height)
 105     speed = "ns3::UniformRandomVariable[Min=%d|Max=%s]" % (speed, speed)
 106     pause = "ns3::ConstantRandomVariable[Constant=1.0]"
 107
 108     mobility = ec.register_resource("ns3::RandomDirection2dMobilityModel")
 109     ec.set(mobility, "Position", position)
 110     ec.set(mobility, "Bounds", bounds)
 111     ec.set(mobility, "Speed", speed)
 112     ec.set(mobility, "Pause",  pause)
 113     ec.register_connection(node, mobility)
 114     return mobility
 115
 116 def add_constant_mobility(ec, node, x, y, z):
 117     mobility = ec.register_resource("ns3::ConstantPositionMobilityModel")
 118     position = "%d:%d:%d" % (x, y, z)
 119     ec.set(mobility, "Position", position)
 120     ec.register_connection(node, mobility)
 121     return mobility
 122
 123 def add_wifi_channel(ec):
 124     channel = ec.register_resource("ns3::YansWifiChannel")
 125     delay = ec.register_resource("ns3::ConstantSpeedPropagationDelayModel")
 126     ec.register_connection(channel, delay)
 127
 128     loss  = ec.register_resource("ns3::LogDistancePropagationLossModel")
 129     ec.register_connection(channel, loss)
 130
 131     return channel
 132
 133 class LinuxNS3SimulationTest(unittest.TestCase):
 134     def setUp(self):
 135         self.fedora_host = "nepi2.pl.sophia.inria.fr"
 136         self.fedora_user = "inria_nepi"
 137         self.fedora_identity = "%s/.ssh/id_rsa_planetlab" % (os.environ['HOME'])
 138
 139     def test_local_p2p_ping(self):
 140         ec = ExperimentController(exp_id = "test-ns3-local-p2p")
 141
 142         node = ec.register_resource("LinuxNode")
 143         ec.set(node, "hostname", "localhost")
 144
 145         simu = ec.register_resource("LinuxNS3Simulation")
 146         ec.set(simu, "verbose", True)
 147         ec.register_connection(simu, node)
 148
 149         nsnode1 = add_ns3_node(ec, simu)
 150         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 151
 152         nsnode2 = add_ns3_node(ec, simu)
 153         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 154
 155         # Create channel
 156         chan = ec.register_resource("ns3::PointToPointChannel")
 157         ec.set(chan, "Delay", "0s")
 158         ec.register_connection(chan, dev1)
 159         ec.register_connection(chan, dev2)
 160
 161         ### create pinger
 162         ping = ec.register_resource("ns3::V4Ping")
 163         ec.set (ping, "Remote", "10.0.0.2")
 164         ec.set (ping, "Interval", "1s")
 165         ec.set (ping, "Verbose", True)
 166         ec.set (ping, "StartTime", "0s")
 167         ec.set (ping, "StopTime", "20s")
 168         ec.register_connection(ping, nsnode1)
 169
 170         ec.deploy()
 171
 172         ec.wait_finished([ping])
 173
 174         stdout = ec.trace(simu, "stdout")
 175
 176         expected = "20 packets transmitted, 20 received, 0% packet loss"
 177         self.assertTrue(stdout.find(expected) > -1)
 178
 179         ec.shutdown()
 180
 181     def test_simple_p2p_ping(self):
 182         ec = ExperimentController(exp_id = "test-ns3-p2p-ping")
 183
 184         node = ec.register_resource("LinuxNode")
 185         ec.set(node, "hostname", self.fedora_host)
 186         ec.set(node, "username", self.fedora_user)
 187         ec.set(node, "identity", self.fedora_identity)
 188         ec.set(node, "cleanProcesses", True)
 189         #ec.set(node, "cleanHome", True)
 190
 191         simu = ec.register_resource("LinuxNS3Simulation")
 192         ec.set(simu, "verbose", True)
 193         ec.register_connection(simu, node)
 194
 195         nsnode1 = add_ns3_node(ec, simu)
 196         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 197
 198         nsnode2 = add_ns3_node(ec, simu)
 199         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 200
 201         # Create channel
 202         chan = ec.register_resource("ns3::PointToPointChannel")
 203         ec.set(chan, "Delay", "0s")
 204         ec.register_connection(chan, dev1)
 205         ec.register_connection(chan, dev2)
 206
 207         ### create pinger
 208         ping = ec.register_resource("ns3::V4Ping")
 209         ec.set (ping, "Remote", "10.0.0.2")
 210         ec.set (ping, "Interval", "1s")
 211         ec.set (ping, "Verbose", True)
 212         ec.set (ping, "StartTime", "0s")
 213         ec.set (ping, "StopTime", "20s")
 214         ec.register_connection(ping, nsnode1)
 215
 216         ec.deploy()
 217
 218         ec.wait_finished([ping])
 219
 220         stdout = ec.trace(simu, "stdout")
 221
 222         expected = "20 packets transmitted, 20 received, 0% packet loss"
 223         self.assertTrue(stdout.find(expected) > -1)
 224
 225         ec.shutdown()
 226
 227     def test_simple_cmsa_ping(self):
 228         ec = ExperimentController(exp_id = "test-ns3-csma-ping")
 229
 230         node = ec.register_resource("LinuxNode")
 231         ec.set(node, "hostname", self.fedora_host)
 232         ec.set(node, "username", self.fedora_user)
 233         ec.set(node, "identity", self.fedora_identity)
 234         ec.set(node, "cleanProcesses", True)
 235         #ec.set(node, "cleanHome", True)
 236
 237         simu = ec.register_resource("LinuxNS3Simulation")
 238         ec.set(simu, "verbose", True)
 239         ec.register_connection(simu, node)
 240
 241         nsnode1 = add_ns3_node(ec, simu)
 242         dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
 243
 244         nsnode2 = add_ns3_node(ec, simu)
 245         dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
 246
 247         # Create channel
 248         chan = ec.register_resource("ns3::CsmaChannel")
 249         ec.set(chan, "Delay", "0s")
 250         ec.register_connection(chan, dev1)
 251         ec.register_connection(chan, dev2)
 252
 253         ### create pinger
 254         ping = ec.register_resource("ns3::V4Ping")
 255         ec.set (ping, "Remote", "10.0.0.2")
 256         ec.set (ping, "Interval", "1s")
 257         ec.set (ping, "Verbose", True)
 258         ec.set (ping, "StartTime", "0s")
 259         ec.set (ping, "StopTime", "20s")
 260         ec.register_connection(ping, nsnode1)
 261
 262         ec.deploy()
 263
 264         ec.wait_finished([ping])
 265
 266         stdout = ec.trace(simu, "stdout")
 267
 268         expected = "20 packets transmitted, 20 received, 0% packet loss"
 269         self.assertTrue(stdout.find(expected) > -1)
 270
 271         ec.shutdown()
 272
 273     def test_compile_local_source(self):
 274         ec = ExperimentController(exp_id = "test-ns3-local-source")
 275
 276         node = ec.register_resource("LinuxNode")
 277         ec.set(node, "hostname", self.fedora_host)
 278         ec.set(node, "username", self.fedora_user)
 279         ec.set(node, "identity", self.fedora_identity)
 280         ec.set(node, "cleanProcesses", True)
 281         #ec.set(node, "cleanHome", True)
 282
 283         simu = ec.register_resource("LinuxNS3Simulation")
 284         ec.set(simu, "verbose", True)
 285         sources = os.path.join(os.path.dirname(os.path.realpath(__file__)),
 286                 "ns-3.18-user.tar.gz")
 287         ec.set(simu, "sources", sources)
 288         ec.register_connection(simu, node)
 289
 290         nsnode1 = add_ns3_node(ec, simu)
 291         dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
 292
 293         nsnode2 = add_ns3_node(ec, simu)
 294         dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
 295
 296         # Create channel
 297         chan = ec.register_resource("ns3::CsmaChannel")
 298         ec.set(chan, "Delay", "0s")
 299         ec.register_connection(chan, dev1)
 300         ec.register_connection(chan, dev2)
 301
 302         ### create pinger
 303         ping = ec.register_resource("ns3::V4Ping")
 304         ec.set (ping, "Remote", "10.0.0.2")
 305         ec.set (ping, "Interval", "1s")
 306         ec.set (ping, "Verbose", True)
 307         ec.set (ping, "StartTime", "0s")
 308         ec.set (ping, "StopTime", "20s")
 309         ec.register_connection(ping, nsnode1)
 310
 311         ec.deploy()
 312
 313         ec.wait_finished([ping])
 314
 315         stdout = ec.trace(simu, "stdout")
 316
 317         expected = "20 packets transmitted, 20 received, 0% packet loss"
 318         self.assertTrue(stdout.find(expected) > -1)
 319
 320         ec.shutdown()
 321
 322     def test_compile_debug_mode(self):
 323         ec = ExperimentController(exp_id = "test-ns3-debug-mode")
 324
 325         node = ec.register_resource("LinuxNode")
 326         ec.set(node, "hostname", self.fedora_host)
 327         ec.set(node, "username", self.fedora_user)
 328         ec.set(node, "identity", self.fedora_identity)
 329         ec.set(node, "cleanProcesses", True)
 330         #ec.set(node, "cleanHome", True)
 331
 332         simu = ec.register_resource("LinuxNS3Simulation")
 333         ec.set(simu, "verbose", True)
 334         ec.set(simu, "nsLog", "V4Ping:Node")
 335         ec.set(simu, "buildMode", "debug")
 336         ec.register_connection(simu, node)
 337
 338         nsnode1 = add_ns3_node(ec, simu)
 339         dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
 340
 341         nsnode2 = add_ns3_node(ec, simu)
 342         dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
 343
 344         # Create channel
 345         chan = ec.register_resource("ns3::CsmaChannel")
 346         ec.set(chan, "Delay", "0s")
 347         ec.register_connection(chan, dev1)
 348         ec.register_connection(chan, dev2)
 349
 350         ### create pinger
 351         ping = ec.register_resource("ns3::V4Ping")
 352         ec.set (ping, "Remote", "10.0.0.2")
 353         ec.set (ping, "Interval", "1s")
 354         ec.set (ping, "Verbose", True)
 355         ec.set (ping, "StartTime", "0s")
 356         ec.set (ping, "StopTime", "20s")
 357         ec.register_connection(ping, nsnode1)
 358
 359         ec.deploy()
 360
 361         ec.wait_finished([ping])
 362
 363         stdout = ec.trace(simu, "stdout")
 364
 365         expected = "20 packets transmitted, 20 received, 0% packet loss"
 366         self.assertTrue(stdout.find(expected) > -1)
 367
 368         stderr = ec.trace(simu, "stderr")
 369         expected = "V4Ping:Read32"
 370         self.assertTrue(stderr.find(expected) > -1)
 371
 372         ec.shutdown()
 373
 374     def test_real_time(self):
 375         ec = ExperimentController(exp_id = "test-ns3-real-time")
 376
 377         node = ec.register_resource("LinuxNode")
 378         ec.set(node, "hostname", self.fedora_host)
 379         ec.set(node, "username", self.fedora_user)
 380         ec.set(node, "identity", self.fedora_identity)
 381         ec.set(node, "cleanProcesses", True)
 382         #ec.set(node, "cleanHome", True)
 383
 384         simu = ec.register_resource("LinuxNS3Simulation")
 385         ec.set(simu, "simulatorImplementationType", "ns3::RealtimeSimulatorImpl")
 386         ec.set(simu, "checksumEnabled", True)
 387         ec.set(simu, "verbose", True)
 388         ec.register_connection(simu, node)
 389
 390         nsnode1 = add_ns3_node(ec, simu)
 391         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 392
 393         nsnode2 = add_ns3_node(ec, simu)
 394         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 395
 396         # Create channel
 397         chan = ec.register_resource("ns3::PointToPointChannel")
 398         ec.set(chan, "Delay", "0s")
 399         ec.register_connection(chan, dev1)
 400         ec.register_connection(chan, dev2)
 401
 402         ### create pinger
 403         ping = ec.register_resource("ns3::V4Ping")
 404         ec.set (ping, "Remote", "10.0.0.2")
 405         ec.set (ping, "Interval", "1s")
 406         ec.set (ping, "Verbose", True)
 407         ec.set (ping, "StartTime", "0s")
 408         ec.set (ping, "StopTime", "20s")
 409         ec.register_connection(ping, nsnode1)
 410
 411         ec.deploy()
 412
 413         ec.wait_finished([ping])
 414
 415         stdout = ec.trace(simu, "stdout")
 416
 417         expected = "20 packets transmitted, 20 received, 0% packet loss"
 418         self.assertTrue(stdout.find(expected) > -1)
 419
 420         rm = ec.get_resource(ping)
 421         start_time = rm.start_time
 422         stop_time = rm.stop_time
 423         delta = stop_time - start_time
 424
 425         self.assertTrue(delta.seconds >= 20, "Time elapsed %d" % delta.seconds)
 426         self.assertTrue(delta.seconds < 25, "Time elapsed %d" % delta.seconds)
 427
 428         ec.shutdown()
 429
 430     def test_traces(self):
 431         ec = ExperimentController(exp_id = "test-ns3-traces")
 432
 433         node = ec.register_resource("LinuxNode")
 434         ec.set(node, "hostname", self.fedora_host)
 435         ec.set(node, "username", self.fedora_user)
 436         ec.set(node, "identity", self.fedora_identity)
 437         ec.set(node, "cleanProcesses", True)
 438         #ec.set(node, "cleanHome", True)
 439
 440         simu = ec.register_resource("LinuxNS3Simulation")
 441         ec.set(simu, "verbose", True)
 442         ec.register_connection(simu, node)
 443
 444         nsnode1 = add_ns3_node(ec, simu)
 445         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 446
 447         nsnode2 = add_ns3_node(ec, simu)
 448         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 449
 450         # Create channel
 451         chan = ec.register_resource("ns3::PointToPointChannel")
 452         ec.set(chan, "Delay", "0s")
 453         ec.register_connection(chan, dev1)
 454         ec.register_connection(chan, dev2)
 455
 456         ### create pinger
 457         ping = ec.register_resource("ns3::V4Ping")
 458         ec.set (ping, "Remote", "10.0.0.2")
 459         ec.set (ping, "Interval", "1s")
 460         ec.set (ping, "Verbose", True)
 461         ec.set (ping, "StartTime", "0s")
 462         ec.set (ping, "StopTime", "20s")
 463         ec.register_connection(ping, nsnode1)
 464
 465         # enable traces
 466         ec.enable_trace(dev1, "pcap")
 467         ec.enable_trace(dev1, "promiscPcap")
 468         ec.enable_trace(dev1, "ascii")
 469
 470         ec.enable_trace(dev2, "pcap")
 471         ec.enable_trace(dev2, "promiscPcap")
 472         ec.enable_trace(dev2, "ascii")
 473
 474         ec.deploy()
 475
 476         ec.wait_finished([ping])
 477
 478         # Trace verification
 479         rm_simu = ec.get_resource(simu)
 480
 481         # TODO: Fix this in ns-3: pcap traces do not flush until the Simulator
 482         #   process is ended, so we can't get the traces of the 'pcap' and
 483         #   'promiscPcap' traces.
 484         #
 485         #for trace in ["pcap", "promiscPcap", "ascii"]:
 486         for trace in ["ascii"]:
 487             for guid in [dev1, dev2]:
 488                 output = ec.trace(guid, trace)
 489
 490                 size = ec.trace(guid, trace, attr = TraceAttr.SIZE)
 491                 self.assertEquals(size, len(output))
 492                 self.assertTrue(size > 100)
 493
 494                 block = ec.trace(guid, trace, attr = TraceAttr.STREAM, block = 5, offset = 1)
 495                 self.assertEquals(block, output[5:10])
 496
 497                 trace_path = ec.trace(guid, trace, attr = TraceAttr.PATH)
 498                 rm = ec.get_resource(guid)
 499                 path = os.path.join(rm_simu.run_home, rm._trace_filename.get(trace))
 500                 self.assertEquals(trace_path, path)
 501
 502         ec.shutdown()
 503
 504     def test_simple_wifi_ping(self):
 505         bounds_width = bounds_height = 200
 506         x = y = 100
 507         speed = 1
 508
 509         ec = ExperimentController(exp_id = "test-ns3-wifi-ping")
 510
 511         node = ec.register_resource("LinuxNode")
 512         ec.set(node, "hostname", self.fedora_host)
 513         ec.set(node, "username", self.fedora_user)
 514         ec.set(node, "identity", self.fedora_identity)
 515         ec.set(node, "cleanProcesses", True)
 516         #ec.set(node, "cleanHome", True)
 517
 518         simu = ec.register_resource("LinuxNS3Simulation")
 519         ec.set(simu, "verbose", True)
 520         ec.register_connection(simu, node)
 521
 522         nsnode1 = add_ns3_node(ec, simu)
 523         dev1, phy1 = add_wifi_device(ec, nsnode1, "10.0.0.1", "24", access_point = True)
 524         mobility1 = add_constant_mobility(ec, nsnode1, x, y, 0)
 525
 526         nsnode2 = add_ns3_node(ec, simu)
 527         dev2, phy2 = add_wifi_device(ec, nsnode2, "10.0.0.2", "24", access_point = False)
 528         mobility1 = add_constant_mobility(ec, nsnode2, x, y, 0)
 529         #mobility2 = add_random_mobility(ec, nsnode2, x, y, 0, speed, bounds_width, bounds_height)
 530
 531         # Create channel
 532         chan = add_wifi_channel(ec)
 533         ec.register_connection(chan, phy1)
 534         ec.register_connection(chan, phy2)
 535
 536         ### create pinger
 537         ping = ec.register_resource("ns3::V4Ping")
 538         ec.set (ping, "Remote", "10.0.0.1")
 539         ec.set (ping, "Interval", "1s")
 540         ec.set (ping, "Verbose", True)
 541         ec.set (ping, "StartTime", "1s")
 542         ec.set (ping, "StopTime", "21s")
 543         ec.register_connection(ping, nsnode2)
 544
 545         ec.deploy()
 546
 547         ec.wait_finished([ping])
 548
 549         stdout = ec.trace(simu, "stdout")
 550
 551         expected = "20 packets transmitted, 20 received, 0% packet loss"
 552         self.assertTrue(stdout.find(expected) > -1)
 553
 554         ec.shutdown()
 555
 556     def test_routing(self):
 557         """
 558         network topology:
 559                                 n4
 560                                 |
 561            n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
 562            |                    |
 563            ping n6              n3
 564
 565
 566         """
 567         ec = ExperimentController(exp_id = "test-ns3-routes")
 568
 569         node = ec.register_resource("LinuxNode")
 570         ec.set(node, "hostname", self.fedora_host)
 571         ec.set(node, "username", self.fedora_user)
 572         ec.set(node, "identity", self.fedora_identity)
 573         ec.set(node, "cleanProcesses", True)
 574         #ec.set(node, "cleanHome", True)
 575
 576         simu = ec.register_resource("LinuxNS3Simulation")
 577         ec.set(simu, "verbose", True)
 578         ec.register_connection(simu, node)
 579
 580         nsnode1 = add_ns3_node(ec, simu)
 581         p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 582
 583         nsnode2 = add_ns3_node(ec, simu)
 584         p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 585         csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
 586
 587         nsnode3 = add_ns3_node(ec, simu)
 588         csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
 589
 590         nsnode4 = add_ns3_node(ec, simu)
 591         csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
 592
 593         nsnode5 = add_ns3_node(ec, simu)
 594         p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
 595         csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
 596
 597         nsnode6 = add_ns3_node(ec, simu)
 598         p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
 599
 600         # P2P chan1
 601         p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
 602         ec.set(p2p_chan1, "Delay", "0s")
 603         ec.register_connection(p2p_chan1, p2p12)
 604         ec.register_connection(p2p_chan1, p2p21)
 605
 606         # CSMA chan
 607         csma_chan = ec.register_resource("ns3::CsmaChannel")
 608         ec.set(csma_chan, "Delay", "0s")
 609         ec.register_connection(csma_chan, csma2)
 610         ec.register_connection(csma_chan, csma3)
 611         ec.register_connection(csma_chan, csma4)
 612         ec.register_connection(csma_chan, csma5)
 613
 614         # P2P chan2
 615         p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
 616         ec.set(p2p_chan2, "Delay", "0s")
 617         ec.register_connection(p2p_chan2, p2p56)
 618         ec.register_connection(p2p_chan2, p2p65)
 619
 620         # Add routes - n1 - n6
 621         r1 = ec.register_resource("ns3::Route")
 622         ec.set(r1, "network", "10.0.2.0")
 623         ec.set(r1, "prefix", "30")
 624         ec.set(r1, "nexthop", "10.0.0.2")
 625         ec.register_connection(r1, nsnode1)
 626
 627         # Add routes - n2 - n6
 628         r2 = ec.register_resource("ns3::Route")
 629         ec.set(r2, "network", "10.0.2.0")
 630         ec.set(r2, "prefix", "30")
 631         ec.set(r2, "nexthop", "10.0.1.4")
 632         ec.register_connection(r2, nsnode2)
 633
 634         # Add routes - n5 - n1
 635         r5 = ec.register_resource("ns3::Route")
 636         ec.set(r5, "network", "10.0.0.0")
 637         ec.set(r5, "prefix", "30")
 638         ec.set(r5, "nexthop", "10.0.1.1")
 639         ec.register_connection(r5, nsnode5)
 640
 641         # Add routes - n6 - n1
 642         r6 = ec.register_resource("ns3::Route")
 643         ec.set(r6, "network", "10.0.0.0")
 644         ec.set(r6, "prefix", "30")
 645         ec.set(r6, "nexthop", "10.0.2.1")
 646         ec.register_connection(r6, nsnode6)
 647
 648         ### create pinger
 649         ping = ec.register_resource("ns3::V4Ping")
 650         ec.set (ping, "Remote", "10.0.2.2")
 651         ec.set (ping, "Interval", "1s")
 652         ec.set (ping, "Verbose", True)
 653         ec.set (ping, "StartTime", "1s")
 654         ec.set (ping, "StopTime", "21s")
 655         ec.register_connection(ping, nsnode1)
 656
 657         ec.deploy()
 658
 659         ec.wait_finished([ping])
 660
 661         stdout = ec.trace(simu, "stdout")
 662
 663         expected = "20 packets transmitted, 20 received, 0% packet loss"
 664         self.assertTrue(stdout.find(expected) > -1)
 665
 666         ec.shutdown()
 667
 668     def ztest_automatic_routing(self):
 669         """
 670         network topology:
 671                                 n4
 672                                 |
 673            n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
 674            |                    |
 675            ping n6              n3
 676
 677
 678         """
 679         ec = ExperimentController(exp_id = "test-ns3-routing")
 680
 681         node = ec.register_resource("LinuxNode")
 682         ec.set(node, "hostname", self.fedora_host)
 683         ec.set(node, "username", self.fedora_user)
 684         ec.set(node, "identity", self.fedora_identity)
 685         ec.set(node, "cleanProcesses", True)
 686         #ec.set(node, "cleanHome", True)
 687
 688         simu = ec.register_resource("LinuxNS3Simulation")
 689         ec.set(simu, "verbose", True)
 690         ec.set(simu, "populateRoutingTables", True)
 691         ec.register_connection(simu, node)
 692
 693         nsnode1 = add_ns3_node(ec, simu)
 694         p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 695
 696         nsnode2 = add_ns3_node(ec, simu)
 697         p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 698         csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
 699
 700         nsnode3 = add_ns3_node(ec, simu)
 701         csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
 702
 703         nsnode4 = add_ns3_node(ec, simu)
 704         csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
 705
 706         nsnode5 = add_ns3_node(ec, simu)
 707         p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
 708         csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
 709
 710         nsnode6 = add_ns3_node(ec, simu)
 711         p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
 712
 713         # P2P chan1
 714         p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
 715         ec.set(p2p_chan1, "Delay", "0s")
 716         ec.register_connection(p2p_chan1, p2p12)
 717         ec.register_connection(p2p_chan1, p2p21)
 718
 719         # CSMA chan
 720         csma_chan = ec.register_resource("ns3::CsmaChannel")
 721         ec.set(csma_chan, "Delay", "0s")
 722         ec.register_connection(csma_chan, csma2)
 723         ec.register_connection(csma_chan, csma3)
 724         ec.register_connection(csma_chan, csma4)
 725         ec.register_connection(csma_chan, csma5)
 726
 727         # P2P chan2
 728         p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
 729         ec.set(p2p_chan2, "Delay", "0s")
 730         ec.register_connection(p2p_chan2, p2p56)
 731         ec.register_connection(p2p_chan2, p2p65)
 732
 733         ### create pinger
 734         ping = ec.register_resource("ns3::V4Ping")
 735         ec.set (ping, "Remote", "10.0.1.2")
 736         ec.set (ping, "Interval", "1s")
 737         ec.set (ping, "Verbose", True)
 738         ec.set (ping, "StartTime", "1s")
 739         ec.set (ping, "StopTime", "21s")
 740         ec.register_connection(ping, nsnode1)
 741
 742         ec.deploy()
 743
 744         ec.wait_finished([ping])
 745
 746         stdout = ec.trace(simu, "stdout")
 747
 748         print stdout
 749
 750         expected = "20 packets transmitted, 20 received, 0% packet loss"
 751         self.assertTrue(stdout.find(expected) > -1)
 752
 753         ec.shutdown()
 754
 755     def test_dce(self):
 756         ec = ExperimentController(exp_id = "test-ns3-dce")
 757
 758         node = ec.register_resource("LinuxNode")
 759         ec.set(node, "hostname", self.fedora_host)
 760         ec.set(node, "username", self.fedora_user)
 761         ec.set(node, "identity", self.fedora_identity)
 762         ec.set(node, "cleanProcesses", True)
 763         #ec.set(node, "cleanHome", True)
 764
 765         simu = ec.register_resource("LinuxNS3Simulation")
 766         ec.set(simu, "verbose", True)
 767         ec.set(simu, "enableDCE", True)
 768         ec.set(simu, "buildMode", "debug")
 769         ec.set(simu, "nsLog", "DceApplication")
 770         ec.register_connection(simu, node)
 771
 772         nsnode1 = add_ns3_node(ec, simu)
 773         ec.set(nsnode1, "enableDCE", True)
 774         p2p1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 775         ec.set(p2p1, "DataRate", "5Mbps")
 776
 777         nsnode2 = add_ns3_node(ec, simu)
 778         ec.set(nsnode2, "enableDCE", True)
 779         p2p2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 780         ec.set(p2p2, "DataRate", "5Mbps")
 781
 782         # Create channel
 783         chan = ec.register_resource("ns3::PointToPointChannel")
 784         ec.set(chan, "Delay", "2ms")
 785
 786         ec.register_connection(chan, p2p1)
 787         ec.register_connection(chan, p2p2)
 788
 789         ### create applications
 790         udp_perf = ec.register_resource("ns3::DceApplication")
 791         ec.set (udp_perf, "binary", "udp-perf")
 792         ec.set (udp_perf, "stackSize", 1<<20)
 793         ec.set (udp_perf, "arguments", "--duration=10;--nodes=2")
 794         ec.set (udp_perf, "StartTime", "1s")
 795         ec.set (udp_perf, "StopTime", "20s")
 796         ec.register_connection(udp_perf, nsnode1)
 797
 798         udp_perf_client = ec.register_resource("ns3::DceApplication")
 799         ec.set (udp_perf_client, "binary", "udp-perf")
 800         ec.set (udp_perf_client, "stackSize", 1<<20)
 801         ec.set (udp_perf_client, "arguments", "--client;--nodes=2;--host=10.0.0.1;--duration=10")
 802         ec.set (udp_perf_client, "StartTime", "2s")
 803         ec.set (udp_perf_client, "StopTime", "20s")
 804         ec.register_connection(udp_perf_client, nsnode2)
 805
 806         ec.deploy()
 807
 808         ec.wait_finished([udp_perf_client])
 809
 810         expected = "udp-perf --duration=10 --nodes=2"
 811         cmdline = ec.trace(udp_perf, "cmdline")
 812         self.assertTrue(cmdline.find(expected) > -1, cmdline)
 813
 814         expected = "Start Time: NS3 Time:          1s ("
 815         status = ec.trace(udp_perf, "status")
 816         self.assertTrue(status.find(expected) > -1, status)
 817
 818         expected = "received=1500 bytes, 1 reads (@1500 bytes) 1500"
 819         stdout = ec.trace(udp_perf, "stdout")
 820         self.assertTrue(stdout.find(expected) > -1, stdout)
 821
 822         stderr = ec.trace(simu, "stderr")
 823         expected = "DceApplication:StartApplication"
 824         self.assertTrue(stderr.find(expected) > -1, stderr)
 825
 826         ec.shutdown()
 827
 828
 829 if __name__ == '__main__':
 830     unittest.main()
 831