from nepi.core import metadata
from nepi.core.attributes import Attribute
from nepi.util import validation
-from nepi.util.constants import AF_INET, STATUS_NOT_STARTED, STATUS_RUNNING, \
- STATUS_FINISHED
-
-wifi_standards = dict({
- "WIFI_PHY_STANDARD_holland": 5,
- "WIFI_PHY_STANDARD_80211p_SCH": 7,
- "WIFI_PHY_STANDARD_80211_5Mhz": 4,
- "WIFI_PHY_UNKNOWN": 8,
- "WIFI_PHY_STANDARD_80211_10Mhz": 3,
- "WIFI_PHY_STANDARD_80211g": 2,
- "WIFI_PHY_STANDARD_80211p_CCH": 6,
- "WIFI_PHY_STANDARD_80211a": 0,
- "WIFI_PHY_STANDARD_80211b": 1
-})
### Connection functions ####
-def connect_node_device(testbed_instance, node, device):
+def connect_node_device(testbed_instance, node_guid, device_guid):
+ node = testbed_instance._elements[node_guid]
+ device = testbed_instance._elements[device_guid]
node.AddDevice(device)
-def connect_queue_device(testbed_instance, queue, device):
+def connect_queue_device(testbed_instance, queue_guid, device_guid):
+ queue = testbed_instance._elements[queue_guid]
+ device = testbed_instance._elements[device_guid]
device.SetQueue(queue)
-def connect_manager_device(testbed_instance, manager, device):
+def connect_manager_device(testbed_instance, manager_guid, device_guid):
+ manager = testbed_instance._elements[manager_guid]
+ device = testbed_instance._elements[device_guid]
device.SetRemoteStationManager(manager)
-def connect_phy_device(testbed_instance, phy, device):
+def connect_phy_device(testbed_instance, phy_guid, device_guid):
+ phy = testbed_instance._elements[phy_guid]
+ device = testbed_instance._elements[device_guid]
device.SetPhy(phy)
phy.SetDevice(device)
# search for the node asociated with the device
- node_guid = testbed_instance.get_connected(guid, "node", "devs")
+ node_guid = testbed_instance.get_connected(device_guid, "node", "devs")
if len(node_guid) == 0:
raise RuntimeError("Can't instantiate interface %d outside netns \
- node" % guid)
+ node" % device_guid)
node = testbed_instance.elements[node_guid[0]]
phy.SetMobility(node)
-def connect_mac_device(testbed_instance, mac, device):
+def connect_mac_device(testbed_instance, mac_guid, device_guid):
+ mac = testbed_instance._elements[mac_guid]
+ device = testbed_instance._elements[device_guid]
device.SetMac(mac)
-def connect_errormodel_device(testbed_instance, model, device):
+def connect_errormodel_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, phy):
+def connect_errormodel_phy(testbed_instance, err_guid, phy_guid):
+ err = testbed_instance._elements[err_guid]
+ phy = testbed_instance._elements[phy_guid]
phy.SetErrorRateModel(err)
-def connect_channel_device(testbed_instance, channel, device):
+def connect_channel_device(testbed_instance, channel_guid, device_guid):
+ channel = testbed_instance._elements[channel_guid]
+ device = testbed_instance._elements[device_guid]
device.Attach(channel)
-def connect_simple_channel_device(testbed_instance, channel, device):
+def connect_simple_channel_device(testbed_instance, channel_guid, device_guid):
+ channel = testbed_instance._elements[channel_guid]
+ device = testbed_instance._elements[device_guid]
device.SetChannel(channel)
-def connect_loss_channel(testbed_instance, loss, channel):
+def connect_loss_channel(testbed_instance, loss_guid, channel_guid):
+ loss = testbed_instance._elements[loss_guid]
+ channel = testbed_instance._elements[channel_guid]
channel.SetPropagationLossModel(loss)
-def connect_next_loss(testbed_instance, prev, next):
+def connect_next_loss(testbed_instance, prev_guid, next_guid):
+ prev = testbed_instance._elements[prev_guid]
+ next = testbed_instance._elements[next_guid]
prev.SetNext(next)
-def connect_delay_channel(testbed_instance, delay, channel):
+def connect_delay_channel(testbed_instance, delay_guid, channel_guid):
+ delay = testbed_instance._elements[delay_guid]
+ channel = testbed_instance._elements[channel_guid]
channel.SetPropagationDelayModel(delay)
-def connect_node_application(testbed_instance, node, application):
+def connect_node_application(testbed_instance, node_guid, application_guid):
+ node = testbed_instance._elements[node_guid]
+ application = testbed_instance._elements[application_guid]
node.AddApplication(application)
# works for ArpL3Protocol, Ipv4L3Protocol, UdpL4Protocol, TcpL4Protocol,
# NscTcpL4Protocol, MobilityModel (every subclass),
# RoutingProtocol (every subclass)
-def connect_node_other(tesbed_instance, node, other):
+def connect_node_other(testbed_instance, node_guid, other_guid):
+ node = testbed_instance._elements[node_guid]
+ other = testbed_instance._elements[other_guid]
node.AggregateObject(other)
-def connect_fd_tap(tesbed_instance, fd, tap):
- # TODO!
- pass
-
- ### create traces functions ###
-
-def get_node_guid(testbed_instance, guid):
- node_guid = testbed_instance.get_connected(guid, "node", "devs")[0]
- return node_guid
-
-def get_dev_number(testbed_instance, guid):
- dev_guids = testbed_instance.get_connected(node_guid, "devs", "node")
- interface_number = 0
- for guid_ in dev_guids:
- if guid_ == guid:
- break
- inteface_number += 1
- return interface_number
-
-def p2ppcap_trace(testbed_instance, guid):
- trace_id = "p2ppcap"
- node_guid = get_node_guid(testbed_instance, guid)
- interface_number = get_dev_number(testbed_instance, guid)
- element = testbed_instance._elements[guid]
- filename = "trace-p2p-node-%d-dev-%d.pcap" % (node_name, interface_number)
- testbed_instance.follow_trace(guid, trace_id, filename)
- filepath = testbed_instance.trace_filename(self, guid, trace_id)
- helper = testbed_instance.ns3.PointToPointHelper()
- helper.EnablePcap(filepath, element, explicitFilename = True)
-
-def _csmapcap_trace(testbed_instance, guid, trace_id, promisc):
- node_guid = get_node_guid(testbed_instance, guid)
- interface_number = get_dev_number(testbed_instance, guid)
- element = testbed_instance._elements[guid]
- filename = "trace-csma-node-%d-dev-%d.pcap" % (node_name, interface_number)
- testbed_instance.follow_trace(guid, trace_id, filename)
- filepath = testbed_instance.trace_filename(self, guid, trace_id)
- helper = testbed_instance.ns3.CsmaHelper()
- helper.EnablePcap(filepath, element, promiscuous = promisc,
- explicitFilename = True)
-
-def csmapcap_trace(testbed_instance, guid):
- trace_id = "csmapcap"
- promisc = False
- _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
-
-def csmapcap_promisc_trace(testbed_instance, guid):
- trace_id = "csmapcap_promisc"
- promisc = True
- _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
-
-def fdpcap_trace(testbed_instance, guid):
- trace_id = "fdpcap"
- node_guid = get_node_guid(testbed_instance, guid)
- interface_number = get_dev_number(testbed_instance, guid)
- element = testbed_instance._elements[guid]
- filename = "trace-fd-node-%d-dev-%d.pcap" % (node_name, interface_number)
- testbed_instance.follow_trace(guid, trace_id, filename)
- filepath = testbed_instance.trace_filename(self, guid, trace_id)
- helper = testbed_instance.ns3.FileDescriptorHelper()
- helper.EnablePcap(filepath, element, explicitFilename = True)
-
-def yanswifipcap_trace(testbed_instance, guid):
- trace_id = "yanswifipcap"
- dev_guid = testbed_instance.get_connected(guid, "dev", "phy")[0]
- node_guid = get_node_guid(testbed_instance, dev_guid)
- interface_number = get_dev_number(testbed_instance, dev_guid)
- element = testbed_instance._elements[dev_guid]
- filename = "trace-yanswifi-node-%d-dev-%d.pcap" % (node_name, interface_number)
- testbed_instance.follow_trace(guid, trace_id, filename)
- filepath = testbed_instance.trace_filename(self, guid, trace_id)
- helper = testbed_instance.ns3.YansWifiPhyHelper()
- helper.EnablePcap(filepath, element, explicitFilename = True)
-
-trace_functions = dict({
- "p2ppcap": p2ppcap_trace,
- "csmapcap": csmapcap_trace,
- "csmapcap_promisc": csmapcap_promisc_trace,
- "fdpcap": fdpcap_trace,
- "yanswifipcap": yanswifipcap_trace
- })
+def connect_fd(testbed_instance, fdnd_guid, cross_data):
+ fdnd = testbed_instance._elements[fdnd_guid]
+ endpoint = fdnd.GetEndpoint()
+ # XXX: check the method StringToBuffer of ns3::FileDescriptorNetDevice
+ # to see how the address should be decoded
+ address = endpoint.replace(":", "").decode('hex')[2:]
+ testbed_instance.set(fdnd_guid, "LinuxSocketAddress", address)
-### Creation functions ###
-
-def create_element(testbed_instance, guid):
- element_factory = testbed_instance.ns3.ObjectFactory()
- factory_id = testbed_instance._create[guid]
- element_factory.SetTypeId(factory_id)
- construct_parameters = testbed_instance._get_construct_parameters(guid)
- for name, value in construct_parameters.iteritems():
- ns3_value = testbed_instance._to_ns3_value(factory_id, name, value)
- element_factory.Set(name, ns3_value)
- element = element_factory.Create()
- testbed_instance._elements[guid] = element
- traces = testbed_instance._get_traces(guid)
- for trace_id in traces:
- trace_func = trace_functions[trace_id]
- trace_func(testbed_instance, guid)
-
-def create_node(testbed_instance, guid):
- create_element(testbed_instance, guid)
- element = testbed_instance._elements[guid]
- element.AggregateObject(testbed_instance.PacketSocketFactory())
-
-def create_device(testbed_instance, guid):
- create_element(testbed_instance, guid)
- element = testbed_instance._elements[guid]
- parameters = testbed_instance._get_parameters(guid)
- if "macAddress" in parameters:
- address = parameters["macAddress"]
- macaddr = testbed_instance.ns3.Mac48Address(address)
- else:
- macaddr = testbed_instance.ns3.Mac48Address.Allocate()
- element.SetAddress(macaddr)
-
-def create_wifi_standard_model(testbed_instance, guid):
- create_element(testbed_instance, guid)
- element = testbed_instance._elements[guid]
- parameters = testbed_instance._get_parameters(guid)
- if "standard" in parameters:
- standard = parameters["standard"]
- if standard:
- elements.ConfigureStandard(wifi_standards[standard])
-
-def create_ipv4protocol(testbed_instance, guid):
- create_element(testbed_instance, guid)
- element = testbed_instance._elements[guid]
- list_routing = testbed_instance.ns3.Ipv4ListRouting()
- element.SetRoutingProtocol(list_routing)
- static_routing = testbed_instance.ns3.Ipv4StaticRouting()
- list_routing.AddRoutingProtocol(static_routing, 1)
-
-### Start/Stop functions ###
-
-def start_application(testbed_instance, guid):
- element = testbed_instance.elements[guid]
- element.Start()
-
-def stop_application(testbed_instance, guid):
- element = testbed_instance.elements[guid]
- element.Stop()
-
-### Status functions ###
-
-def status_application(testbed_instance, guid):
- if guid not in testbed_instance.elements.keys():
- return STATUS_NOT_STARTED
- app = testbed_instance.elements[guid]
- parameters = testbed_instance._get_parameters(guid)
- if "stopTime" in parameters:
- stop = parameters["stopTime"]
- if stop:
- simTime = testbed_instance.ns3.Simulator.Now()
- if simTime.Compare(stopTime) > 0:
- return STATUS_RUNNING
- return STATUS_FINISHED
-
-### Factory information ###
+### Connector information ###
connector_types = dict({
"node": dict({
dict({
"from": ( "ns3", "ns3::Node", "devs" ),
"to": ( "ns3", "ns3::BridgeNetDevice", "node" ),
- "code": connect_node_device,
+ "init_code": connect_node_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "devs" ),
"to": ( "ns3", "ns3::CsmaNetDevice", "node" ),
- "code": connect_node_device,
+ "init_code": connect_node_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "devs" ),
"to": ( "ns3", "ns3::EmuNetDevice", "node" ),
- "code": connect_node_device,
+ "init_code": connect_node_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "devs" ),
"to": ( "ns3", "ns3::PointToPointNetDevice", "node" ),
- "code": connect_node_device,
+ "init_code": connect_node_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "devs" ),
"to": ( "ns3", "ns3::SimpleNetDevice", "node" ),
- "code": connect_node_device,
+ "init_code": connect_node_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "devs" ),
"to": ( "ns3", "ns3::FileDescriptorNetDevice", "node" ),
- "code": connect_node_device,
+ "init_code": connect_node_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "devs" ),
"to": ( "ns3", "ns3::WifiNetDevice", "node" ),
- "code": connect_node_device,
+ "init_code": connect_node_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::DropTailQueue", "dev" ),
"to": ( "ns3", "ns3::CsmaNetDevice", "queue" ),
- "code": connect_queue_device,
+ "init_code": connect_queue_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::DropTailQueue", "dev" ),
"to": ( "ns3", "ns3::EmuNetDevice", "queue" ),
- "code": connect_queue_device,
+ "init_code": connect_queue_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::DropTailQueue", "dev" ),
"to": ( "ns3", "ns3::PointToPointNetDevice", "queue" ),
- "code": connect_queue_device,
+ "init_code": connect_queue_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::ArfWifiManager", "dev" ),
"to": ( "ns3", "ns3::WifiNetDevice", "manager" ),
- "code": connect_manager_device,
+ "init_code": connect_manager_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::ConstantRateWifiManager", "dev" ),
"to": ( "ns3", "ns3::WifiNetDevice", "manager" ),
- "code": connect_manager_device,
+ "init_code": connect_manager_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::YansWifiPhy", "dev" ),
"to": ( "ns3", "ns3::WifiNetDevice", "phy" ),
- "code": connect_phy_device,
+ "init_code": connect_phy_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::QapWifiMac", "dev" ),
"to": ( "ns3", "ns3::WifiNetDevice", "mac" ),
- "code": connect_mac_device,
+ "init_code": connect_mac_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::QstaWifiMac", "dev" ),
"to": ( "ns3", "ns3::WifiNetDevice", "mac" ),
- "code": connect_mac_device,
+ "init_code": connect_mac_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::RateErrorModel", "dev" ),
"to": ( "ns3", "ns3::CsmaNetDevice", "err" ),
- "code": connect_errormodel_device,
+ "init_code": connect_errormodel_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::RateErrorModel", "dev" ),
"to": ( "ns3", "ns3::PointToPointNetDevice", "err" ),
- "code": connect_errormodel_device,
+ "init_code": connect_errormodel_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::ListErrorModel", "dev" ),
"to": ( "ns3", "ns3::CsmaNetDevice", "err" ),
- "code": connect_errormodel_device,
+ "init_code": connect_errormodel_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::ListErrorModel", "dev" ),
"to": ( "ns3", "ns3::PointToPointNetDevice", "err" ),
- "code": connect_errormodel_device,
+ "init_code": connect_errormodel_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::NistErrorRateModel", "phy" ),
"to": ( "ns3", "ns3::YansWifiPhy", "err" ),
- "code": connect_errormodel_phy,
+ "init_code": connect_errormodel_phy,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::CsmaChannel", "devs" ),
"to": ( "ns3", "ns3::CsmaNetDevice", "chan" ),
- "code": connect_channel_device,
+ "init_code": connect_channel_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::PointToPointChannel", "dev2" ),
"to": ( "ns3", "ns3::PointToPointNetDevice", "chan" ),
- "code": connect_channel_device,
+ "init_code": connect_channel_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::SimpleChannel", "devs" ),
"to": ( "ns3", "ns3::SimpleNetDevice", "chan" ),
- "code": connect_simple_channel_device,
+ "init_code": connect_simple_channel_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::YansWifiChannel", "phys" ),
"to": ( "ns3", "ns3::YansWifiPhy", "chan" ),
- "code": connect_simple_channel_device,
+ "init_code": connect_simple_channel_device,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::LogDistancePropagationLossModel", "prev" ),
"to": ( "ns3", "ns3::YansWifiChannel", "loss" ),
- "code": connect_loss_channel,
+ "init_code": connect_loss_channel,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::LogDistancePropagationLossModel", "prev" ),
"to": ( "ns3", "ns3::LogDistancePropagationLossModel", "next" ),
- "code": connect_next_loss,
+ "init_code": connect_next_loss,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::ConstantSpeedPropagationDelayModel", "chan" ),
"to": ( "ns3", "ns3::YansWifiChannel", "delay" ),
- "code": connect_delay_channel,
+ "init_code": connect_delay_channel,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "apps" ),
"to": ( "ns3", "ns3::OnOffApplication", "node" ),
- "code": connect_node_application,
+ "init_code": connect_node_application,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "apps" ),
"to": ( "ns3", "ns3::PacketSink", "node" ),
- "code": connect_node_application,
+ "init_code": connect_node_application,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "apps" ),
"to": ( "ns3", "ns3::UdpEchoClient", "node" ),
- "code": connect_node_application,
+ "init_code": connect_node_application,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "apps" ),
"to": ( "ns3", "ns3::UdpEchoServer", "node" ),
- "code": connect_node_application,
+ "init_code": connect_node_application,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "apps" ),
"to": ( "ns3", "ns3::V4Ping", "node" ),
- "code": connect_node_application,
+ "init_code": connect_node_application,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "protos" ),
"to": ( "ns3", "ns3::ArpL3Protocol", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "protos" ),
"to": ( "ns3", "ns3::Icmpv4L4Protocol", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "protos" ),
"to": ( "ns3", "ns3::Ipv4L3Protocol", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "protos" ),
"to": ( "ns3", "ns3::UdpL4Protocol", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "protos" ),
"to": ( "ns3", "ns3::TcpL4Protocol", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "mobility" ),
"to": ( "ns3", "ns3::ConstantAccelerationMobilityModel", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "mobility" ),
"to": ( "ns3", "ns3::ConstantPositionMobilityModel", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "mobility" ),
"to": ( "ns3", "ns3::ConstantVelocityMobilityModel", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "mobility" ),
"to": ( "ns3", "ns3::HierarchicalMobilityModel", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "mobility" ),
"to": ( "ns3", "ns3::RandomDirection2dMobilityModel", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "mobility" ),
"to": ( "ns3", "ns3::RandomWalk2dMobilityModel", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::Node", "mobility" ),
"to": ( "ns3", "ns3::RandomWaypointMobilityModel", "node" ),
- "code": connect_node_other,
+ "init_code": connect_node_other,
"can_cross": False
}),
dict({
"from": ( "ns3", "ns3::FileDescriptorNetDevice", "fd" ),
"to": ( "netns", "TapNodeInterface", "fd" ),
- "code": connect_fd_tap,
- "can_cross": False
+ "init_code": connect_fd,
+ "can_cross": True
}),
]
"name": "P2PPcapTrace",
"help": "Trace to sniff packets from a P2P network device"
}),
+ "p2pascii": dict({
+ "name": "P2PAsciiTrace",
+ "help": "Ascii trace from a P2P network device"
+ }),
"csmapcap_promisc": dict({
"name": "CsmaPromiscPcapTrace",
"help": "Trace to sniff packets from a Csma network device in promiscuous mode"
]
testbed_attributes = dict({
- "ns3_bindings": dict({
- "name": "ns3Bindings",
- "help": "Location of the ns-3 python binding",
- "type": Attribute.STRING,
- "flags": Attribute.DesignOnly,
- "validation_function": validation.is_string # TODO: validation.is_path
- }),
- "ns3_library": dict({
- "name": "ns3Library",
- "help": "Location of the ns-3 library .so file",
- "type": Attribute.STRING,
- "flags": Attribute.DesignOnly,
- "validation_function": validation.is_string # TODO: validation.is_path
- }),
- "simu_impl_type": dict({
- "name": "SimulatorImplementationType",
- "help": "The object class to use as the simulator implementation",
- "type": Attribute.STRING,
- "flags": Attribute.DesignOnly,
- "validation_function": validation.is_string
- }),
- "checksum": dict({
- "name": "ChecksumEnabled",
- "help": "A global switch to enable all checksums for all protocols",
- "type": Attribute.BOOL,
- "value": False,
- "flags": Attribute.DesignOnly,
- "validation_function": validation.is_bool
- })
- })
+ "simu_impl_type": dict({
+ "name": "SimulatorImplementationType",
+ "help": "The object class to use as the simulator implementation",
+ "type": Attribute.STRING,
+ "flags": Attribute.DesignOnly,
+ "validation_function": validation.is_string
+ }),
+ "checksum": dict({
+ "name": "ChecksumEnabled",
+ "help": "A global switch to enable all checksums for all protocols",
+ "type": Attribute.BOOL,
+ "value": False,
+ "flags": Attribute.DesignOnly,
+ "validation_function": validation.is_bool
+ }),
+})
class VersionedMetadataInfo(metadata.VersionedMetadataInfo):
@property
return traces
@property
- def factories_order(self):
+ def create_order(self):
+ return factories_order
+
+ @property
+ def configure_order(self):
return factories_order
@property
git://git.onelab.eu / nepi.git / blobdiff