--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+#
+# Experiment Topology:
+#
+# n1 --- n2 --- n3
+#
+#
+# This example is based on the ns-3 wifi-hidden-terminal.cc example.
+#
+
+from nepi.core.design import ExperimentDescription, FactoriesProvider
+from nepi.core.execute import ExperimentController
+import tempfile
+import time
+
+def create_node(ns3_desc):
+ node = ns3_desc.create("ns3::Node")
+ ipv4 = ns3_desc.create("ns3::Ipv4L3Protocol")
+ arp = ns3_desc.create("ns3::ArpL3Protocol")
+ icmp = ns3_desc.create("ns3::Icmpv4L4Protocol")
+ udp = ns3_desc.create("ns3::UdpL4Protocol")
+ tcp = ns3_desc.create("ns3::TcpL4Protocol")
+ node.connector("protos").connect(ipv4.connector("node"))
+ node.connector("protos").connect(arp.connector("node"))
+ node.connector("protos").connect(icmp.connector("node"))
+ node.connector("protos").connect(udp.connector("node"))
+ node.connector("protos").connect(tcp.connector("node"))
+ mobility = ns3_desc.create("ns3::ConstantPositionMobilityModel")
+ node.connector("mobility").connect(mobility.connector("node"))
+
+ return (node, mobility)
+
+def create_wifi_device(ns3_desc, node, channel):
+ dev = ns3_desc.create("ns3::WifiNetDevice")
+ node.connector("devs").connect(dev.connector("node"))
+ manager = ns3_desc.create("ns3::ConstantRateWifiManager")
+ manager.set_attribute_value("DataMode", "DsssRate2Mbps")
+ manager.set_attribute_value("ControlMode", "DsssRate1Mbps")
+ dev.connector("manager").connect(manager.connector("dev"))
+
+ mac = ns3_desc.create("ns3::AdhocWifiMac")
+ mac.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211b")
+ mac.set_attribute_value("QosSupported", False)
+ dev.connector("mac").connect(mac.connector("dev"))
+
+ phy = ns3_desc.create("ns3::YansWifiPhy")
+ phy.set_attribute_value("Standard", "WIFI_PHY_STANDARD_80211b")
+ dev.connector("phy").connect(phy.connector("dev"))
+ channel.connector("phys").connect(phy.connector("chan"))
+
+ return dev
+
+root_dir = tempfile.mkdtemp()
+
+exp_desc = ExperimentDescription()
+
+testbed_id = "ns3"
+ns3_provider = FactoriesProvider(testbed_id)
+ns3_desc = exp_desc.add_testbed_description(ns3_provider)
+ns3_desc.set_attribute_value("homeDirectory", root_dir)
+# 0. Enable or disable CTS/RTS
+# ??
+
+# 1 & 2 & 6. Create 3 nodes with their mobility models, and Install TCP/IP stack & assign IP addresses
+(node1, mob1) = create_node(ns3_desc)
+(node2, mob2) = create_node(ns3_desc)
+(node3, mob3) = create_node(ns3_desc)
+
+# 3. Create propagation loss matrix
+matrix = ns3_desc.create("ns3::MatrixPropagationLossModel")
+matrix.set_attribute_value("DefaultLoss", 200.0)
+
+mp1 = ns3_desc.create("ns3::Nepi::MobilityPair")
+mp1.connector("matrix").connect(matrix.connector("mobpair"))
+mp1.set_attribute_value("Loss", 50.0)
+mp1.connector("ma").connect(mob1.connector("mp"))
+mp1.connector("mb").connect(mob2.connector("mp"))
+
+mp2 = ns3_desc.create("ns3::Nepi::MobilityPair")
+mp2.connector("matrix").connect(matrix.connector("mobpair"))
+mp2.set_attribute_value("Loss", 50.0)
+mp2.connector("ma").connect(mob3.connector("mp"))
+mp2.connector("mb").connect(mob2.connector("mp"))
+
+# 4. Create & setup wifi channel
+channel = ns3_desc.create("ns3::YansWifiChannel")
+channel.connector("loss").connect(matrix.connector("chan"))
+delay = ns3_desc.create("ns3::ConstantSpeedPropagationDelayModel")
+channel.connector("delay").connect(delay.connector("chan"))
+
+# 5. Install wireless devices
+dev1 = create_wifi_device(ns3_desc, node1, channel)
+ip1 = dev1.add_address()
+ip1.set_attribute_value("Address", "10.0.0.1")
+ip1.set_attribute_value("NetPrefix", 8)
+
+dev2 = create_wifi_device(ns3_desc, node2, channel)
+ip2 = dev2.add_address()
+ip2.set_attribute_value("Address", "10.0.0.2")
+ip2.set_attribute_value("NetPrefix", 8)
+
+dev3 = create_wifi_device(ns3_desc, node3, channel)
+ip3 = dev3.add_address()
+ip3.set_attribute_value("Address", "10.0.0.3")
+ip3.set_attribute_value("NetPrefix", 8)
+
+app = ns3_desc.create("ns3::V4Ping")
+app.set_attribute_value("Remote", "10.0.0.3")
+app.set_attribute_value("Verbose", True)
+app.set_attribute_value("StartTime", "0s")
+app.set_attribute_value("StopTime", "20s")
+
+app.connector("node").connect(node1.connector("apps"))
+
+xml = exp_desc.to_xml()
+
+controller = ExperimentController(xml, root_dir)
+controller.start()
+
+controller.stop()
+controller.shutdown()
"type": Attribute.DOUBLE,
"help": "The default value for propagation loss, dB."
}),
+ "Loss": dict({
+ "name": "Loss",
+ "validation_function": validation.is_double,
+ "value": 1.7976900000000001e+308,
+ "type": Attribute.DOUBLE,
+ "help": "The default value for propagation loss, dB."
+ }),
+ "Symmetric": dict({
+ "name": "Symmetric",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "type": Attribute.BOOL,
+ "help": "Symmetry between in the propagation loss model between nodes."
+ }),
"IntervalT3": dict({
"name": "IntervalT3",
"validation_function": validation.is_time,
"help" : "Flag to enable or disable interface",
"type" : Attribute.BOOL,
"value" : True,
- "validation_function" : validation.is_integer,
+ "validation_function" : validation.is_bool,
+ }),
+ "QosSupported" : dict({
+ "name" : "QosSupported",
+ "help" : "Flag to enable or disable QoS support at wifi MAC layer",
+ "type" : Attribute.BOOL,
+ "value" : False,
+ "validation_function" : validation.is_bool,
}),
})
device = testbed_instance._elements[device_guid]
device.SetMac(mac)
-def connect_errormodel_device(testbed_instance, model_guid, device_guid):
+def connect_error_model_device(testbed_instance, model_guid, device_guid):
model = testbed_instance._elements[model_guid]
device = testbed_instance._elements[device_guid]
device.SetReceiveErrorModel(model)
-def connect_errormodel_phy(testbed_instance, err_guid, phy_guid):
+def connect_error_model_phy(testbed_instance, err_guid, phy_guid):
err = testbed_instance._elements[err_guid]
phy = testbed_instance._elements[phy_guid]
phy.SetErrorRateModel(err)
"max": 1,
"min": 0
}),
+ "mobpair": dict({
+ "help": "Connector from MatrixPropagationLossModel to MobilityPair",
+ "name": "mobpair",
+ "max": -1,
+ "min": 0
+ }),
+ "matrix": dict({
+ "help": "Connector from MobilityPair to MatrixPropagationLossModel",
+ "name": "matrix",
+ "max": 1,
+ "min": 0
+ }),
+ "mp": dict({
+ "help": "Connector from MobilityModel to MobilityPair",
+ "name": "mp",
+ "max": -1,
+ "min": 0
+ }),
+ "ma": dict({
+ "help": "Connector to the 'ma' source mobility model, in the context of a mobility loss pair ",
+ "name": "ma",
+ "max": 1,
+ "min": 0
+ }),
+ "mb": dict({
+ "help": "Connector to the 'mb' destination mobility model, in the context of a mobility loss pair ",
+ "name": "mb",
+ "max": 1,
+ "min": 1
+ }),
"tcp": dict({
"help": "Connector for ip-ip tunneling over TCP link",
"name": "tcp",
"init_code": connect_mac_device,
"can_cross": False
}),
+ dict({
+ "from": ( "ns3", "ns3::AdhocWifiMac", "dev" ),
+ "to": ( "ns3", "ns3::WifiNetDevice", "mac" ),
+ "init_code": connect_mac_device,
+ "can_cross": False
+ }),
dict({
"from": ( "ns3", "ns3::RateErrorModel", "dev" ),
"to": ( "ns3", "ns3::CsmaNetDevice", "err" ),
- "init_code": connect_errormodel_device,
+ "init_code": connect_error_model_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::RateErrorModel", "dev" ),
"to": ( "ns3", "ns3::PointToPointNetDevice", "err" ),
- "init_code": connect_errormodel_device,
+ "init_code": connect_error_model_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::ListErrorModel", "dev" ),
"to": ( "ns3", "ns3::CsmaNetDevice", "err" ),
- "init_code": connect_errormodel_device,
+ "init_code": connect_error_model_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::ListErrorModel", "dev" ),
"to": ( "ns3", "ns3::PointToPointNetDevice", "err" ),
- "init_code": connect_errormodel_device,
+ "init_code": connect_error_model_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::NistErrorRateModel", "phy" ),
"to": ( "ns3", "ns3::YansWifiPhy", "err" ),
- "init_code": connect_errormodel_phy,
+ "init_code": connect_error_model_phy,
"can_cross": False
}),
dict({
"init_code": connect_node_other,
"can_cross": False
}),
+
+
+ dict({
+ "from": ( "ns3", "ns3::Nepi::MobilityPair", "matrix" ),
+ "to": ( "ns3", "ns3::MatrixPropagationLossModel", "mobpair" ),
+ "init_code": connect_dummy,
+ "can_cross": False
+ }),
+ dict({
+ "from": ( "ns3", "ns3::Nepi::MobilityPair", "ma" ),
+ "to": ( "ns3", "ns3::ConstantVelocityMobilityModel", "mp" ),
+ "init_code": connect_dummy,
+ "can_cross": False
+ }),
+ dict({
+ "from": ( "ns3", "ns3::Nepi::MobilityPair", "mb" ),
+ "to": ( "ns3", "ns3::ConstantVelocityMobilityModel", "mp" ),
+ "init_code": connect_dummy,
+ "can_cross": False
+ }),
+ dict({
+ "from": ( "ns3", "ns3::Nepi::MobilityPair", "ma" ),
+ "to": ( "ns3", "ns3::ConstantAccelerationMobilityModel", "mp" ),
+ "init_code": connect_dummy,
+ "can_cross": False
+ }),
+ dict({
+ "from": ( "ns3", "ns3::Nepi::MobilityPair", "mb" ),
+ "to": ( "ns3", "ns3::ConstantAccelerationMobilityModel", "mp" ),
+ "init_code": connect_dummy,
+ "can_cross": False
+ }),
+ dict({
+ "from": ( "ns3", "ns3::Nepi::MobilityPair", "ma" ),
+ "to": ( "ns3", "ns3::ConstantPositionMobilityModel", "mp" ),
+ "init_code": connect_dummy,
+ "can_cross": False
+ }),
+ dict({
+ "from": ( "ns3", "ns3::Nepi::MobilityPair", "mb" ),
+ "to": ( "ns3", "ns3::ConstantPositionMobilityModel", "mp" ),
+ "init_code": connect_dummy,
+ "can_cross": False
+ }),
+ dict({
+ "from": ( "ns3", "ns3::MatrixPropagationLossModel", "chan" ),
+ "to": ( "ns3", "ns3::YansWifiChannel", "loss" ),
+ "init_code": connect_loss_channel,
+ "can_cross": False
+ }),
+
+
+
dict({
"from": ( "ns3", "ns3::Node", "mobility" ),
"to": ( "ns3", "ns3::ConstantAccelerationMobilityModel", "node" ),
element = testbed_instance._elements[guid]
element.AggregateObject(testbed_instance.ns3.PacketSocketFactory())
-def create_wifi_standard_model(testbed_instance, guid):
+def create_wifi_phy(testbed_instance, guid):
create_element(testbed_instance, guid)
element = testbed_instance._elements[guid]
parameters = testbed_instance._get_parameters(guid)
raise RuntimeError("No wifi standard set for %d" % guid)
element.ConfigureStandard(wifi_standards[standard])
+def create_wifi_mac(testbed_instance, guid):
+ create_element(testbed_instance, guid)
+ element = testbed_instance._elements[guid]
+ parameters = testbed_instance._get_parameters(guid)
+ standard = parameters.get("Standard")
+ if not standard:
+ raise RuntimeError("No wifi standard set for %d" % guid)
+ element.ConfigureStandard(wifi_standards[standard])
+ qos = parameters.get("QosSupported")
+ # BUG: There seems to be an inheritance problem with the Python Bindings and SetQosSupported.
+ # It seems to be onbly defined for regular-wifi-mac.h and not for its children...
+ # Report this!
+ # element.SetQosSupported(qos)
+
def create_waypoint_mobility(testbed_instance, guid):
create_element(testbed_instance, guid)
element = testbed_instance._elements[guid]
element = testbed_instance._elements[guid]
element.Start()
+def configure_matrix_propagation(testbed_instance, guid):
+ create_element(testbed_instance, guid)
+ element = testbed_instance._elements[guid]
+ mp_guids = testbed_instance.get_connected(guid, "mobpair", "matrix")
+ for mpg in mp_guids:
+ mp = testbed_instance._elements[mpg]
+ mas = testbed_instance.get_connected(mpg, "ma", "mp")
+ if len(mas) != 1:
+ raise RuntimeError("Wrong number of source mobility models for MobilityPair %d" % guid)
+ mbs = testbed_instance.get_connected(mpg, "mb", "mp")
+ if len(mbs) != 1:
+ raise RuntimeError("Wrong number of destination mobility models for MobilityPair %d" % guid)
+ parameters = testbed_instance._get_parameters(mpg)
+ loss = parameters.get("Loss")
+ symmetric = parameters.get("Symmetric")
+ element.SetLoss(mas[0].element, mbs[0].element, loss, symemtric)
+
+
### Factories ###
factories_create_order = ["ns3::BasicEnergySource",
"ns3::EdcaTxopN",
"ns3::StaWifiMac",
"ns3::ApWifiMac",
- "ns3::QadhocWifiMac",
"ns3::MinstrelWifiManager",
"ns3::CaraWifiManager",
"ns3::AarfcdWifiManager",
"ns3::NakagamiPropagationLossModel",
"ns3::FixedRssLossModel",
"ns3::MatrixPropagationLossModel",
+ "ns3::Nepi::MobilityPair",
"ns3::RangePropagationLossModel",
"ns3::RandomPropagationDelayModel",
"ns3::ConstantSpeedPropagationDelayModel",
"ns3::EdcaTxopN",
"ns3::StaWifiMac",
"ns3::ApWifiMac",
- "ns3::QadhocWifiMac",
"ns3::MinstrelWifiManager",
"ns3::CaraWifiManager",
"ns3::AarfcdWifiManager",
"ns3::NakagamiPropagationLossModel",
"ns3::FixedRssLossModel",
"ns3::MatrixPropagationLossModel",
+ "ns3::Nepi::MobilityPair",
"ns3::RangePropagationLossModel",
"ns3::RandomPropagationDelayModel",
"ns3::ConstantSpeedPropagationDelayModel",
"create_function": create_element,
"configure_function": configure_element,
"help": "",
- "connector_types": ["node"],
+ "connector_types": ["node", "mp"],
"box_attributes": ["Position",
"Velocity"],
"tags": [tags.MOBILE],
}),
"ns3::AdhocWifiMac": dict({
"category": FC.CATEGORY_MAC_MODELS,
- "create_function": create_element,
+ "create_function": create_wifi_mac,
"configure_function": configure_element,
"help": "",
- "connector_types": [],
+ "connector_types": ["dev"],
"box_attributes": ["CtsTimeout",
"AckTimeout",
"BasicBlockAckTimeout",
"Slot",
"Pifs",
"MaxPropagationDelay",
- "Ssid"],
+ "Ssid",
+ "Standard",
+ "QosSupported"],
}),
"ns3::ConstantAccelerationMobilityModel": dict({
"category": FC.CATEGORY_MOBILITY_MODELS,
"create_function": create_element,
"configure_function": configure_element,
"help": "",
- "connector_types": ["node"],
+ "connector_types": ["node", "mp"],
"box_attributes": ["Position",
"Velocity"],
"tags": [tags.MOBILE],
"ns3::MatrixPropagationLossModel": dict({
"category": FC.CATEGORY_LOSS_MODELS,
"create_function": create_element,
- "configure_function": configure_element,
+ "configure_function": configure_matrix_propagation,
"help": "",
- "connector_types": [],
+ "connector_types": ["mobpair", "chan"],
"box_attributes": ["DefaultLoss"],
+ }),
+ "ns3::Nepi::MobilityPair": dict({
+ "category": FC.CATEGORY_LOSS_MODELS,
+ "help": "",
+ "connector_types": ["matrix", "ma", "mb"],
+ "box_attributes": ["Loss", "Symmetric"],
}),
"ns3::WifiNetDevice": dict({
"category": FC.CATEGORY_DEVICES,
}),
"ns3::StaWifiMac": dict({
"category": FC.CATEGORY_MAC_MODELS,
- "create_function": create_wifi_standard_model,
+ "create_function": create_wifi_mac,
"configure_function": configure_element,
"help": "Station Wifi MAC Model",
"connector_types": ["dev"],
"Pifs",
"MaxPropagationDelay",
"Ssid",
- "Standard"],
+ "Standard",
+ "QosSupported"],
}),
"ns3::UdpEchoClient": dict({
"category": FC.CATEGORY_APPLICATIONS,
"create_function": create_element,
"configure_function": configure_element,
"help": "",
- "connector_types": ["node"],
+ "connector_types": ["node", "mp"],
"box_attributes": ["Position",
"Velocity"],
"tags": [tags.MOBILE],
}),
"ns3::ApWifiMac": dict({
"category": FC.CATEGORY_MAC_MODELS,
- "create_function": create_wifi_standard_model,
+ "create_function": create_wifi_mac,
"configure_function": configure_element,
"help": "Access point Wifi MAC Model",
"connector_types": ["dev"],
"Pifs",
"MaxPropagationDelay",
"Ssid",
- "Standard"],
+ "Standard",
+ "QosSupported"],
}),
"ns3::YansErrorRateModel": dict({
"category": FC.CATEGORY_ERROR_MODELS,
}),
"ns3::YansWifiPhy": dict({
"category": FC.CATEGORY_PHY_MODELS,
- "create_function": create_wifi_standard_model,
+ "create_function": create_wifi_phy,
"configure_function": configure_element,
"help": "",
"connector_types": ["dev", "err", "chan"],
"RtsCtsThreshold",
"FragmentationThreshold",
"NonUnicastMode"],
- }),
- "ns3::QadhocWifiMac": dict({
- "category": FC.CATEGORY_MAC_MODELS,
- "create_function": create_element,
- "configure_function": configure_element,
- "help": "",
- "connector_types": [],
- "box_attributes": ["CtsTimeout",
- "AckTimeout",
- "BasicBlockAckTimeout",
- "CompressedBlockAckTimeout",
- "Sifs",
- "EifsNoDifs",
- "Slot",
- "Pifs",
- "MaxPropagationDelay",
- "Ssid"],
}),
"ns3::JakesPropagationLossModel": dict({
"category": FC.CATEGORY_LOSS_MODELS,
git://git.onelab.eu / nepi.git / commitdiff