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