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