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