test/resources/linux/ns3/ns3simulation.py

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