test/resources/linux/ns3/serialization.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 shutil
  29 import time
  30 import tempfile
  31 import unittest
  32
  33 def add_ns3_node(ec, simu):
  34     node = ec.register_resource("ns3::Node")
  35     ec.register_connection(node, simu)
  36
  37     ipv4 = ec.register_resource("ns3::Ipv4L3Protocol")
  38     ec.register_connection(node, ipv4)
  39
  40     arp = ec.register_resource("ns3::ArpL3Protocol")
  41     ec.register_connection(node, arp)
  42
  43     icmp = ec.register_resource("ns3::Icmpv4L4Protocol")
  44     ec.register_connection(node, icmp)
  45
  46     udp = ec.register_resource("ns3::UdpL4Protocol")
  47     ec.register_connection(node, udp)
  48
  49     return node
  50
  51 def add_point2point_device(ec, node, ip, prefix):
  52     dev = ec.register_resource("ns3::PointToPointNetDevice")
  53     ec.set(dev, "ip", ip)
  54     ec.set(dev, "prefix", prefix)
  55     ec.register_connection(node, dev)
  56
  57     queue = ec.register_resource("ns3::DropTailQueue")
  58     ec.register_connection(dev, queue)
  59
  60     return dev
  61
  62 def add_csma_device(ec, node, ip, prefix):
  63     dev = ec.register_resource("ns3::CsmaNetDevice")
  64     ec.set(dev, "ip", ip)
  65     ec.set(dev, "prefix", prefix)
  66     ec.register_connection(node, dev)
  67
  68     queue = ec.register_resource("ns3::DropTailQueue")
  69     ec.register_connection(dev, queue)
  70
  71     return dev
  72
  73 def add_wifi_device(ec, node, ip, prefix,
  74         access_point = False):
  75     dev = ec.register_resource("ns3::WifiNetDevice")
  76     ec.set(dev, "ip", ip)
  77     ec.set(dev, "prefix", prefix)
  78     ec.register_connection(node, dev)
  79
  80     phy = ec.register_resource("ns3::YansWifiPhy")
  81     ec.set(phy, "Standard", "WIFI_PHY_STANDARD_80211a")
  82     ec.register_connection(dev, phy)
  83
  84     error = ec.register_resource("ns3::NistErrorRateModel")
  85     ec.register_connection(phy, error)
  86
  87     manager = ec.register_resource("ns3::ArfWifiManager")
  88     ec.register_connection(dev, manager)
  89
  90     if access_point:
  91         mac = ec.register_resource("ns3::ApWifiMac")
  92     else:
  93         mac = ec.register_resource("ns3::StaWifiMac")
  94
  95     ec.set(mac, "Standard", "WIFI_PHY_STANDARD_80211a")
  96     ec.register_connection(dev, mac)
  97
  98     return dev, phy
  99
 100 def add_random_mobility(ec, node, x, y, z, speed, bounds_width,
 101         bounds_height):
 102     position = "%d:%d:%d" % (x, y, z)
 103     bounds = "0|%d|0|%d" % (bounds_width, bounds_height)
 104     speed = "ns3::UniformRandomVariable[Min=%d|Max=%s]" % (speed, speed)
 105     pause = "ns3::ConstantRandomVariable[Constant=1.0]"
 106
 107     mobility = ec.register_resource("ns3::RandomDirection2dMobilityModel")
 108     ec.set(mobility, "Position", position)
 109     ec.set(mobility, "Bounds", bounds)
 110     ec.set(mobility, "Speed", speed)
 111     ec.set(mobility, "Pause",  pause)
 112     ec.register_connection(node, mobility)
 113     return mobility
 114
 115 def add_constant_mobility(ec, node, x, y, z):
 116     mobility = ec.register_resource("ns3::ConstantPositionMobilityModel")
 117     position = "%d:%d:%d" % (x, y, z)
 118     ec.set(mobility, "Position", position)
 119     ec.register_connection(node, mobility)
 120     return mobility
 121
 122 def add_wifi_channel(ec):
 123     channel = ec.register_resource("ns3::YansWifiChannel")
 124     delay = ec.register_resource("ns3::ConstantSpeedPropagationDelayModel")
 125     ec.register_connection(channel, delay)
 126
 127     loss  = ec.register_resource("ns3::LogDistancePropagationLossModel")
 128     ec.register_connection(channel, loss)
 129
 130     return channel
 131
 132 class LinuxNS3SimulationSerializationTest(unittest.TestCase):
 133     def setUp(self):
 134         #self.fedora_host = "nepi2.pl.sophia.inria.fr"
 135         self.fedora_host = "planetlab1.informatik.uni-erlangen.de"
 136         self.fedora_user = "inria_nepi"
 137         self.fedora_identity = "%s/.ssh/id_rsa_planetlab" % (os.environ['HOME'])
 138
 139     @skipIfNotAlive
 140     def t_wifi_serialize(self, host, user = None, identity = None):
 141         bounds_width = bounds_height = 200
 142         x = y = 100
 143         speed = 1
 144
 145         dirpath = tempfile.mkdtemp()
 146
 147         ec = ExperimentController(exp_id = "test-ns3-wifi-ping")
 148
 149         node = ec.register_resource("linux::Node")
 150         if host == "localhost":
 151             ec.set(node, "hostname", "localhost")
 152         else:
 153             ec.set(node, "hostname", host)
 154             ec.set(node, "username", user)
 155             ec.set(node, "identity", identity)
 156
 157         ec.set(node, "cleanProcesses", True)
 158         #ec.set(node, "cleanHome", True)
 159
 160         simu = ec.register_resource("linux::ns3::Simulation")
 161         ec.set(simu, "verbose", True)
 162         ec.register_connection(simu, node)
 163
 164         nsnode1 = add_ns3_node(ec, simu)
 165         dev1, phy1 = add_wifi_device(ec, nsnode1, "10.0.0.1", "24", access_point = True)
 166         mobility1 = add_constant_mobility(ec, nsnode1, x, y, 0)
 167
 168         nsnode2 = add_ns3_node(ec, simu)
 169         dev2, phy2 = add_wifi_device(ec, nsnode2, "10.0.0.2", "24", access_point = False)
 170         mobility1 = add_constant_mobility(ec, nsnode2, x, y, 0)
 171         #mobility2 = add_random_mobility(ec, nsnode2, x, y, 0, speed, bounds_width, bounds_height)
 172
 173         # Create channel
 174         chan = add_wifi_channel(ec)
 175         ec.register_connection(chan, phy1)
 176         ec.register_connection(chan, phy2)
 177
 178         ### create pinger
 179         ping = ec.register_resource("ns3::V4Ping")
 180         ec.set (ping, "Remote", "10.0.0.1")
 181         ec.set (ping, "Interval", "1s")
 182         ec.set (ping, "Verbose", True)
 183         ec.set (ping, "StartTime", "1s")
 184         ec.set (ping, "StopTime", "21s")
 185         ec.register_connection(ping, nsnode2)
 186
 187         filepath = ec.save(dirpath)
 188         print(filepath)
 189
 190         ec.deploy()
 191
 192         ec.wait_finished([ping])
 193
 194         stdout = ec.trace(simu, "stdout")
 195
 196         expected = "20 packets transmitted, 20 received, 0% packet loss"
 197         self.assertTrue(stdout.find(expected) > -1)
 198
 199         ec.shutdown()
 200
 201         # Load serialized experiment
 202         ec2 = ExperimentController.load(filepath)
 203
 204         ec2.deploy()
 205
 206         ec2.wait_finished([ping])
 207
 208         self.assertEquals(len(ec.resources), len(ec2.resources))
 209
 210         stdout = ec2.trace(simu, "stdout")
 211
 212         expected = "20 packets transmitted, 20 received, 0% packet loss"
 213         self.assertTrue(stdout.find(expected) > -1)
 214
 215         ec2.shutdown()
 216
 217         shutil.rmtree(dirpath)
 218
 219     @skipIfNotAlive
 220     def t_routing_serialize(self, host, user = None, identity = None):
 221         """
 222         network topology:
 223                                 n4
 224                                 |
 225            n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
 226            |                    |
 227            ping n6              n3
 228
 229
 230         """
 231         dirpath = tempfile.mkdtemp()
 232
 233         ec = ExperimentController(exp_id = "test-ns3-routes")
 234
 235         node = ec.register_resource("linux::Node")
 236         if host == "localhost":
 237             ec.set(node, "hostname", host)
 238         else:
 239             ec.set(node, "hostname", host)
 240             ec.set(node, "username", user)
 241             ec.set(node, "identity", identity)
 242
 243         ec.set(node, "cleanProcesses", True)
 244         #ec.set(node, "cleanHome", True)
 245
 246         simu = ec.register_resource("linux::ns3::Simulation")
 247         ec.set(simu, "verbose", True)
 248         ec.register_connection(simu, node)
 249
 250         nsnode1 = add_ns3_node(ec, simu)
 251         p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 252
 253         nsnode2 = add_ns3_node(ec, simu)
 254         p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 255         csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
 256
 257         nsnode3 = add_ns3_node(ec, simu)
 258         csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
 259
 260         nsnode4 = add_ns3_node(ec, simu)
 261         csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
 262
 263         nsnode5 = add_ns3_node(ec, simu)
 264         p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
 265         csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
 266
 267         nsnode6 = add_ns3_node(ec, simu)
 268         p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
 269
 270         # P2P chan1
 271         p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
 272         ec.set(p2p_chan1, "Delay", "0s")
 273         ec.register_connection(p2p_chan1, p2p12)
 274         ec.register_connection(p2p_chan1, p2p21)
 275
 276         # CSMA chan
 277         csma_chan = ec.register_resource("ns3::CsmaChannel")
 278         ec.set(csma_chan, "Delay", "0s")
 279         ec.register_connection(csma_chan, csma2)
 280         ec.register_connection(csma_chan, csma3)
 281         ec.register_connection(csma_chan, csma4)
 282         ec.register_connection(csma_chan, csma5)
 283
 284         # P2P chan2
 285         p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
 286         ec.set(p2p_chan2, "Delay", "0s")
 287         ec.register_connection(p2p_chan2, p2p56)
 288         ec.register_connection(p2p_chan2, p2p65)
 289
 290         # Add routes - n1 - n6
 291         r1 = ec.register_resource("ns3::Route")
 292         ec.set(r1, "network", "10.0.2.0")
 293         ec.set(r1, "prefix", "30")
 294         ec.set(r1, "nexthop", "10.0.0.2")
 295         ec.register_connection(r1, nsnode1)
 296
 297         # Add routes - n2 - n6
 298         r2 = ec.register_resource("ns3::Route")
 299         ec.set(r2, "network", "10.0.2.0")
 300         ec.set(r2, "prefix", "30")
 301         ec.set(r2, "nexthop", "10.0.1.4")
 302         ec.register_connection(r2, nsnode2)
 303
 304         # Add routes - n5 - n1
 305         r5 = ec.register_resource("ns3::Route")
 306         ec.set(r5, "network", "10.0.0.0")
 307         ec.set(r5, "prefix", "30")
 308         ec.set(r5, "nexthop", "10.0.1.1")
 309         ec.register_connection(r5, nsnode5)
 310
 311         # Add routes - n6 - n1
 312         r6 = ec.register_resource("ns3::Route")
 313         ec.set(r6, "network", "10.0.0.0")
 314         ec.set(r6, "prefix", "30")
 315         ec.set(r6, "nexthop", "10.0.2.1")
 316         ec.register_connection(r6, nsnode6)
 317
 318         ### create pinger
 319         ping = ec.register_resource("ns3::V4Ping")
 320         ec.set (ping, "Remote", "10.0.2.2")
 321         ec.set (ping, "Interval", "1s")
 322         ec.set (ping, "Verbose", True)
 323         ec.set (ping, "StartTime", "1s")
 324         ec.set (ping, "StopTime", "21s")
 325         ec.register_connection(ping, nsnode1)
 326
 327         filepath = ec.save(dirpath)
 328         print(filepath)
 329
 330         ec.deploy()
 331
 332         ec.wait_finished([ping])
 333
 334         stdout = ec.trace(simu, "stdout")
 335
 336         expected = "20 packets transmitted, 20 received, 0% packet loss"
 337         self.assertTrue(stdout.find(expected) > -1)
 338
 339         ec.shutdown()
 340
 341         # Load serialized experiment
 342         ec2 = ExperimentController.load(filepath)
 343
 344         ec2.deploy()
 345
 346         ec2.wait_finished([ping])
 347
 348         self.assertEquals(len(ec.resources), len(ec2.resources))
 349
 350         stdout = ec2.trace(simu, "stdout")
 351
 352         expected = "20 packets transmitted, 20 received, 0% packet loss"
 353         self.assertTrue(stdout.find(expected) > -1)
 354
 355         ec2.shutdown()
 356
 357         shutil.rmtree(dirpath)
 358
 359     @skipIfNotAlive
 360     def t_dce_serialize(self, host, user = None, identity = None):
 361         dirpath = tempfile.mkdtemp()
 362
 363         ec = ExperimentController(exp_id = "test-ns3-dce")
 364
 365         node = ec.register_resource("linux::Node")
 366         if host == "localhost":
 367             ec.set(node, "hostname", host)
 368         else:
 369             ec.set(node, "hostname", host)
 370             ec.set(node, "username", user)
 371             ec.set(node, "identity", identity)
 372
 373         ec.set(node, "cleanProcesses", True)
 374         #ec.set(node, "cleanHome", True)
 375
 376         simu = ec.register_resource("linux::ns3::Simulation")
 377         ec.set(simu, "verbose", True)
 378         ec.register_connection(simu, node)
 379
 380         nsnode1 = add_ns3_node(ec, simu)
 381         p2p1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
 382         ec.set(p2p1, "DataRate", "5Mbps")
 383
 384         nsnode2 = add_ns3_node(ec, simu)
 385         p2p2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
 386         ec.set(p2p2, "DataRate", "5Mbps")
 387
 388         # Create channel
 389         chan = ec.register_resource("ns3::PointToPointChannel")
 390         ec.set(chan, "Delay", "2ms")
 391
 392         ec.register_connection(chan, p2p1)
 393         ec.register_connection(chan, p2p2)
 394
 395         ### create applications
 396         udp_perf = ec.register_resource("linux::ns3::dce::Application")
 397         ec.set (udp_perf, "binary", "udp-perf")
 398         ec.set (udp_perf, "stackSize", 1<<20)
 399         ec.set (udp_perf, "arguments", "--duration=10;--nodes=2")
 400         ec.set (udp_perf, "StartTime", "1s")
 401         ec.set (udp_perf, "StopTime", "20s")
 402         ec.register_connection(udp_perf, nsnode1)
 403
 404         udp_perf_client = ec.register_resource("linux::ns3::dce::Application")
 405         ec.set (udp_perf_client, "binary", "udp-perf")
 406         ec.set (udp_perf_client, "stackSize", 1<<20)
 407         ec.set (udp_perf_client, "arguments", "--client;--nodes=2;--host=10.0.0.1;--duration=10")
 408         ec.set (udp_perf_client, "StartTime", "2s")
 409         ec.set (udp_perf_client, "StopTime", "20s")
 410         ec.register_connection(udp_perf_client, nsnode2)
 411
 412         filepath = ec.save(dirpath)
 413
 414         ec.deploy()
 415
 416         ec.wait_finished([udp_perf_client])
 417
 418         # Give time to flush the streams
 419         import time
 420         time.sleep(5)
 421
 422         expected = "udp-perf --duration=10 --nodes=2"
 423         cmdline = ec.trace(udp_perf, "cmdline")
 424         self.assertTrue(cmdline.find(expected) > -1, cmdline)
 425
 426         expected = "Start Time: NS3 Time:          1s ("
 427         status = ec.trace(udp_perf, "status")
 428         self.assertTrue(status.find(expected) > -1, status)
 429
 430         expected = "received=1500 bytes, 1 reads (@1500 bytes) 1500"
 431         stdout = ec.trace(udp_perf, "stdout")
 432         self.assertTrue(stdout.find(expected) > -1, stdout)
 433
 434         ec.shutdown()
 435
 436         # Load serialized experiment
 437         ec2 = ExperimentController.load(filepath)
 438
 439         ec2.deploy()
 440         ec2.wait_finished([udp_perf_client])
 441
 442         # Give time to flush the streams
 443         time.sleep(5)
 444
 445         self.assertEquals(len(ec.resources), len(ec2.resources))
 446
 447         expected = "udp-perf --duration=10 --nodes=2"
 448         cmdline = ec2.trace(udp_perf, "cmdline")
 449         self.assertTrue(cmdline.find(expected) > -1, cmdline)
 450
 451         expected = "Start Time: NS3 Time:          1s ("
 452         status = ec2.trace(udp_perf, "status")
 453         self.assertTrue(status.find(expected) > -1, status)
 454
 455         expected = "received=1500 bytes, 1 reads (@1500 bytes) 1500"
 456         stdout = ec2.trace(udp_perf, "stdout")
 457         self.assertTrue(stdout.find(expected) > -1, stdout)
 458
 459         ec2.shutdown()
 460
 461         shutil.rmtree(dirpath)
 462
 463     def test_wifi_serialize_fedora(self):
 464         self.t_wifi_serialize(self.fedora_host, self.fedora_user, self.fedora_identity)
 465
 466     def test_wifi_serialize_local(self):
 467         self.t_wifi_serialize("localhost")
 468
 469     def test_routing_serialize_fedora(self):
 470         self.t_routing_serialize(self.fedora_host, self.fedora_user, self.fedora_identity)
 471
 472     def test_routing_serialize_local(self):
 473         self.t_routing_serialize("localhost")
 474
 475     def test_dce_serialize_fedora(self):
 476         self.t_dce_serialize(self.fedora_host, self.fedora_user, self.fedora_identity)
 477
 478     def test_dce_serialize_local(self):
 479         self.t_dce_serialize("localhost")
 480
 481
 482 if __name__ == '__main__':
 483     unittest.main()
 484