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