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