test/resources/linux/ns3/ns3simulation.py

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