def guids(self):
raise NotImplementedError
- def configure(self, name, value):
- """Set a configuartion attribute for the testbed instance"""
+ def defer_configure(self, name, value):
+ """Instructs setting a configuartion attribute for the testbed instance"""
raise NotImplementedError
- def create(self, guid, factory_id):
+ def defer_create(self, guid, factory_id):
"""Instructs creation of element """
raise NotImplementedError
- def create_set(self, guid, name, value):
+ def defer_create_set(self, guid, name, value):
"""Instructs setting an initial attribute on an element"""
raise NotImplementedError
- def factory_set(self, guid, name, value):
+ def defer_factory_set(self, guid, name, value):
"""Instructs setting an attribute on a factory"""
raise NotImplementedError
- def connect(self, guid1, connector_type_name1, guid2,
+ def defer_connect(self, guid1, connector_type_name1, guid2,
connector_type_name2):
+ """Instructs creation of a connection between the given connectors"""
raise NotImplementedError
- def cross_connect(self, guid, connector_type_name, cross_guid,
+ def defer_cross_connect(self, guid, connector_type_name, cross_guid,
cross_testbed_id, cross_factory_id, cross_connector_type_name):
+ """
+ Instructs creation of a connection between the given connectors
+ of different testbed instances
+ """
raise NotImplementedError
- def add_trace(self, guid, trace_id):
+ def defer_add_trace(self, guid, trace_id):
+ """Instructs the addition of a trace"""
raise NotImplementedError
- def add_address(self, guid, address, netprefix, broadcast):
+ def defer_add_address(self, guid, address, netprefix, broadcast):
+ """Instructs the addition of an address"""
raise NotImplementedError
- def add_route(self, guid, destination, netprefix, nexthop):
+ def defer_add_route(self, guid, destination, netprefix, nexthop):
+ """Instructs the addition of a route"""
raise NotImplementedError
def do_setup(self):
raise NotImplementedError
def do_create(self):
- """After do_create all instructed elements are created and
- attributes setted"""
+ """
+ After do_create all instructed elements are created and
+ attributes setted
+ """
raise NotImplementedError
def do_connect(self):
- """After do_connect all internal connections between testbed elements
- are done"""
+ """
+ After do_connect all internal connections between testbed elements
+ are done
+ """
raise NotImplementedError
def do_configure(self):
raise NotImplementedError
def do_cross_connect(self):
- """After do_cross_connect all external connections between different testbed
- elements are done"""
+ """
+ After do_cross_connect all external connections between different testbed
+ elements are done
+ """
raise NotImplementedError
def start(self):
testbed = proxy.create_testbed_instance(testbed_id,
testbed_version, access_config)
for (name, value) in data.get_attribute_data(guid):
- testbed.configure(name, value)
+ testbed.defer_configure(name, value)
self._testbeds[guid] = testbed
else:
element_guids.append(guid)
for guid in element_guids:
(testbed_guid, factory_id) = data.get_box_data(guid)
testbed = self._testbeds[testbed_guid]
- testbed.create(guid, factory_id)
+ testbed.defer_create(guid, factory_id)
for (name, value) in data.get_attribute_data(guid):
- testbed.create_set(guid, name, value)
+ testbed.defer_create_set(guid, name, value)
for guid in element_guids:
(testbed_guid, factory_id) = data.get_box_data(guid)
(other_testbed_guid, other_factory_id) = data.get_box_data(
other_guid)
if testbed_guid == other_testbed_guid:
- testbed.connect(guid, connector_type_name, other_guid,
+ testbed.defer_connect(guid, connector_type_name, other_guid,
other_connector_type_name)
else:
- testbed.cross_connect(guid, connector_type_name, other_guid,
+ testbed.defer_cross_connect(guid, connector_type_name, other_guid,
other_testbed_id, other_factory_id, other_connector_type_name)
for trace_id in data.get_trace_data(guid):
- testbed.add_trace(guid, trace_id)
+ testbed.defer_add_trace(guid, trace_id)
for (autoconf, address, netprefix, broadcast) in \
data.get_address_data(guid):
if address != None:
- testbed.add_address(guid, address, netprefix, broadcast)
+ testbed.defer_add_address(guid, address, netprefix, broadcast)
for (destination, netprefix, nexthop) in data.get_route_data(guid):
- testbed.add_route(guid, destination, netprefix, nexthop)
+ testbed.defer_add_route(guid, destination, netprefix, nexthop)
def elements(self):
return self._elements
- def configure(self, name, value):
+ def defer_configure(self, name, value):
if not self._attributes.has_attribute(name):
raise RuntimeError("Invalid attribute %s for testbed" % name)
# Validation
self._attributes.set_attribute_value(name, value)
self._configure[name] = value
- def create(self, guid, factory_id):
+ def defer_create(self, guid, factory_id):
if factory_id not in self._factories:
raise RuntimeError("Invalid element type %s for testbed version %s" %
(factory_id, self._testbed_version))
guid)
self._create[guid] = factory_id
- def create_set(self, guid, name, value):
+ def defer_create_set(self, guid, name, value):
if not guid in self._create:
raise RuntimeError("Element guid %d doesn't exist" % guid)
factory_id = self._create[guid]
self._create_set[guid] = dict()
self._create_set[guid][name] = value
- def factory_set(self, guid, name, value):
+ def defer_factory_set(self, guid, name, value):
if not guid in self._create:
raise RuntimeError("Element guid %d doesn't exist" % guid)
factory_id = self._create[guid]
self._factory_set[guid] = dict()
self._factory_set[guid][name] = value
- def connect(self, guid1, connector_type_name1, guid2,
+ def defer_connect(self, guid1, connector_type_name1, guid2,
connector_type_name2):
factory_id1 = self._create[guid1]
factory_id2 = self._create[guid2]
self._connect[guid2][connector_type_name2][guid1] = \
connector_type_name1
- def cross_connect(self, guid, connector_type_name, cross_guid,
+ def defer_cross_connect(self, guid, connector_type_name, cross_guid,
cross_testbed_id, cross_factory_id, cross_connector_type_name):
factory_id = self._create[guid]
count = self._get_connection_count(guid, connector_type_name)
(cross_guid, cross_testbed_id, cross_factory_id,
cross_connector_type_name)
- def add_trace(self, guid, trace_id):
+ def defer_add_trace(self, guid, trace_id):
if not guid in self._create:
raise RuntimeError("Element guid %d doesn't exist" % guid)
factory_id = self._create[guid]
self._add_trace[guid] = list()
self._add_trace[guid].append(trace_id)
- def add_address(self, guid, address, netprefix, broadcast):
+ def defer_add_address(self, guid, address, netprefix, broadcast):
if not guid in self._create:
raise RuntimeError("Element guid %d doesn't exist" % guid)
factory_id = self._create[guid]
self._add_address[guid] = list()
self._add_address[guid].append((address, netprefix, broadcast))
- def add_route(self, guid, destination, netprefix, nexthop):
+ def defer_add_route(self, guid, destination, netprefix, nexthop):
if not guid in self._create:
raise RuntimeError("Element guid %d doesn't exist" % guid)
factory_id = self._create[guid]
if None in peer or self._localPeerName in peer:
if None in peer:
peer.remove(None)
- if self._localPeerName:
+ if self._localPeerName in peer:
peer.remove(self._localPeerName)
return (
self.GetNodes(nodeIdOrName, fields, filters=filters, peer=peer, **kw)
elif instruction == SHUTDOWN:
reply = self.shutdown(params)
elif instruction == CONFIGURE:
- reply = self.configure(params)
+ reply = self.defer_configure(params)
elif instruction == CREATE:
- reply = self.create(params)
+ reply = self.defer_create(params)
elif instruction == CREATE_SET:
- reply = self.create_set(params)
+ reply = self.defer_create_set(params)
elif instruction == FACTORY_SET:
- reply = self.factory_set(params)
+ reply = self.defer_factory_set(params)
elif instruction == CONNECT:
- reply = self.connect(params)
+ reply = self.defer_connect(params)
elif instruction == CROSS_CONNECT:
- reply = self.cross_connect(params)
+ reply = self.defer_cross_connect(params)
elif instruction == ADD_TRACE:
- reply = self.add_trace(params)
+ reply = self.defer_add_trace(params)
elif instruction == ADD_ADDRESS:
- reply = self.add_address(params)
+ reply = self.defer_add_address(params)
elif instruction == ADD_ROUTE:
- reply = self.add_route(params)
+ reply = self.defer_add_route(params)
elif instruction == DO_SETUP:
reply = self.do_setup(params)
elif instruction == DO_CREATE:
result = base64.b64encode(guids)
return "%d|%s" % (OK, result)
- def create(self, params):
+ def defer_create(self, params):
guid = int(params[1])
factory_id = params[2]
- self._testbed.create(guid, factory_id)
+ self._testbed.defer_create(guid, factory_id)
return "%d|%s" % (OK, "")
def trace(self, params):
self._testbed.shutdown()
return "%d|%s" % (OK, "")
- def configure(self, params):
+ def defer_configure(self, params):
name = base64.b64decode(params[1])
value = base64.b64decode(params[2])
type = int(params[3])
value = set_type(type, value)
- self._testbed.configure(name, value)
+ self._testbed.defer_configure(name, value)
return "%d|%s" % (OK, "")
- def create_set(self, params):
+ def defer_create_set(self, params):
guid = int(params[1])
name = base64.b64decode(params[2])
value = base64.b64decode(params[3])
type = int(params[4])
value = set_type(type, value)
- self._testbed.create_set(guid, name, value)
+ self._testbed.defer_create_set(guid, name, value)
return "%d|%s" % (OK, "")
- def factory_set(self, params):
+ def defer_factory_set(self, params):
name = base64.b64decode(params[1])
value = base64.b64decode(params[2])
type = int(params[3])
value = set_type(type, value)
- self._testbed.factory_set(name, value)
+ self._testbed.defer_factory_set(name, value)
return "%d|%s" % (OK, "")
- def connect(self, params):
+ def defer_connect(self, params):
guid1 = int(params[1])
connector_type_name1 = params[2]
guid2 = int(params[3])
connector_type_name2 = params[4]
- self._testbed.connect(guid1, connector_type_name1, guid2,
+ self._testbed.defer_connect(guid1, connector_type_name1, guid2,
connector_type_name2)
return "%d|%s" % (OK, "")
- def cross_connect(self, params):
+ def defer_cross_connect(self, params):
guid = int(params[1])
connector_type_name = params[2]
cross_guid = int(params[3])
cross_testbed_id = params[6]
cross_factory_id = params[7]
cross_connector_type_name = params[8]
- self._testbed.cross_connect(guid, connector_type_name, cross_guid,
+ self._testbed.defer_cross_connect(guid, connector_type_name, cross_guid,
cross_testbed_id, cross_factory_id, cross_connector_type_name)
return "%d|%s" % (OK, "")
- def add_trace(self, params):
+ def defer_add_trace(self, params):
guid = int(params[1])
trace_id = params[2]
- self._testbed.add_trace(guid, trace_id)
+ self._testbed.defer_add_trace(guid, trace_id)
return "%d|%s" % (OK, "")
- def add_address(self, params):
+ def defer_add_address(self, params):
guid = int(params[1])
address = params[2]
netprefix = int(params[3])
broadcast = params[4]
- self._testbed.add_address(guid, address, netprefix,
+ self._testbed.defer_add_address(guid, address, netprefix,
broadcast)
return "%d|%s" % (OK, "")
- def add_route(self, params):
+ def defer_add_route(self, params):
guid = int(params[1])
destination = params[2]
netprefix = int(params[3])
nexthop = params[4]
- self._testbed.add_route(guid, destination, netprefix, nexthop)
+ self._testbed.defer_add_route(guid, destination, netprefix, nexthop)
return "%d|%s" % (OK, "")
def do_setup(self, params):
raise RuntimeError(text)
return map(int, text.split(","))
- def configure(self, name, value):
+ def defer_configure(self, name, value):
msg = testbed_messages[CONFIGURE]
type = get_type(value)
# avoid having "|" in this parameters
if code == ERROR:
raise RuntimeError(text)
- def create(self, guid, factory_id):
+ def defer_create(self, guid, factory_id):
msg = testbed_messages[CREATE]
msg = msg % (guid, factory_id)
self._client.send_msg(msg)
if code == ERROR:
raise RuntimeError(text)
- def create_set(self, guid, name, value):
+ def defer_create_set(self, guid, name, value):
msg = testbed_messages[CREATE_SET]
type = get_type(value)
# avoid having "|" in this parameters
if code == ERROR:
raise RuntimeError(text)
- def factory_set(self, guid, name, value):
+ def defer_factory_set(self, guid, name, value):
msg = testbed_messages[FACTORY_SET]
type = get_type(value)
# avoid having "|" in this parameters
if code == ERROR:
raise RuntimeError(text)
- def connect(self, guid1, connector_type_name1, guid2,
+ def defer_connect(self, guid1, connector_type_name1, guid2,
connector_type_name2):
msg = testbed_messages[CONNECT]
msg = msg % (guid1, connector_type_name1, guid2,
if code == ERROR:
raise RuntimeError(text)
- def cross_connect(self, guid, connector_type_name, cross_guid,
+ def defer_cross_connect(self, guid, connector_type_name, cross_guid,
cross_testbed_id, cross_factory_id, cross_connector_type_name):
msg = testbed_messages[CROSS_CONNECT]
msg = msg % (guid, connector_type_name, cross_guid,
if code == ERROR:
raise RuntimeError(text)
- def add_trace(self, guid, trace_id):
+ def defer_add_trace(self, guid, trace_id):
msg = testbed_messages[ADD_TRACE]
msg = msg % (guid, trace_id)
self._client.send_msg(msg)
if code == ERROR:
raise RuntimeError(text)
- def add_address(self, guid, address, netprefix, broadcast):
+ def defer_add_address(self, guid, address, netprefix, broadcast):
msg = testbed_messages[ADD_ADDRESS]
msg = msg % (guid, address, netprefix, broadcast)
self._client.send_msg(msg)
if code == ERROR:
raise RuntimeError(text)
- def add_route(self, guid, destination, netprefix, nexthop):
+ def defer_add_route(self, guid, destination, netprefix, nexthop):
msg = testbed_messages[ADD_ROUTE]
msg = msg % (guid, destination, netprefix, nexthop)
self._client.send_msg(msg)
testbed_version = "01"
testbed_id = "mock"
instance = mock.TestbedInstance(testbed_version)
- instance.configure("fake", True)
- instance.create(2, "Node")
- instance.create(3, "Node")
- instance.create(4, "Node")
- instance.create(5, "Interface")
- instance.create_set(5, "fake", True)
- instance.connect(2, "devs", 5, "node")
- instance.create(6, "Interface")
- instance.create_set(6, "fake", True)
- instance.connect(3, "devs", 6, "node")
- instance.connect(5, "iface", 6, "iface")
- instance.create(7, "Application")
- instance.add_trace(7, "fake")
- instance.connect(7, "node", 2, "apps")
+ instance.defer_configure("fake", True)
+ instance.defer_create(2, "Node")
+ instance.defer_create(3, "Node")
+ instance.defer_create(4, "Node")
+ instance.defer_create(5, "Interface")
+ instance.defer_create_set(5, "fake", True)
+ instance.defer_connect(2, "devs", 5, "node")
+ instance.defer_create(6, "Interface")
+ instance.defer_create_set(6, "fake", True)
+ instance.defer_connect(3, "devs", 6, "node")
+ instance.defer_connect(5, "iface", 6, "iface")
+ instance.defer_create(7, "Application")
+ instance.defer_add_trace(7, "fake")
+ instance.defer_connect(7, "node", 2, "apps")
instance.do_setup()
instance.do_create()
user = getpass.getuser()
testbed_version = "01"
instance = netns.TestbedInstance(testbed_version)
- instance.configure("homeDirectory", self.root_dir)
- instance.create(2, "Node")
- instance.create(3, "Node")
- instance.create(4, "NodeInterface")
- instance.create_set(4, "up", True)
- instance.connect(2, "devs", 4, "node")
- instance.add_address(4, "10.0.0.1", 24, None)
- instance.create(5, "NodeInterface")
- instance.create_set(5, "up", True)
- instance.connect(3, "devs", 5, "node")
- instance.add_address(5, "10.0.0.2", 24, None)
- instance.create(6, "Switch")
- instance.create_set(6, "up", True)
- instance.connect(4, "switch", 6, "devs")
- instance.connect(5, "switch", 6, "devs")
- instance.create(7, "Application")
- instance.create_set(7, "command", "ping -qc1 10.0.0.2")
- instance.create_set(7, "user", user)
- instance.add_trace(7, "stdout")
- instance.connect(7, "node", 2, "apps")
+ instance.defer_configure("homeDirectory", self.root_dir)
+ instance.defer_create(2, "Node")
+ instance.defer_create(3, "Node")
+ instance.defer_create(4, "NodeInterface")
+ instance.defer_create_set(4, "up", True)
+ instance.defer_connect(2, "devs", 4, "node")
+ instance.defer_add_address(4, "10.0.0.1", 24, None)
+ instance.defer_create(5, "NodeInterface")
+ instance.defer_create_set(5, "up", True)
+ instance.defer_connect(3, "devs", 5, "node")
+ instance.defer_add_address(5, "10.0.0.2", 24, None)
+ instance.defer_create(6, "Switch")
+ instance.defer_create_set(6, "up", True)
+ instance.defer_connect(4, "switch", 6, "devs")
+ instance.defer_connect(5, "switch", 6, "devs")
+ instance.defer_create(7, "Application")
+ instance.defer_create_set(7, "command", "ping -qc1 10.0.0.2")
+ instance.defer_create_set(7, "user", user)
+ instance.defer_add_trace(7, "stdout")
+ instance.defer_connect(7, "node", 2, "apps")
instance.do_setup()
instance.do_create()
user = getpass.getuser()
testbed_version = "01"
instance = netns.TestbedInstance(testbed_version)
- instance.configure("homeDirectory", self.root_dir)
- instance.create(2, "Node")
- instance.create(3, "Node")
- instance.create(4, "P2PNodeInterface")
- instance.create_set(4, "up", True)
- instance.connect(2, "devs", 4, "node")
- instance.add_address(4, "10.0.0.1", 24, None)
- instance.create(5, "P2PNodeInterface")
- instance.create_set(5, "up", True)
- instance.connect(3, "devs", 5, "node")
- instance.add_address(5, "10.0.0.2", 24, None)
- instance.connect(4, "p2p", 5, "p2p")
- instance.create(6, "Application")
- instance.create_set(6, "command", "ping -qc1 10.0.0.2")
- instance.create_set(6, "user", user)
- instance.add_trace(6, "stdout")
- instance.connect(6, "node", 2, "apps")
+ instance.defer_configure("homeDirectory", self.root_dir)
+ instance.defer_create(2, "Node")
+ instance.defer_create(3, "Node")
+ instance.defer_create(4, "P2PNodeInterface")
+ instance.defer_create_set(4, "up", True)
+ instance.defer_connect(2, "devs", 4, "node")
+ instance.defer_add_address(4, "10.0.0.1", 24, None)
+ instance.defer_create(5, "P2PNodeInterface")
+ instance.defer_create_set(5, "up", True)
+ instance.defer_connect(3, "devs", 5, "node")
+ instance.defer_add_address(5, "10.0.0.2", 24, None)
+ instance.defer_connect(4, "p2p", 5, "p2p")
+ instance.defer_create(6, "Application")
+ instance.defer_create_set(6, "command", "ping -qc1 10.0.0.2")
+ instance.defer_create_set(6, "user", user)
+ instance.defer_add_trace(6, "stdout")
+ instance.defer_connect(6, "node", 2, "apps")
instance.do_setup()
instance.do_create()
user = getpass.getuser()
testbed_version = "01"
instance = netns.TestbedInstance(testbed_version)
- instance.configure("homeDirectory", self.root_dir)
- instance.create(2, "Node")
- instance.create(3, "Node")
- instance.create(4, "Node")
- instance.create(5, "NodeInterface")
- instance.create_set(5, "up", True)
- instance.connect(2, "devs", 5, "node")
- instance.add_address(5, "10.0.0.1", 24, None)
- instance.create(6, "NodeInterface")
- instance.create_set(6, "up", True)
- instance.connect(3, "devs", 6, "node")
- instance.add_address(6, "10.0.0.2", 24, None)
- instance.create(7, "NodeInterface")
- instance.create_set(7, "up", True)
- instance.connect(3, "devs", 7, "node")
- instance.add_address(7, "10.0.1.1", 24, None)
- instance.create(8, "NodeInterface")
- instance.create_set(8, "up", True)
- instance.connect(4, "devs", 8, "node")
- instance.add_address(8, "10.0.1.2", 24, None)
- instance.create(9, "Switch")
- instance.create_set(9, "up", True)
- instance.connect(5, "switch", 9, "devs")
- instance.connect(6, "switch", 9, "devs")
- instance.create(10, "Switch")
- instance.create_set(10, "up", True)
- instance.connect(7, "switch", 10, "devs")
- instance.connect(8, "switch", 10, "devs")
- instance.create(11, "Application")
- instance.create_set(11, "command", "ping -qc1 10.0.1.2")
- instance.create_set(11, "user", user)
- instance.add_trace(11, "stdout")
- instance.connect(11, "node", 2, "apps")
+ instance.defer_configure("homeDirectory", self.root_dir)
+ instance.defer_create(2, "Node")
+ instance.defer_create(3, "Node")
+ instance.defer_create(4, "Node")
+ instance.defer_create(5, "NodeInterface")
+ instance.defer_create_set(5, "up", True)
+ instance.defer_connect(2, "devs", 5, "node")
+ instance.defer_add_address(5, "10.0.0.1", 24, None)
+ instance.defer_create(6, "NodeInterface")
+ instance.defer_create_set(6, "up", True)
+ instance.defer_connect(3, "devs", 6, "node")
+ instance.defer_add_address(6, "10.0.0.2", 24, None)
+ instance.defer_create(7, "NodeInterface")
+ instance.defer_create_set(7, "up", True)
+ instance.defer_connect(3, "devs", 7, "node")
+ instance.defer_add_address(7, "10.0.1.1", 24, None)
+ instance.defer_create(8, "NodeInterface")
+ instance.defer_create_set(8, "up", True)
+ instance.defer_connect(4, "devs", 8, "node")
+ instance.defer_add_address(8, "10.0.1.2", 24, None)
+ instance.defer_create(9, "Switch")
+ instance.defer_create_set(9, "up", True)
+ instance.defer_connect(5, "switch", 9, "devs")
+ instance.defer_connect(6, "switch", 9, "devs")
+ instance.defer_create(10, "Switch")
+ instance.defer_create_set(10, "up", True)
+ instance.defer_connect(7, "switch", 10, "devs")
+ instance.defer_connect(8, "switch", 10, "devs")
+ instance.defer_create(11, "Application")
+ instance.defer_create_set(11, "command", "ping -qc1 10.0.1.2")
+ instance.defer_create_set(11, "user", user)
+ instance.defer_add_trace(11, "stdout")
+ instance.defer_connect(11, "node", 2, "apps")
- instance.add_route(2, "10.0.1.0", 24, "10.0.0.2")
- instance.add_route(4, "10.0.0.0", 24, "10.0.1.1")
+ instance.defer_add_route(2, "10.0.1.0", 24, "10.0.0.2")
+ instance.defer_add_route(4, "10.0.0.0", 24, "10.0.1.1")
instance.do_setup()
instance.do_create()
def test_run_ping_if(self):
testbed_version = "3_9_RC3"
instance = ns3.TestbedInstance(testbed_version)
- instance.configure("homeDirectory", self.root_dir)
- instance.create(2, "ns3::Node")
- instance.create(3, "ns3::Ipv4L3Protocol")
- instance.create(4, "ns3::ArpL3Protocol")
- instance.create(5, "ns3::Icmpv4L4Protocol")
- instance.create(6, "ns3::UdpL4Protocol")
- instance.connect(2, "protos", 3, "node")
- instance.connect(2, "protos", 4, "node")
- instance.connect(2, "protos", 5, "node")
- instance.connect(2, "protos", 6, "node")
- instance.create(7, "ns3::PointToPointNetDevice")
- instance.create(8, "ns3::DropTailQueue")
- instance.connect(2, "devs", 7, "node")
- instance.connect(7, "queue", 8, "dev")
- instance.add_trace(7, "P2PAsciiTrace")
- instance.add_address(7, "10.0.0.1", 24, None)
+ instance.defer_configure("homeDirectory", self.root_dir)
+ instance.defer_create(2, "ns3::Node")
+ instance.defer_create(3, "ns3::Ipv4L3Protocol")
+ instance.defer_create(4, "ns3::ArpL3Protocol")
+ instance.defer_create(5, "ns3::Icmpv4L4Protocol")
+ instance.defer_create(6, "ns3::UdpL4Protocol")
+ instance.defer_connect(2, "protos", 3, "node")
+ instance.defer_connect(2, "protos", 4, "node")
+ instance.defer_connect(2, "protos", 5, "node")
+ instance.defer_connect(2, "protos", 6, "node")
+ instance.defer_create(7, "ns3::PointToPointNetDevice")
+ instance.defer_create(8, "ns3::DropTailQueue")
+ instance.defer_connect(2, "devs", 7, "node")
+ instance.defer_connect(7, "queue", 8, "dev")
+ instance.defer_add_trace(7, "P2PAsciiTrace")
+ instance.defer_add_address(7, "10.0.0.1", 24, None)
- instance.create(9, "ns3::Node")
- instance.create(10, "ns3::Ipv4L3Protocol")
- instance.create(11, "ns3::ArpL3Protocol")
- instance.create(12, "ns3::Icmpv4L4Protocol")
- instance.create(13, "ns3::UdpL4Protocol")
- instance.connect(9, "protos", 10, "node")
- instance.connect(9, "protos", 11, "node")
- instance.connect(9, "protos", 12, "node")
- instance.connect(9, "protos", 13, "node")
- instance.create(14, "ns3::PointToPointNetDevice")
- instance.create(15, "ns3::DropTailQueue")
- instance.connect(9, "devs", 14, "node")
- instance.connect(14, "queue", 15, "dev")
- instance.add_trace(14, "P2PAsciiTrace")
- instance.add_address(14, "10.0.0.2", 24, None)
+ instance.defer_create(9, "ns3::Node")
+ instance.defer_create(10, "ns3::Ipv4L3Protocol")
+ instance.defer_create(11, "ns3::ArpL3Protocol")
+ instance.defer_create(12, "ns3::Icmpv4L4Protocol")
+ instance.defer_create(13, "ns3::UdpL4Protocol")
+ instance.defer_connect(9, "protos", 10, "node")
+ instance.defer_connect(9, "protos", 11, "node")
+ instance.defer_connect(9, "protos", 12, "node")
+ instance.defer_connect(9, "protos", 13, "node")
+ instance.defer_create(14, "ns3::PointToPointNetDevice")
+ instance.defer_create(15, "ns3::DropTailQueue")
+ instance.defer_connect(9, "devs", 14, "node")
+ instance.defer_connect(14, "queue", 15, "dev")
+ instance.defer_add_trace(14, "P2PAsciiTrace")
+ instance.defer_add_address(14, "10.0.0.2", 24, None)
- instance.create(16, "ns3::PointToPointChannel")
- instance.connect(7, "chan", 16, "dev2")
- instance.connect(14, "chan", 16, "dev2")
+ instance.defer_create(16, "ns3::PointToPointChannel")
+ instance.defer_connect(7, "chan", 16, "dev2")
+ instance.defer_connect(14, "chan", 16, "dev2")
- instance.create(17, "ns3::V4Ping")
- instance.create_set(17, "Remote", "10.0.0.2")
- instance.create_set(17, "StartTime", "0s")
- instance.create_set(17, "StopTime", "10s")
- instance.connect(17, "node", 2, "apps")
+ instance.defer_create(17, "ns3::V4Ping")
+ instance.defer_create_set(17, "Remote", "10.0.0.2")
+ instance.defer_create_set(17, "StartTime", "0s")
+ instance.defer_create_set(17, "StopTime", "10s")
+ instance.defer_connect(17, "node", 2, "apps")
instance.do_setup()
instance.do_create()
def test_run_ping_routing(self):
testbed_version = "3_9_RC3"
instance = ns3.TestbedInstance(testbed_version)
- instance.configure("homeDirectory", self.root_dir)
- instance.create(2, "ns3::Node")
- instance.create(3, "ns3::Ipv4L3Protocol")
- instance.create(4, "ns3::ArpL3Protocol")
- instance.create(5, "ns3::Icmpv4L4Protocol")
- instance.create(6, "ns3::UdpL4Protocol")
- instance.connect(2, "protos", 3, "node")
- instance.connect(2, "protos", 4, "node")
- instance.connect(2, "protos", 5, "node")
- instance.connect(2, "protos", 6, "node")
- instance.create(7, "ns3::PointToPointNetDevice")
- instance.create(8, "ns3::DropTailQueue")
- instance.connect(2, "devs", 7, "node")
- instance.connect(7, "queue", 8, "dev")
- instance.add_trace(7, "P2PAsciiTrace")
- instance.add_address(7, "10.0.0.1", 24, None)
+ instance.defer_configure("homeDirectory", self.root_dir)
+ instance.defer_create(2, "ns3::Node")
+ instance.defer_create(3, "ns3::Ipv4L3Protocol")
+ instance.defer_create(4, "ns3::ArpL3Protocol")
+ instance.defer_create(5, "ns3::Icmpv4L4Protocol")
+ instance.defer_create(6, "ns3::UdpL4Protocol")
+ instance.defer_connect(2, "protos", 3, "node")
+ instance.defer_connect(2, "protos", 4, "node")
+ instance.defer_connect(2, "protos", 5, "node")
+ instance.defer_connect(2, "protos", 6, "node")
+ instance.defer_create(7, "ns3::PointToPointNetDevice")
+ instance.defer_create(8, "ns3::DropTailQueue")
+ instance.defer_connect(2, "devs", 7, "node")
+ instance.defer_connect(7, "queue", 8, "dev")
+ instance.defer_add_trace(7, "P2PAsciiTrace")
+ instance.defer_add_address(7, "10.0.0.1", 24, None)
- instance.create(9, "ns3::Node")
- instance.create(10, "ns3::Ipv4L3Protocol")
- instance.create(11, "ns3::ArpL3Protocol")
- instance.create(12, "ns3::Icmpv4L4Protocol")
- instance.create(13, "ns3::UdpL4Protocol")
- instance.connect(9, "protos", 10, "node")
- instance.connect(9, "protos", 11, "node")
- instance.connect(9, "protos", 12, "node")
- instance.connect(9, "protos", 13, "node")
- instance.create(14, "ns3::PointToPointNetDevice")
- instance.create(15, "ns3::DropTailQueue")
- instance.connect(9, "devs", 14, "node")
- instance.connect(14, "queue", 15, "dev")
- instance.add_trace(14, "P2PAsciiTrace")
- instance.add_address(14, "10.0.0.2", 24, None)
+ instance.defer_create(9, "ns3::Node")
+ instance.defer_create(10, "ns3::Ipv4L3Protocol")
+ instance.defer_create(11, "ns3::ArpL3Protocol")
+ instance.defer_create(12, "ns3::Icmpv4L4Protocol")
+ instance.defer_create(13, "ns3::UdpL4Protocol")
+ instance.defer_connect(9, "protos", 10, "node")
+ instance.defer_connect(9, "protos", 11, "node")
+ instance.defer_connect(9, "protos", 12, "node")
+ instance.defer_connect(9, "protos", 13, "node")
+ instance.defer_create(14, "ns3::PointToPointNetDevice")
+ instance.defer_create(15, "ns3::DropTailQueue")
+ instance.defer_connect(9, "devs", 14, "node")
+ instance.defer_connect(14, "queue", 15, "dev")
+ instance.defer_add_trace(14, "P2PAsciiTrace")
+ instance.defer_add_address(14, "10.0.0.2", 24, None)
- instance.create(16, "ns3::PointToPointChannel")
- instance.connect(7, "chan", 16, "dev2")
- instance.connect(14, "chan", 16, "dev2")
+ instance.defer_create(16, "ns3::PointToPointChannel")
+ instance.defer_connect(7, "chan", 16, "dev2")
+ instance.defer_connect(14, "chan", 16, "dev2")
- instance.create(17, "ns3::PointToPointNetDevice")
- instance.create(18, "ns3::DropTailQueue")
- instance.connect(9, "devs", 17, "node")
- instance.connect(17, "queue", 18, "dev")
- instance.add_trace(17, "P2PAsciiTrace")
- instance.add_address(17, "10.0.1.1", 24, None)
+ instance.defer_create(17, "ns3::PointToPointNetDevice")
+ instance.defer_create(18, "ns3::DropTailQueue")
+ instance.defer_connect(9, "devs", 17, "node")
+ instance.defer_connect(17, "queue", 18, "dev")
+ instance.defer_add_trace(17, "P2PAsciiTrace")
+ instance.defer_add_address(17, "10.0.1.1", 24, None)
- instance.create(19, "ns3::Node")
- instance.create(20, "ns3::Ipv4L3Protocol")
- instance.create(21, "ns3::ArpL3Protocol")
- instance.create(22, "ns3::Icmpv4L4Protocol")
- instance.create(23, "ns3::UdpL4Protocol")
- instance.connect(19, "protos", 20, "node")
- instance.connect(19, "protos", 21, "node")
- instance.connect(19, "protos", 22, "node")
- instance.connect(19, "protos", 23, "node")
- instance.create(24, "ns3::PointToPointNetDevice")
- instance.create(25, "ns3::DropTailQueue")
- instance.connect(19, "devs", 24, "node")
- instance.connect(24, "queue", 25, "dev")
- instance.add_trace(24, "P2PAsciiTrace")
- instance.add_address(24, "10.0.1.2", 24, None)
+ instance.defer_create(19, "ns3::Node")
+ instance.defer_create(20, "ns3::Ipv4L3Protocol")
+ instance.defer_create(21, "ns3::ArpL3Protocol")
+ instance.defer_create(22, "ns3::Icmpv4L4Protocol")
+ instance.defer_create(23, "ns3::UdpL4Protocol")
+ instance.defer_connect(19, "protos", 20, "node")
+ instance.defer_connect(19, "protos", 21, "node")
+ instance.defer_connect(19, "protos", 22, "node")
+ instance.defer_connect(19, "protos", 23, "node")
+ instance.defer_create(24, "ns3::PointToPointNetDevice")
+ instance.defer_create(25, "ns3::DropTailQueue")
+ instance.defer_connect(19, "devs", 24, "node")
+ instance.defer_connect(24, "queue", 25, "dev")
+ instance.defer_add_trace(24, "P2PAsciiTrace")
+ instance.defer_add_address(24, "10.0.1.2", 24, None)
- instance.create(26, "ns3::PointToPointChannel")
- instance.connect(17, "chan", 26, "dev2")
- instance.connect(24, "chan", 26, "dev2")
+ instance.defer_create(26, "ns3::PointToPointChannel")
+ instance.defer_connect(17, "chan", 26, "dev2")
+ instance.defer_connect(24, "chan", 26, "dev2")
- instance.create(27, "ns3::V4Ping")
- instance.create_set(27, "Remote", "10.0.1.2")
- instance.create_set(27, "StartTime", "0s")
- instance.create_set(27, "StopTime", "10s")
- instance.connect(27, "node", 2, "apps")
+ instance.defer_create(27, "ns3::V4Ping")
+ instance.defer_create_set(27, "Remote", "10.0.1.2")
+ instance.defer_create_set(27, "StartTime", "0s")
+ instance.defer_create_set(27, "StopTime", "10s")
+ instance.defer_connect(27, "node", 2, "apps")
- instance.add_route(2, "10.0.1.0", 24, "10.0.0.2")
- instance.add_route(19, "10.0.0.0", 24, "10.0.1.1")
+ instance.defer_add_route(2, "10.0.1.0", 24, "10.0.0.2")
+ instance.defer_add_route(19, "10.0.0.0", 24, "10.0.1.1")
instance.do_setup()
instance.do_create()
git://git.onelab.eu / nepi.git / commitdiff