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.set(simu, "pybindgenVersion", "834")
 289         ec.register_connection(simu, node)
 290
 291         nsnode1 = add_ns3_node(ec, simu)
 292         dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
 293
 294         nsnode2 = add_ns3_node(ec, simu)
 295         dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
 296
 297         # Create channel
 298         chan = ec.register_resource("ns3::CsmaChannel")
 299         ec.set(chan, "Delay", "0s")
 300         ec.register_connection(chan, dev1)
 301         ec.register_connection(chan, dev2)
 302
 303         ### create pinger
 304         ping = ec.register_resource("ns3::V4Ping")
 305         ec.set (ping, "Remote", "10.0.0.2")
 306         ec.set (ping, "Interval", "1s")
 307         ec.set (ping, "Verbose", True)
 308         ec.set (ping, "StartTime", "0s")
 309         ec.set (ping, "StopTime", "20s")
 310         ec.register_connection(ping, nsnode1)
 311
 312         ec.deploy()
 313
 314         ec.wait_finished([ping])
 315
 316         stdout = ec.trace(simu, "stdout")
 317
 318         expected = "20 packets transmitted, 20 received, 0% packet loss"
 319         self.assertTrue(stdout.find(expected) > -1)
 320
 321         ec.shutdown()
 322
 323     def test_compile_debug_mode(self):
 324         ec = ExperimentController(exp_id = "test-ns3-debug-mode")
 325
 326         node = ec.register_resource("LinuxNode")
 327         ec.set(node, "hostname", self.fedora_host)
 328         ec.set(node, "username", self.fedora_user)
 329         ec.set(node, "identity", self.fedora_identity)
 330         ec.set(node, "cleanProcesses", True)
 331         #ec.set(node, "cleanHome", True)
 332
 333         simu = ec.register_resource("LinuxNS3Simulation")
 334         ec.set(simu, "verbose", True)
 335         ec.set(simu, "nsLog", "V4Ping:Node")
 336         ec.set(simu, "buildMode", "debug")
 337         ec.register_connection(simu, node)
 338
 339         nsnode1 = add_ns3_node(ec, simu)
 340         dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
 341
 342         nsnode2 = add_ns3_node(ec, simu)
 343         dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
 344
 345         # Create channel
 346         chan = ec.register_resource("ns3::CsmaChannel")
 347         ec.set(chan, "Delay", "0s")
 348         ec.register_connection(chan, dev1)
 349         ec.register_connection(chan, dev2)
 350
 351         ### create pinger
 352         ping = ec.register_resource("ns3::V4Ping")
 353         ec.set (ping, "Remote", "10.0.0.2")
 354         ec.set (ping, "Interval", "1s")
 355         ec.set (ping, "Verbose", True)
 356         ec.set (ping, "StartTime", "0s")
 357         ec.set (ping, "StopTime", "20s")
 358         ec.register_connection(ping, nsnode1)
 359
 360         ec.deploy()
 361
 362         ec.wait_finished([ping])
 363
 364         stdout = ec.trace(simu, "stdout")
 365
 366         expected = "20 packets transmitted, 20 received, 0% packet loss"
 367         self.assertTrue(stdout.find(expected) > -1)
 368
 369         stderr = ec.trace(simu, "stderr")
 370         expected = "V4Ping:Read32"
 371         self.assertTrue(stderr.find(expected) > -1)
 372
 373         ec.shutdown()
 374
 375     def test_real_time(self):
 376         ec = ExperimentController(exp_id = "test-ns3-real-time")
 377
 378         node = ec.register_resource("LinuxNode")
 379         ec.set(node, "hostname", self.fedora_host)
 380         ec.set(node, "username", self.fedora_user)
 381         ec.set(node, "identity", self.fedora_identity)
 382         ec.set(node, "cleanProcesses", True)
 383         #ec.set(node, "cleanHome", True)
 384
 385         simu = ec.register_resource("LinuxNS3Simulation")
 386         ec.set(simu, "simulatorImplementationType", "ns3::RealtimeSimulatorImpl")
 387         ec.set(simu, "checksumEnabled", True)
 388         ec.set(simu, "verbose", True)
 389         ec.register_connection(simu, node)
 390
 391         nsnode1 = add_ns3_node(ec, simu)
 392         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 393
 394         nsnode2 = add_ns3_node(ec, simu)
 395         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 396
 397         # Create channel
 398         chan = ec.register_resource("ns3::PointToPointChannel")
 399         ec.set(chan, "Delay", "0s")
 400         ec.register_connection(chan, dev1)
 401         ec.register_connection(chan, dev2)
 402
 403         ### create pinger
 404         ping = ec.register_resource("ns3::V4Ping")
 405         ec.set (ping, "Remote", "10.0.0.2")
 406         ec.set (ping, "Interval", "1s")
 407         ec.set (ping, "Verbose", True)
 408         ec.set (ping, "StartTime", "0s")
 409         ec.set (ping, "StopTime", "20s")
 410         ec.register_connection(ping, nsnode1)
 411
 412         ec.deploy()
 413
 414         ec.wait_finished([ping])
 415
 416         stdout = ec.trace(simu, "stdout")
 417
 418         expected = "20 packets transmitted, 20 received, 0% packet loss"
 419         self.assertTrue(stdout.find(expected) > -1)
 420
 421         rm = ec.get_resource(ping)
 422         start_time = rm.start_time
 423         stop_time = rm.stop_time
 424         delta = stop_time - start_time
 425
 426         self.assertTrue(delta.seconds >= 20, "Time elapsed %d" % delta.seconds)
 427         self.assertTrue(delta.seconds < 25, "Time elapsed %d" % delta.seconds)
 428
 429         ec.shutdown()
 430
 431     def test_traces(self):
 432         ec = ExperimentController(exp_id = "test-ns3-traces")
 433
 434         node = ec.register_resource("LinuxNode")
 435         ec.set(node, "hostname", self.fedora_host)
 436         ec.set(node, "username", self.fedora_user)
 437         ec.set(node, "identity", self.fedora_identity)
 438         ec.set(node, "cleanProcesses", True)
 439         #ec.set(node, "cleanHome", True)
 440
 441         simu = ec.register_resource("LinuxNS3Simulation")
 442         ec.set(simu, "verbose", True)
 443         ec.register_connection(simu, node)
 444
 445         nsnode1 = add_ns3_node(ec, simu)
 446         dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 447
 448         nsnode2 = add_ns3_node(ec, simu)
 449         dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 450
 451         # Create channel
 452         chan = ec.register_resource("ns3::PointToPointChannel")
 453         ec.set(chan, "Delay", "0s")
 454         ec.register_connection(chan, dev1)
 455         ec.register_connection(chan, dev2)
 456
 457         ### create pinger
 458         ping = ec.register_resource("ns3::V4Ping")
 459         ec.set (ping, "Remote", "10.0.0.2")
 460         ec.set (ping, "Interval", "1s")
 461         ec.set (ping, "Verbose", True)
 462         ec.set (ping, "StartTime", "0s")
 463         ec.set (ping, "StopTime", "20s")
 464         ec.register_connection(ping, nsnode1)
 465
 466         # enable traces
 467         ec.enable_trace(dev1, "pcap")
 468         ec.enable_trace(dev1, "promiscPcap")
 469         ec.enable_trace(dev1, "ascii")
 470
 471         ec.enable_trace(dev2, "pcap")
 472         ec.enable_trace(dev2, "promiscPcap")
 473         ec.enable_trace(dev2, "ascii")
 474
 475         ec.deploy()
 476
 477         ec.wait_finished([ping])
 478
 479         # Trace verification
 480         rm_simu = ec.get_resource(simu)
 481
 482         # TODO: Fix this in ns-3: pcap traces do not flush until the Simulator
 483         #   process is ended, so we can't get the traces of the 'pcap' and
 484         #   'promiscPcap' traces.
 485         #
 486         #for trace in ["pcap", "promiscPcap", "ascii"]:
 487         for trace in ["ascii"]:
 488             for guid in [dev1, dev2]:
 489                 output = ec.trace(guid, trace)
 490
 491                 size = ec.trace(guid, trace, attr = TraceAttr.SIZE)
 492                 self.assertEquals(size, len(output))
 493                 self.assertTrue(size > 100)
 494
 495                 block = ec.trace(guid, trace, attr = TraceAttr.STREAM, block = 5, offset = 1)
 496                 self.assertEquals(block, output[5:10])
 497
 498                 trace_path = ec.trace(guid, trace, attr = TraceAttr.PATH)
 499                 rm = ec.get_resource(guid)
 500                 path = os.path.join(rm_simu.run_home, rm._trace_filename.get(trace))
 501                 self.assertEquals(trace_path, path)
 502
 503         ec.shutdown()
 504
 505     def test_simple_wifi_ping(self):
 506         bounds_width = bounds_height = 200
 507         x = y = 100
 508         speed = 1
 509
 510         ec = ExperimentController(exp_id = "test-ns3-wifi-ping")
 511
 512         node = ec.register_resource("LinuxNode")
 513         ec.set(node, "hostname", self.fedora_host)
 514         ec.set(node, "username", self.fedora_user)
 515         ec.set(node, "identity", self.fedora_identity)
 516         ec.set(node, "cleanProcesses", True)
 517         #ec.set(node, "cleanHome", True)
 518
 519         simu = ec.register_resource("LinuxNS3Simulation")
 520         ec.set(simu, "verbose", True)
 521         ec.register_connection(simu, node)
 522
 523         nsnode1 = add_ns3_node(ec, simu)
 524         dev1, phy1 = add_wifi_device(ec, nsnode1, "10.0.0.1", "24", access_point = True)
 525         mobility1 = add_constant_mobility(ec, nsnode1, x, y, 0)
 526
 527         nsnode2 = add_ns3_node(ec, simu)
 528         dev2, phy2 = add_wifi_device(ec, nsnode2, "10.0.0.2", "24", access_point = False)
 529         mobility1 = add_constant_mobility(ec, nsnode2, x, y, 0)
 530         #mobility2 = add_random_mobility(ec, nsnode2, x, y, 0, speed, bounds_width, bounds_height)
 531
 532         # Create channel
 533         chan = add_wifi_channel(ec)
 534         ec.register_connection(chan, phy1)
 535         ec.register_connection(chan, phy2)
 536
 537         ### create pinger
 538         ping = ec.register_resource("ns3::V4Ping")
 539         ec.set (ping, "Remote", "10.0.0.1")
 540         ec.set (ping, "Interval", "1s")
 541         ec.set (ping, "Verbose", True)
 542         ec.set (ping, "StartTime", "1s")
 543         ec.set (ping, "StopTime", "21s")
 544         ec.register_connection(ping, nsnode2)
 545
 546         ec.deploy()
 547
 548         ec.wait_finished([ping])
 549
 550         stdout = ec.trace(simu, "stdout")
 551
 552         expected = "20 packets transmitted, 20 received, 0% packet loss"
 553         self.assertTrue(stdout.find(expected) > -1)
 554
 555         ec.shutdown()
 556
 557     def test_routing(self):
 558         """
 559         network topology:
 560                                 n4
 561                                 |
 562            n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
 563            |                    |
 564            ping n6              n3
 565
 566
 567         """
 568         ec = ExperimentController(exp_id = "test-ns3-routes")
 569
 570         node = ec.register_resource("LinuxNode")
 571         ec.set(node, "hostname", self.fedora_host)
 572         ec.set(node, "username", self.fedora_user)
 573         ec.set(node, "identity", self.fedora_identity)
 574         ec.set(node, "cleanProcesses", True)
 575         #ec.set(node, "cleanHome", True)
 576
 577         simu = ec.register_resource("LinuxNS3Simulation")
 578         ec.set(simu, "verbose", True)
 579         ec.register_connection(simu, node)
 580
 581         nsnode1 = add_ns3_node(ec, simu)
 582         p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 583
 584         nsnode2 = add_ns3_node(ec, simu)
 585         p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 586         csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
 587
 588         nsnode3 = add_ns3_node(ec, simu)
 589         csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
 590
 591         nsnode4 = add_ns3_node(ec, simu)
 592         csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
 593
 594         nsnode5 = add_ns3_node(ec, simu)
 595         p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
 596         csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
 597
 598         nsnode6 = add_ns3_node(ec, simu)
 599         p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
 600
 601         # P2P chan1
 602         p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
 603         ec.set(p2p_chan1, "Delay", "0s")
 604         ec.register_connection(p2p_chan1, p2p12)
 605         ec.register_connection(p2p_chan1, p2p21)
 606
 607         # CSMA chan
 608         csma_chan = ec.register_resource("ns3::CsmaChannel")
 609         ec.set(csma_chan, "Delay", "0s")
 610         ec.register_connection(csma_chan, csma2)
 611         ec.register_connection(csma_chan, csma3)
 612         ec.register_connection(csma_chan, csma4)
 613         ec.register_connection(csma_chan, csma5)
 614
 615         # P2P chan2
 616         p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
 617         ec.set(p2p_chan2, "Delay", "0s")
 618         ec.register_connection(p2p_chan2, p2p56)
 619         ec.register_connection(p2p_chan2, p2p65)
 620
 621         # Add routes - n1 - n6
 622         r1 = ec.register_resource("ns3::Route")
 623         ec.set(r1, "network", "10.0.2.0")
 624         ec.set(r1, "prefix", "30")
 625         ec.set(r1, "nexthop", "10.0.0.2")
 626         ec.register_connection(r1, nsnode1)
 627
 628         # Add routes - n2 - n6
 629         r2 = ec.register_resource("ns3::Route")
 630         ec.set(r2, "network", "10.0.2.0")
 631         ec.set(r2, "prefix", "30")
 632         ec.set(r2, "nexthop", "10.0.1.4")
 633         ec.register_connection(r2, nsnode2)
 634
 635         # Add routes - n5 - n1
 636         r5 = ec.register_resource("ns3::Route")
 637         ec.set(r5, "network", "10.0.0.0")
 638         ec.set(r5, "prefix", "30")
 639         ec.set(r5, "nexthop", "10.0.1.1")
 640         ec.register_connection(r5, nsnode5)
 641
 642         # Add routes - n6 - n1
 643         r6 = ec.register_resource("ns3::Route")
 644         ec.set(r6, "network", "10.0.0.0")
 645         ec.set(r6, "prefix", "30")
 646         ec.set(r6, "nexthop", "10.0.2.1")
 647         ec.register_connection(r6, nsnode6)
 648
 649         ### create pinger
 650         ping = ec.register_resource("ns3::V4Ping")
 651         ec.set (ping, "Remote", "10.0.2.2")
 652         ec.set (ping, "Interval", "1s")
 653         ec.set (ping, "Verbose", True)
 654         ec.set (ping, "StartTime", "1s")
 655         ec.set (ping, "StopTime", "21s")
 656         ec.register_connection(ping, nsnode1)
 657
 658         ec.deploy()
 659
 660         ec.wait_finished([ping])
 661
 662         stdout = ec.trace(simu, "stdout")
 663
 664         expected = "20 packets transmitted, 20 received, 0% packet loss"
 665         self.assertTrue(stdout.find(expected) > -1)
 666
 667         ec.shutdown()
 668
 669     def ztest_automatic_routing(self):
 670         """
 671         network topology:
 672                                 n4
 673                                 |
 674            n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
 675            |                    |
 676            ping n6              n3
 677
 678
 679         """
 680         ec = ExperimentController(exp_id = "test-ns3-routing")
 681
 682         node = ec.register_resource("LinuxNode")
 683         ec.set(node, "hostname", self.fedora_host)
 684         ec.set(node, "username", self.fedora_user)
 685         ec.set(node, "identity", self.fedora_identity)
 686         ec.set(node, "cleanProcesses", True)
 687         #ec.set(node, "cleanHome", True)
 688
 689         simu = ec.register_resource("LinuxNS3Simulation")
 690         ec.set(simu, "verbose", True)
 691         ec.set(simu, "populateRoutingTables", True)
 692         ec.register_connection(simu, node)
 693
 694         nsnode1 = add_ns3_node(ec, simu)
 695         p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 696
 697         nsnode2 = add_ns3_node(ec, simu)
 698         p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 699         csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
 700
 701         nsnode3 = add_ns3_node(ec, simu)
 702         csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
 703
 704         nsnode4 = add_ns3_node(ec, simu)
 705         csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
 706
 707         nsnode5 = add_ns3_node(ec, simu)
 708         p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
 709         csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
 710
 711         nsnode6 = add_ns3_node(ec, simu)
 712         p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
 713
 714         # P2P chan1
 715         p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
 716         ec.set(p2p_chan1, "Delay", "0s")
 717         ec.register_connection(p2p_chan1, p2p12)
 718         ec.register_connection(p2p_chan1, p2p21)
 719
 720         # CSMA chan
 721         csma_chan = ec.register_resource("ns3::CsmaChannel")
 722         ec.set(csma_chan, "Delay", "0s")
 723         ec.register_connection(csma_chan, csma2)
 724         ec.register_connection(csma_chan, csma3)
 725         ec.register_connection(csma_chan, csma4)
 726         ec.register_connection(csma_chan, csma5)
 727
 728         # P2P chan2
 729         p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
 730         ec.set(p2p_chan2, "Delay", "0s")
 731         ec.register_connection(p2p_chan2, p2p56)
 732         ec.register_connection(p2p_chan2, p2p65)
 733
 734         ### create pinger
 735         ping = ec.register_resource("ns3::V4Ping")
 736         ec.set (ping, "Remote", "10.0.1.2")
 737         ec.set (ping, "Interval", "1s")
 738         ec.set (ping, "Verbose", True)
 739         ec.set (ping, "StartTime", "1s")
 740         ec.set (ping, "StopTime", "21s")
 741         ec.register_connection(ping, nsnode1)
 742
 743         ec.deploy()
 744
 745         ec.wait_finished([ping])
 746
 747         stdout = ec.trace(simu, "stdout")
 748
 749         print stdout
 750
 751         expected = "20 packets transmitted, 20 received, 0% packet loss"
 752         self.assertTrue(stdout.find(expected) > -1)
 753
 754         ec.shutdown()
 755
 756     def test_dce(self):
 757         ec = ExperimentController(exp_id = "test-ns3-dce")
 758
 759         node = ec.register_resource("LinuxNode")
 760         ec.set(node, "hostname", self.fedora_host)
 761         ec.set(node, "username", self.fedora_user)
 762         ec.set(node, "identity", self.fedora_identity)
 763         ec.set(node, "cleanProcesses", True)
 764         #ec.set(node, "cleanHome", True)
 765
 766         simu = ec.register_resource("LinuxNS3Simulation")
 767         ec.set(simu, "verbose", True)
 768         ec.set(simu, "enableDCE", True)
 769         ec.set(simu, "buildMode", "debug")
 770         ec.set(simu, "nsLog", "DceApplication")
 771         ec.register_connection(simu, node)
 772
 773         nsnode1 = add_ns3_node(ec, simu)
 774         ec.set(nsnode1, "enableDCE", True)
 775         p2p1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 776         ec.set(p2p1, "DataRate", "5Mbps")
 777
 778         nsnode2 = add_ns3_node(ec, simu)
 779         ec.set(nsnode2, "enableDCE", True)
 780         p2p2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 781         ec.set(p2p2, "DataRate", "5Mbps")
 782
 783         # Create channel
 784         chan = ec.register_resource("ns3::PointToPointChannel")
 785         ec.set(chan, "Delay", "2ms")
 786
 787         ec.register_connection(chan, p2p1)
 788         ec.register_connection(chan, p2p2)
 789
 790         ### create applications
 791         udp_perf = ec.register_resource("ns3::DceApplication")
 792         ec.set (udp_perf, "binary", "udp-perf")
 793         ec.set (udp_perf, "stackSize", 1<<20)
 794         ec.set (udp_perf, "arguments", "--duration=10;--nodes=2")
 795         ec.set (udp_perf, "StartTime", "1s")
 796         ec.set (udp_perf, "StopTime", "20s")
 797         ec.register_connection(udp_perf, nsnode1)
 798
 799         udp_perf_client = ec.register_resource("ns3::DceApplication")
 800         ec.set (udp_perf_client, "binary", "udp-perf")
 801         ec.set (udp_perf_client, "stackSize", 1<<20)
 802         ec.set (udp_perf_client, "arguments", "--client;--nodes=2;--host=10.0.0.1;--duration=10")
 803         ec.set (udp_perf_client, "StartTime", "2s")
 804         ec.set (udp_perf_client, "StopTime", "20s")
 805         ec.register_connection(udp_perf_client, nsnode2)
 806
 807         ec.deploy()
 808
 809         ec.wait_finished([udp_perf_client])
 810
 811         expected = "udp-perf --duration=10 --nodes=2"
 812         cmdline = ec.trace(udp_perf, "cmdline")
 813         self.assertTrue(cmdline.find(expected) > -1, cmdline)
 814
 815         expected = "Start Time: NS3 Time:          1s ("
 816         status = ec.trace(udp_perf, "status")
 817         self.assertTrue(status.find(expected) > -1, status)
 818
 819         expected = "received=1500 bytes, 1 reads (@1500 bytes) 1500"
 820         stdout = ec.trace(udp_perf, "stdout")
 821         self.assertTrue(stdout.find(expected) > -1, stdout)
 822
 823         stderr = ec.trace(simu, "stderr")
 824         expected = "DceApplication:StartApplication"
 825         self.assertTrue(stderr.find(expected) > -1, stderr)
 826
 827         ec.shutdown()
 828
 829
 830 if __name__ == '__main__':
 831     unittest.main()
 832