test/resources/linux/ns3/ns3simulation.py

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