src/nepi/testbeds/ns3/metadata_v3_9_RC3.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from constants import TESTBED_ID
   5 from nepi.core import metadata
   6 from nepi.core.attributes import Attribute
   7 from nepi.util import validation
   8 import os.path
   9 import functools
  10
  11 from nepi.util.tunchannel_impl import \
  12     crossconnect_tunchannel_peer_init, \
  13     crossconnect_tunchannel_peer_compl
  14
  15
  16 ### Connection functions ####
  17
  18 def connect_node_device(testbed_instance, node_guid, device_guid):
  19     node = testbed_instance._elements[node_guid]
  20     device = testbed_instance._elements[device_guid]
  21     node.AddDevice(device)
  22
  23 def connect_queue_device(testbed_instance, queue_guid, device_guid):
  24     queue = testbed_instance._elements[queue_guid]
  25     device = testbed_instance._elements[device_guid]
  26     device.SetQueue(queue)
  27
  28 def connect_manager_device(testbed_instance, manager_guid, device_guid):
  29     manager = testbed_instance._elements[manager_guid]
  30     device = testbed_instance._elements[device_guid]
  31     device.SetRemoteStationManager(manager)
  32
  33 def connect_phy_device(testbed_instance, phy_guid, device_guid):
  34     phy = testbed_instance._elements[phy_guid]
  35     device = testbed_instance._elements[device_guid]
  36     device.SetPhy(phy)
  37     phy.SetDevice(device)
  38     # search for the node asociated with the device
  39     node_guid = testbed_instance.get_connected(device_guid, "node", "devs")
  40     if len(node_guid) == 0:
  41         raise RuntimeError("Can't instantiate interface %d outside netns \
  42                 node" % device_guid)
  43     node = testbed_instance.elements[node_guid[0]]
  44     phy.SetMobility(node)
  45
  46 def connect_mac_device(testbed_instance, mac_guid, device_guid):
  47     mac = testbed_instance._elements[mac_guid]
  48     device = testbed_instance._elements[device_guid]
  49     device.SetMac(mac)
  50
  51 def connect_errormodel_device(testbed_instance, model_guid, device_guid):
  52     model = testbed_instance._elements[model_guid]
  53     device = testbed_instance._elements[device_guid]
  54     device.SetReceiveErrorModel(model)
  55
  56 def connect_errormodel_phy(testbed_instance, err_guid, phy_guid):
  57     err = testbed_instance._elements[err_guid]
  58     phy = testbed_instance._elements[phy_guid]
  59     phy.SetErrorRateModel(err)
  60
  61 def connect_channel_device(testbed_instance, channel_guid, device_guid):
  62     channel = testbed_instance._elements[channel_guid]
  63     device = testbed_instance._elements[device_guid]
  64     device.Attach(channel)
  65
  66 def connect_simple_channel_device(testbed_instance, channel_guid, device_guid):
  67     channel = testbed_instance._elements[channel_guid]
  68     device = testbed_instance._elements[device_guid]
  69     device.SetChannel(channel)
  70
  71 def connect_loss_channel(testbed_instance, loss_guid, channel_guid):
  72     loss = testbed_instance._elements[loss_guid]
  73     channel = testbed_instance._elements[channel_guid]
  74     channel.SetPropagationLossModel(loss)
  75
  76 def connect_next_loss(testbed_instance, prev_guid, next_guid):
  77     prev = testbed_instance._elements[prev_guid]
  78     next = testbed_instance._elements[next_guid]
  79     prev.SetNext(next)
  80
  81 def connect_delay_channel(testbed_instance, delay_guid, channel_guid):
  82     delay = testbed_instance._elements[delay_guid]
  83     channel = testbed_instance._elements[channel_guid]
  84     channel.SetPropagationDelayModel(delay)
  85
  86 def connect_node_application(testbed_instance, node_guid, application_guid):
  87     node = testbed_instance._elements[node_guid]
  88     application = testbed_instance._elements[application_guid]
  89     node.AddApplication(application)
  90 # works for ArpL3Protocol, Ipv4L3Protocol, UdpL4Protocol, TcpL4Protocol,
  91 # NscTcpL4Protocol, MobilityModel (every subclass),
  92 # RoutingProtocol (every subclass)
  93
  94 def connect_node_other(testbed_instance, node_guid, other_guid):
  95     node = testbed_instance._elements[node_guid]
  96     other = testbed_instance._elements[other_guid]
  97     node.AggregateObject(other)
  98
  99 def connect_fd(testbed_instance, fdnd_guid, cross_data):
 100     fdnd = testbed_instance._elements[fdnd_guid]
 101     endpoint = fdnd.GetEndpoint()
 102     # XXX: check the method StringToBuffer of ns3::FileDescriptorNetDevice
 103     # to see how the address should be decoded
 104     address = endpoint.replace(":", "").decode('hex')[2:]
 105     testbed_instance.set(fdnd_guid, "LinuxSocketAddress", address)
 106
 107     # If it's a non-abstract socket, add the path
 108     if not address.startswith('\x00'):
 109         address = os.path.join( testbed_instance.root_directory, address )
 110
 111     # Set tun standard contract attributes
 112     testbed_instance.set(fdnd_guid, "tun_addr", address )
 113     testbed_instance.set(fdnd_guid, "tun_proto", "fd")
 114     testbed_instance.set(fdnd_guid, "tun_port", 0)
 115     testbed_instance.set(fdnd_guid, "tun_key", "\xfa"*32) # unimportant, fds aren't encrypted
 116
 117 def connect_tunchannel_fd(testbed_instance, tun_guid, fdnd_guid):
 118     fdnd = testbed_instance._elements[fdnd_guid]
 119     tun = testbed_instance._elements[tun_guid]
 120
 121     # XXX: check the method StringToBuffer of ns3::FileDescriptorNetDevice
 122     # to see how the address should be decoded
 123     endpoint = fdnd.GetEndpoint()
 124     address = endpoint.replace(":", "").decode('hex')[2:]
 125     testbed_instance.set(fdnd_guid, "LinuxSocketAddress", address)
 126
 127     # Create socket pair to connect the FDND and the TunChannel with it
 128     import socket
 129     sock1, sock2 = socket.socketpair(
 130         socket.AF_UNIX, socket.SOCK_SEQPACKET)
 131
 132     # Send one endpoint to the FDND
 133     import passfd
 134     import socket
 135     sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
 136     sock.connect(address)
 137     passfd.sendfd(sock, sock1.fileno(), '0')
 138
 139     # Store a reference to the endpoint to keep the socket alive
 140     fdnd._endpoint_socket = sock1
 141
 142     # Send the other endpoint to the TUN channel
 143     tun.tun_socket = sock2
 144
 145     # With this kind of tun_socket, NS3 will expect a PI header
 146     # (sockets don't support the TUNGETIFF ioctl, so it will assume
 147     # the default presence of PI headers)
 148     tun.with_pi = True
 149
 150
 151 ### Connector information ###
 152
 153 connector_types = dict({
 154     "node": dict({
 155                 "help": "Connector to a ns3::Node object (mandatory)",
 156                 "name": "node",
 157                 "max": 1,
 158                 "min": 1
 159             }),
 160     "devs": dict({
 161                 "help": "Connector to network interfaces",
 162                 "name": "devs",
 163                 "max": -1,
 164                 "min": 0
 165             }),
 166     "dev2": dict({
 167                 "help": "Connector to exactly two network interfaces (mandatory)",
 168                 "name": "dev2",
 169                 "max": 2,
 170                 "min": 2
 171             }),
 172     "dev": dict({
 173                 "help": "Connector to exactly one network interface (mandatory)",
 174                 "name": "dev",
 175                 "max": 1,
 176                 "min": 1
 177             }),
 178     "apps": dict({
 179                 "help": "Connector to applications",
 180                 "name": "apps",
 181                 "max": -1,
 182                 "min": 0
 183             }),
 184     "protos": dict({
 185                 "help": "Connector to network stacks and protocols",
 186                 "name": "protos",
 187                 "max": -1,
 188                 "min": 0
 189             }),
 190     "chan": dict({
 191                 "help": "Connector to a channel for the device (mandatory)",
 192                 "name": "chan",
 193                 "max": 1,
 194                 "min": 1
 195             }),
 196     "queue": dict({
 197                 "help": "Connector to a queueing discipline (mandatory)",
 198                 "name": "queue",
 199                 "max": 1,
 200                 "min": 1
 201             }),
 202     "err": dict({
 203                 "help": "Connector to an error model for the device",
 204                 "name": "err",
 205                 "max": 1,
 206                 "min": 0
 207             }),
 208     "->fd": dict({
 209                 "help": "File descriptor receptor for devices with file descriptors",
 210                 "name": "->fd",
 211                 "max": 1,
 212                 "min": 0
 213             }),
 214     "fd->": dict({
 215                 "help": "File descriptor provider for devices with file descriptors",
 216                 "name": "fd->",
 217                 "max": 1,
 218                 "min": 0
 219             }),
 220     "phy": dict({
 221                 "help": "Connector to interconnect elements with a PHY wifi model",
 222                 "name": "phy",
 223                 "max": 1,
 224                 "min": 0
 225             }),
 226     "phys": dict({
 227                 "help": "Connector to interconnect a wifi channel with PHY wifi models",
 228                 "name": "phys",
 229                 "max": -1,
 230                 "min": 0
 231             }),
 232     "mac": dict({
 233                 "help": "Connector to interconnect a device with a MAC wifi model",
 234                 "name": "mac",
 235                 "max": 1,
 236                 "min": 0
 237             }),
 238     "manager": dict({
 239                 "help": "Connector to interconnect a wifi device with a wifi manager",
 240                 "name": "manager",
 241                 "max": 1,
 242                 "min": 0
 243             }),
 244     "delay": dict({
 245                 "help": "Connector to a delay model",
 246                 "name": "delay",
 247                 "max": 1,
 248                 "min": 0
 249             }),
 250     "loss": dict({
 251                 "help": "Connector to a loss model",
 252                 "name": "loss",
 253                 "max": 1,
 254                 "min": 0
 255             }),
 256     "prev": dict({
 257                 "help": "Connector to the previous loss model",
 258                 "name": "prev",
 259                 "max": 1,
 260                 "min": 0
 261             }),
 262     "next": dict({
 263                 "help": "Connector to the next loss model",
 264                 "name": "next",
 265                 "max": 1,
 266                 "min": 0
 267             }),
 268     "mobility": dict({
 269                 "help": "Connector to a mobility model for the node",
 270                 "name": "mobility",
 271                 "max": 1,
 272                 "min": 0
 273             }),
 274     "tcp": dict({
 275                 "help": "ip-ip tunneling over TCP link",
 276                 "name": "tcp",
 277                 "max": 1,
 278                 "min": 0
 279             }),
 280     "udp": dict({
 281                 "help": "ip-ip tunneling over UDP datagrams",
 282                 "name": "udp",
 283                 "max": 1,
 284                 "min": 0
 285             }),
 286     })
 287
 288 connections = [
 289     dict({
 290             "from": ( "ns3", "ns3::Node", "devs" ),
 291             "to":   ( "ns3", "ns3::BridgeNetDevice", "node" ),
 292             "init_code": connect_node_device,
 293             "can_cross": False
 294     }),
 295     dict({
 296             "from": ( "ns3", "ns3::Node", "devs" ),
 297             "to":   ( "ns3", "ns3::CsmaNetDevice", "node" ),
 298             "init_code": connect_node_device,
 299             "can_cross": False
 300     }),
 301     dict({
 302             "from": ( "ns3", "ns3::Node", "devs" ),
 303             "to":   ( "ns3", "ns3::EmuNetDevice", "node" ),
 304             "init_code": connect_node_device,
 305             "can_cross": False
 306     }),
 307     dict({
 308             "from": ( "ns3", "ns3::Node", "devs" ),
 309             "to":   ( "ns3", "ns3::PointToPointNetDevice", "node" ),
 310             "init_code": connect_node_device,
 311             "can_cross": False
 312     }),
 313     dict({
 314             "from": ( "ns3", "ns3::Node", "devs" ),
 315             "to":   ( "ns3", "ns3::SimpleNetDevice", "node" ),
 316             "init_code": connect_node_device,
 317             "can_cross": False
 318     }),
 319     dict({
 320             "from": ( "ns3", "ns3::Node", "devs" ),
 321             "to":   ( "ns3", "ns3::FileDescriptorNetDevice", "node" ),
 322             "init_code": connect_node_device,
 323             "can_cross": False
 324     }),
 325     dict({
 326             "from": ( "ns3", "ns3::Node", "devs" ),
 327             "to":   ( "ns3", "ns3::WifiNetDevice", "node" ),
 328             "init_code": connect_node_device,
 329             "can_cross": False
 330     }),
 331     dict({
 332             "from": ( "ns3", "ns3::DropTailQueue", "dev" ),
 333             "to":   ( "ns3", "ns3::CsmaNetDevice", "queue" ),
 334             "init_code": connect_queue_device,
 335             "can_cross": False
 336     }),
 337     dict({
 338             "from": ( "ns3", "ns3::DropTailQueue", "dev" ),
 339             "to":   ( "ns3", "ns3::EmuNetDevice", "queue" ),
 340             "init_code": connect_queue_device,
 341             "can_cross": False
 342     }),
 343     dict({
 344             "from": ( "ns3", "ns3::DropTailQueue", "dev" ),
 345             "to":   ( "ns3", "ns3::PointToPointNetDevice", "queue" ),
 346             "init_code": connect_queue_device,
 347             "can_cross": False
 348     }),
 349     dict({
 350             "from": ( "ns3", "ns3::ArfWifiManager", "dev" ),
 351             "to":   ( "ns3", "ns3::WifiNetDevice", "manager" ),
 352             "init_code": connect_manager_device,
 353             "can_cross": False
 354     }),
 355     dict({
 356             "from": ( "ns3", "ns3::ConstantRateWifiManager", "dev" ),
 357             "to":   ( "ns3", "ns3::WifiNetDevice", "manager" ),
 358             "init_code": connect_manager_device,
 359             "can_cross": False
 360     }),
 361     dict({
 362             "from": ( "ns3", "ns3::YansWifiPhy", "dev" ),
 363             "to":   ( "ns3", "ns3::WifiNetDevice", "phy" ),
 364             "init_code": connect_phy_device,
 365             "can_cross": False
 366     }),
 367     dict({
 368             "from": ( "ns3", "ns3::QapWifiMac", "dev" ),
 369             "to":   ( "ns3", "ns3::WifiNetDevice", "mac" ),
 370             "init_code": connect_mac_device,
 371             "can_cross": False
 372     }),
 373     dict({
 374             "from": ( "ns3", "ns3::QstaWifiMac", "dev" ),
 375             "to":   ( "ns3", "ns3::WifiNetDevice", "mac" ),
 376             "init_code": connect_mac_device,
 377             "can_cross": False
 378     }),
 379     dict({
 380             "from": ( "ns3", "ns3::RateErrorModel", "dev" ),
 381             "to":   ( "ns3", "ns3::CsmaNetDevice", "err" ),
 382             "init_code": connect_errormodel_device,
 383             "can_cross": False
 384     }),
 385     dict({
 386             "from": ( "ns3", "ns3::RateErrorModel", "dev" ),
 387             "to":   ( "ns3", "ns3::PointToPointNetDevice", "err" ),
 388             "init_code": connect_errormodel_device,
 389             "can_cross": False
 390     }),
 391     dict({
 392             "from": ( "ns3", "ns3::ListErrorModel", "dev" ),
 393             "to":   ( "ns3", "ns3::CsmaNetDevice", "err" ),
 394             "init_code": connect_errormodel_device,
 395             "can_cross": False
 396     }),
 397     dict({
 398             "from": ( "ns3", "ns3::ListErrorModel", "dev" ),
 399             "to":   ( "ns3", "ns3::PointToPointNetDevice", "err" ),
 400             "init_code": connect_errormodel_device,
 401             "can_cross": False
 402     }),
 403     dict({
 404         "from": ( "ns3", "ns3::NistErrorRateModel", "phy" ),
 405         "to":   ( "ns3", "ns3::YansWifiPhy", "err" ),
 406         "init_code": connect_errormodel_phy,
 407         "can_cross": False
 408     }),
 409     dict({
 410         "from": ( "ns3", "ns3::CsmaChannel", "devs" ),
 411         "to":   ( "ns3", "ns3::CsmaNetDevice", "chan" ),
 412         "init_code": connect_channel_device,
 413         "can_cross": False
 414     }),
 415     dict({
 416         "from": ( "ns3", "ns3::PointToPointChannel", "dev2" ),
 417         "to":   ( "ns3", "ns3::PointToPointNetDevice", "chan" ),
 418         "init_code": connect_channel_device,
 419         "can_cross": False
 420     }),
 421     dict({
 422         "from": ( "ns3", "ns3::SimpleChannel", "devs" ),
 423         "to":   ( "ns3", "ns3::SimpleNetDevice", "chan" ),
 424         "init_code": connect_simple_channel_device,
 425         "can_cross": False
 426     }),
 427     dict({
 428         "from": ( "ns3", "ns3::YansWifiChannel", "phys" ),
 429         "to":   ( "ns3", "ns3::YansWifiPhy", "chan" ),
 430         "init_code": connect_simple_channel_device,
 431         "can_cross": False
 432     }),
 433     dict({
 434         "from": ( "ns3", "ns3::LogDistancePropagationLossModel", "prev" ),
 435         "to":   ( "ns3", "ns3::YansWifiChannel", "loss" ),
 436         "init_code": connect_loss_channel,
 437         "can_cross": False
 438     }),
 439     dict({
 440         "from": ( "ns3", "ns3::LogDistancePropagationLossModel", "prev" ),
 441         "to":   ( "ns3", "ns3::LogDistancePropagationLossModel", "next" ),
 442         "init_code": connect_next_loss,
 443         "can_cross": False
 444     }),
 445     dict({
 446         "from": ( "ns3", "ns3::ConstantSpeedPropagationDelayModel", "chan" ),
 447         "to":   ( "ns3", "ns3::YansWifiChannel", "delay" ),
 448         "init_code": connect_delay_channel,
 449         "can_cross": False
 450     }),
 451     dict({
 452         "from": ( "ns3", "ns3::Node", "apps" ),
 453         "to":   ( "ns3", "ns3::OnOffApplication", "node" ),
 454         "init_code": connect_node_application,
 455         "can_cross": False
 456     }),
 457     dict({
 458         "from": ( "ns3", "ns3::Node", "apps" ),
 459         "to":   ( "ns3", "ns3::PacketSink", "node" ),
 460         "init_code": connect_node_application,
 461         "can_cross": False
 462     }),
 463     dict({
 464         "from": ( "ns3", "ns3::Node", "apps" ),
 465         "to":   ( "ns3", "ns3::UdpEchoClient", "node" ),
 466         "init_code": connect_node_application,
 467         "can_cross": False
 468     }),
 469     dict({
 470         "from": ( "ns3", "ns3::Node", "apps" ),
 471         "to":   ( "ns3", "ns3::UdpEchoServer", "node" ),
 472         "init_code": connect_node_application,
 473         "can_cross": False
 474     }),
 475     dict({
 476         "from": ( "ns3", "ns3::Node", "apps" ),
 477         "to":   ( "ns3", "ns3::V4Ping", "node" ),
 478         "init_code": connect_node_application,
 479         "can_cross": False
 480     }),
 481     dict({
 482         "from": ( "ns3", "ns3::Node", "protos" ),
 483         "to":   ( "ns3", "ns3::ArpL3Protocol", "node" ),
 484         "init_code": connect_node_other,
 485         "can_cross": False
 486     }),
 487     dict({
 488         "from": ( "ns3", "ns3::Node", "protos" ),
 489         "to":   ( "ns3", "ns3::Icmpv4L4Protocol", "node" ),
 490         "init_code": connect_node_other,
 491         "can_cross": False
 492     }),
 493     dict({
 494         "from": ( "ns3", "ns3::Node", "protos" ),
 495         "to":   ( "ns3", "ns3::Icmpv6L4Protocol", "node" ),
 496         "init_code": connect_node_other,
 497         "can_cross": False
 498     }),
 499     dict({
 500         "from": ( "ns3", "ns3::Node", "protos" ),
 501         "to":   ( "ns3", "ns3::Ipv4L3Protocol", "node" ),
 502         "init_code": connect_node_other,
 503         "can_cross": False
 504     }),
 505     dict({
 506         "from": ( "ns3", "ns3::Node", "protos" ),
 507         "to":   ( "ns3", "ns3::Ipv6L3Protocol", "node" ),
 508         "init_code": connect_node_other,
 509         "can_cross": False
 510     }),
 511     dict({
 512         "from": ( "ns3", "ns3::Node", "protos" ),
 513         "to":   ( "ns3", "ns3::UdpL4Protocol", "node" ),
 514         "init_code": connect_node_other,
 515         "can_cross": False
 516     }),
 517     dict({
 518         "from": ( "ns3", "ns3::Node", "protos" ),
 519         "to":   ( "ns3", "ns3::TcpL4Protocol", "node" ),
 520         "init_code": connect_node_other,
 521         "can_cross": False
 522     }),
 523     dict({
 524         "from": ( "ns3", "ns3::Node", "mobility" ),
 525         "to":   ( "ns3", "ns3::ConstantAccelerationMobilityModel", "node" ),
 526         "init_code": connect_node_other,
 527         "can_cross": False
 528     }),
 529     dict({
 530         "from": ( "ns3", "ns3::Node", "mobility" ),
 531         "to":   ( "ns3", "ns3::ConstantPositionMobilityModel", "node" ),
 532         "init_code": connect_node_other,
 533         "can_cross": False
 534     }),
 535     dict({
 536         "from": ( "ns3", "ns3::Node", "mobility" ),
 537         "to":   ( "ns3", "ns3::ConstantVelocityMobilityModel", "node" ),
 538         "init_code": connect_node_other,
 539         "can_cross": False
 540     }),
 541     dict({
 542         "from": ( "ns3", "ns3::Node", "mobility" ),
 543         "to":   ( "ns3", "ns3::HierarchicalMobilityModel", "node" ),
 544         "init_code": connect_node_other,
 545         "can_cross": False
 546     }),
 547     dict({
 548         "from": ( "ns3", "ns3::Node", "mobility" ),
 549         "to":   ( "ns3", "ns3::RandomDirection2dMobilityModel", "node" ),
 550         "init_code": connect_node_other,
 551         "can_cross": False
 552     }),
 553     dict({
 554         "from": ( "ns3", "ns3::Node", "mobility" ),
 555         "to":   ( "ns3", "ns3::RandomWalk2dMobilityModel", "node" ),
 556         "init_code": connect_node_other,
 557         "can_cross": False
 558     }),
 559     dict({
 560         "from": ( "ns3", "ns3::Node", "mobility" ),
 561         "to":   ( "ns3", "ns3::RandomWaypointMobilityModel", "node" ),
 562         "init_code": connect_node_other,
 563         "can_cross": False
 564     }),
 565     dict({
 566         "from": ( "ns3", "ns3::FileDescriptorNetDevice", "->fd" ),
 567         "to":   ( None, None, "fd->" ),
 568         "init_code": connect_fd,
 569         "can_cross": True
 570     }),
 571     dict({
 572         "from": ( "ns3", "ns3::Nepi::TunChannel", "fd->" ),
 573         "to":   ( "ns3", "ns3::FileDescriptorNetDevice", "->fd" ),
 574         "init_code": connect_tunchannel_fd,
 575         "can_cross": False
 576     }),
 577     dict({
 578         "from": ( "ns3", "ns3::Nepi::TunChannel", "tcp"),
 579         "to":   (None, None, "tcp"),
 580         "init_code": functools.partial(crossconnect_tunchannel_peer_init,"tcp"),
 581         "compl_code": functools.partial(crossconnect_tunchannel_peer_compl,"tcp"),
 582         "can_cross": True
 583     }),
 584     dict({
 585         "from": ( "ns3", "ns3::Nepi::TunChannel", "udp"),
 586         "to":   (None, None, "udp"),
 587         "init_code": functools.partial(crossconnect_tunchannel_peer_init,"udp"),
 588         "compl_code": functools.partial(crossconnect_tunchannel_peer_compl,"udp"),
 589         "can_cross": True
 590     }),
 591 ]
 592
 593 traces = dict({
 594     "p2ppcap": dict({
 595                 "name": "P2PPcapTrace",
 596                 "help": "Trace to sniff packets from a P2P network device"
 597               }),
 598     "p2pascii": dict({
 599                 "name": "P2PAsciiTrace",
 600                 "help": "Ascii trace from a P2P network device"
 601               }),
 602     "csmapcap_promisc": dict({
 603                 "name": "CsmaPromiscPcapTrace",
 604                 "help": "Trace to sniff packets from a Csma network device in promiscuous mode"
 605               }),
 606     "csmapcap": dict({
 607                 "name": "CsmaPcapTrace",
 608                 "help": "Trace to sniff packets from a Csma network device"
 609               }),
 610     "fdpcap": dict({
 611                 "name": "FileDescriptorPcapTrace",
 612                 "help": "Trace to sniff packets from a FileDescriptor network device"
 613               }),
 614     "yanswifipcap": dict({
 615                 "name": "YansWifiPhyPcapTrace",
 616                 "help": "Trace to sniff packets from a Wifi network device"
 617               }),
 618 })
 619
 620 factories_order = ["ns3::BasicEnergySource",
 621     "ns3::WifiRadioEnergyModel",
 622     "ns3::BSSchedulerRtps",
 623     "ns3::BSSchedulerSimple",
 624     "ns3::SubscriberStationNetDevice",
 625     "ns3::BaseStationNetDevice",
 626     "ns3::UdpTraceClient",
 627     "ns3::UdpServer",
 628     "ns3::UdpClient",
 629     "ns3::FlowMonitor",
 630     "ns3::Radvd",
 631     "ns3::Ping6",
 632     "ns3::flame::FlameProtocol",
 633     "ns3::flame::FlameRtable",
 634     "ns3::dot11s::AirtimeLinkMetricCalculator",
 635     "ns3::dot11s::HwmpProtocol",
 636     "ns3::dot11s::HwmpRtable",
 637     "ns3::dot11s::PeerManagementProtocol",
 638     "ns3::dot11s::PeerLink",
 639     "ns3::MeshWifiInterfaceMac",
 640     "ns3::MeshPointDevice",
 641     "ns3::UanMacRcGw",
 642     "ns3::UanMacRc",
 643     "ns3::UanPhyCalcSinrDual",
 644     "ns3::UanPhyPerGenDefault",
 645     "ns3::UanPhyDual",
 646     "ns3::UanPropModelThorp",
 647     "ns3::UanMacCw",
 648     "ns3::UanNoiseModelDefault",
 649     "ns3::UanMacAloha",
 650     "ns3::UanPropModelIdeal",
 651     "ns3::UanTransducerHd",
 652     "ns3::UanPhyCalcSinrDefault",
 653     "ns3::UanPhyGen",
 654     "ns3::UanPhyCalcSinrFhFsk",
 655     "ns3::UanPhyPerUmodem",
 656     "ns3::UanChannel",
 657     "ns3::V4Ping",
 658     "ns3::AthstatsWifiTraceSink",
 659     "ns3::FlameStack",
 660     "ns3::Dot11sStack",
 661     "ns3::NonCommunicatingNetDevice",
 662     "ns3::HalfDuplexIdealPhy",
 663     "ns3::AlohaNoackNetDevice",
 664     "ns3::SpectrumAnalyzer",
 665     "ns3::WaveformGenerator",
 666     "ns3::MultiModelSpectrumChannel",
 667     "ns3::SingleModelSpectrumChannel",
 668     "ns3::MsduStandardAggregator",
 669     "ns3::EdcaTxopN",
 670     "ns3::QstaWifiMac",
 671     "ns3::QapWifiMac",
 672     "ns3::QadhocWifiMac",
 673     "ns3::MinstrelWifiManager",
 674     "ns3::CaraWifiManager",
 675     "ns3::AarfcdWifiManager",
 676     "ns3::OnoeWifiManager",
 677     "ns3::AmrrWifiManager",
 678     "ns3::ConstantRateWifiManager",
 679     "ns3::IdealWifiManager",
 680     "ns3::AarfWifiManager",
 681     "ns3::ArfWifiManager",
 682     "ns3::WifiNetDevice",
 683     "ns3::NqstaWifiMac",
 684     "ns3::NqapWifiMac",
 685     "ns3::AdhocWifiMac",
 686     "ns3::DcaTxop",
 687     "ns3::WifiMacQueue",
 688     "ns3::YansWifiChannel",
 689     "ns3::YansWifiPhy",
 690     "ns3::NistErrorRateModel",
 691     "ns3::YansErrorRateModel",
 692     "ns3::WaypointMobilityModel",
 693     "ns3::ConstantAccelerationMobilityModel",
 694     "ns3::RandomDirection2dMobilityModel",
 695     "ns3::RandomWalk2dMobilityModel",
 696     "ns3::SteadyStateRandomWaypointMobilityModel",
 697     "ns3::RandomWaypointMobilityModel",
 698     "ns3::GaussMarkovMobilityModel",
 699     "ns3::ConstantVelocityMobilityModel",
 700     "ns3::ConstantPositionMobilityModel",
 701     "ns3::ListPositionAllocator",
 702     "ns3::GridPositionAllocator",
 703     "ns3::RandomRectanglePositionAllocator",
 704     "ns3::RandomBoxPositionAllocator",
 705     "ns3::RandomDiscPositionAllocator",
 706     "ns3::UniformDiscPositionAllocator",
 707     "ns3::HierarchicalMobilityModel",
 708     "ns3::aodv::RoutingProtocol",
 709     "ns3::UdpEchoServer",
 710     "ns3::UdpEchoClient",
 711     "ns3::PacketSink",
 712     "ns3::OnOffApplication",
 713     "ns3::VirtualNetDevice",
 714     "ns3::FileDescriptorNetDevice",
 715     "ns3::Nepi::TunChannel",
 716     "ns3::TapBridge",
 717     "ns3::BridgeChannel",
 718     "ns3::BridgeNetDevice",
 719     "ns3::EmuNetDevice",
 720     "ns3::CsmaChannel",
 721     "ns3::CsmaNetDevice",
 722     "ns3::PointToPointRemoteChannel",
 723     "ns3::PointToPointChannel",
 724     "ns3::PointToPointNetDevice",
 725     "ns3::NscTcpL4Protocol",
 726     "ns3::Icmpv6L4Protocol",
 727     "ns3::Ipv6OptionPad1",
 728     "ns3::Ipv6OptionPadn",
 729     "ns3::Ipv6OptionJumbogram",
 730     "ns3::Ipv6OptionRouterAlert",
 731     "ns3::Ipv6ExtensionHopByHop",
 732     "ns3::Ipv6ExtensionDestination",
 733     "ns3::Ipv6ExtensionFragment",
 734     "ns3::Ipv6ExtensionRouting",
 735     "ns3::Ipv6ExtensionLooseRouting",
 736     "ns3::Ipv6ExtensionESP",
 737     "ns3::Ipv6ExtensionAH",
 738     "ns3::Ipv6L3Protocol",
 739     "ns3::LoopbackNetDevice",
 740     "ns3::Icmpv4L4Protocol",
 741     "ns3::RttMeanDeviation",
 742     "ns3::ArpL3Protocol",
 743     "ns3::TcpL4Protocol",
 744     "ns3::UdpL4Protocol",
 745     "ns3::Ipv4L3Protocol",
 746     "ns3::SimpleNetDevice",
 747     "ns3::SimpleChannel",
 748     "ns3::PacketSocket",
 749     "ns3::DropTailQueue",
 750     "ns3::Node",
 751     "ns3::FriisSpectrumPropagationLossModel",
 752     "ns3::Cost231PropagationLossModel",
 753     "ns3::JakesPropagationLossModel",
 754     "ns3::RandomPropagationLossModel",
 755     "ns3::FriisPropagationLossModel",
 756     "ns3::TwoRayGroundPropagationLossModel",
 757     "ns3::LogDistancePropagationLossModel",
 758     "ns3::ThreeLogDistancePropagationLossModel",
 759     "ns3::NakagamiPropagationLossModel",
 760     "ns3::FixedRssLossModel",
 761     "ns3::MatrixPropagationLossModel",
 762     "ns3::RangePropagationLossModel",
 763     "ns3::RandomPropagationDelayModel",
 764     "ns3::ConstantSpeedPropagationDelayModel",
 765     "ns3::RateErrorModel",
 766     "ns3::ListErrorModel",
 767     "ns3::ReceiveListErrorModel",
 768     "ns3::PacketBurst",
 769     "ns3::EnergySourceContainer"
 770  ]
 771
 772 testbed_attributes = dict({
 773      "simu_impl_type": dict({
 774             "name": "SimulatorImplementationType",
 775             "help": "The object class to use as the simulator implementation",
 776             "type": Attribute.STRING,
 777             "flags": Attribute.DesignOnly,
 778             "validation_function": validation.is_string
 779         }),
 780       "checksum": dict({
 781             "name": "ChecksumEnabled",
 782             "help": "A global switch to enable all checksums for all protocols",
 783             "type": Attribute.BOOL,
 784             "value": False,
 785             "flags": Attribute.DesignOnly,
 786             "validation_function": validation.is_bool
 787         }),
 788 })
 789
 790 class VersionedMetadataInfo(metadata.VersionedMetadataInfo):
 791     @property
 792     def connector_types(self):
 793         return connector_types
 794
 795     @property
 796     def connections(self):
 797         return connections
 798
 799     @property
 800     def attributes(self):
 801         from attributes_metadata_v3_9_RC3 import attributes
 802         return attributes
 803
 804     @property
 805     def traces(self):
 806         return traces
 807
 808     @property
 809     def create_order(self):
 810         return factories_order
 811
 812     @property
 813     def configure_order(self):
 814         return factories_order
 815
 816     @property
 817     def factories_info(self):
 818         from factories_metadata_v3_9_RC3 import factories_info
 819         return factories_info
 820
 821     @property
 822     def testbed_attributes(self):
 823         return testbed_attributes
 824