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