iface1.set_attribute_value("up", True)
node1.connector("devs").connect(iface1.connector("node"))
ip1 = iface1.add_address()
-p1.set_attribute_value("Address", "10.0.0.1")
+ip1.set_attribute_value("Address", "10.0.0.1")
iface2 = netns.create("NodeInterface")
iface2.set_attribute_value("up", True)
node2.connector("devs").connect(iface2.connector("node"))
app.set_attribute_value("command", "ping -qc10 10.0.0.2")
app.connector("node").connect(node1.connector("apps"))
-#print experiment.xml_description
+print experiment.xml_description
description = """
<experiment>
return self._help
@property
- def readornly(self):
+ def readonly(self):
return self._readonly
@property
def allowed(self):
return self._allowed
+ @property
+ def validation_function(self):
+ return self._validation_function
+
def get_value(self):
return self._value
def can_connect(self, connector):
connector_type_id = connector.connector_type.connector_type_id
- self.connector_type.can_connect(connector_type_id)
+ return self.connector_type.can_connect(connector_type_id)
def destroy(self):
for connector in self._connections:
self.add_attribute(name = "NetPrefix",
help = "Network prefix for the address",
type = Attribute.INTEGER,
- prefix_range = prefix_range,
+ range = prefix_range,
validation_function = validation.is_integer)
if family == AF_INET:
self.add_attribute(name = "Broadcast",
for connector_type in factory.connector_types:
connector = Connector(self, connector_type)
- self._connectors[connector_type.connector_id] = connector
+ self._connectors[connector_type.name] = connector
for trace in factory.traces:
tr = Trace(trace.name, trace.help, trace.enabled)
self._traces[trace.name] = tr
super(AddressableBox, self).__init__(guid, factory, container)
self._family = family
# maximum number of addresses this box can have
- self._max_addresses = max_addressess
+ self._max_addresses = max_addresses
self._addresses = list()
@property
return self._boxes.values()
def create(self, factory_id):
- guid = self.guid_generator.next()
- factory = self._provider.factories(factory_id)
+ guid = self._guid_generator.next()
+ factory = self._provider.factory(factory_id)
box = factory.create(guid, self)
self._boxes[guid] = box
+ return box
def delete(self, guid):
box = self._boxes[guid]
self._guid_generator, testbed_version, testbed_provider)
guid = testbed_description.guid
self._testbed_descriptions[guid] = testbed_description
+ return testbed_description
def remove_testbed_description(self, testbed_description):
guid = testbed_description.guid
def get_metadata():
return dict({
- "node": dict({
+ "Node": dict({
"factory_type": "routing",
"display_name": "Node",
"help": "Node",
validation.is_bool)
]
}),
- "p2piface": dict({
+ "P2PInterface": dict({
"factory_type": "addressable",
"family": AF_INET,
"max_addresses": 1,
validation.is_bool),
]
}),
- "tapiface": dict({
+ "TapNodeInterface": dict({
"factory_type": "addressable",
"family": AF_INET,
"max_addresses": 1,
validation.is_bool),
]
}),
- "nodeiface": dict({ #TODO: Addresses!
+ "NodeInterface": dict({
"factory_type": "addressable",
"family": AF_INET,
"max_addresses": 1,
validation.is_bool),
]
}),
- "switch": dict({
+ "Switch": dict({
"display_name": "Switch",
"help": "Switch interface",
"category": "devices",
#TODO:("MaxAge", help, type, value, range, allowed, readonly, validation_function)
]
}),
- "application": dict({
+ "Application": dict({
"display_name": "Application",
"help": "Generic executable command line application",
"category": "applications",
def is_ip4_address(value):
try:
- ipaddr.IPv4(value)
- except ipaddr.Error:
+ ipaddr.IPv4Address(value)
+ except ipaddr.AddressValueError:
return False
return True
def is_ip6_address(value):
try:
- ipaddr.IPv6(value)
- except ipaddr.Error:
+ ipaddr.IPv6Address(value)
+ except ipaddr.AddressValueError:
return False
return True