From: Claudio-Daniel Freire Date: Fri, 8 Apr 2011 14:09:11 +0000 (+0200) Subject: Ticket #9: rename create/create_set/add_x/configure/connect -> defer_x X-Git-Tag: nepi_v2~170 X-Git-Url: http://git.onelab.eu/?a=commitdiff_plain;h=a2cc7028377f93607cb36b85e904a8b92bc7d5f8;p=nepi.git Ticket #9: rename create/create_set/add_x/configure/connect -> defer_x --- diff --git a/src/nepi/core/execute.py b/src/nepi/core/execute.py index 857ebb53..12e9899c 100644 --- a/src/nepi/core/execute.py +++ b/src/nepi/core/execute.py @@ -167,37 +167,45 @@ class TestbedInstance(object): 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): @@ -205,13 +213,17 @@ class TestbedInstance(object): 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): @@ -219,8 +231,10 @@ class TestbedInstance(object): 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): @@ -303,7 +317,7 @@ class ExperimentController(object): 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) @@ -313,9 +327,9 @@ class ExperimentController(object): 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) @@ -326,17 +340,17 @@ class ExperimentController(object): (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) diff --git a/src/nepi/core/testbed_impl.py b/src/nepi/core/testbed_impl.py index f6698178..54df3195 100644 --- a/src/nepi/core/testbed_impl.py +++ b/src/nepi/core/testbed_impl.py @@ -45,14 +45,14 @@ class TestbedInstance(execute.TestbedInstance): 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)) @@ -61,7 +61,7 @@ class TestbedInstance(execute.TestbedInstance): 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] @@ -74,7 +74,7 @@ class TestbedInstance(execute.TestbedInstance): 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] @@ -87,7 +87,7 @@ class TestbedInstance(execute.TestbedInstance): 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] @@ -109,7 +109,7 @@ class TestbedInstance(execute.TestbedInstance): 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) @@ -125,7 +125,7 @@ class TestbedInstance(execute.TestbedInstance): (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] @@ -137,7 +137,7 @@ class TestbedInstance(execute.TestbedInstance): 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] @@ -155,7 +155,7 @@ class TestbedInstance(execute.TestbedInstance): 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] diff --git a/src/nepi/testbeds/planetlab/plcapi.py b/src/nepi/testbeds/planetlab/plcapi.py index a31e100e..4521e8cf 100644 --- a/src/nepi/testbeds/planetlab/plcapi.py +++ b/src/nepi/testbeds/planetlab/plcapi.py @@ -187,7 +187,7 @@ class PLCAPI(object): 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) diff --git a/src/nepi/util/proxy.py b/src/nepi/util/proxy.py index 784bf530..a83f2b82 100644 --- a/src/nepi/util/proxy.py +++ b/src/nepi/util/proxy.py @@ -300,23 +300,23 @@ class TestbedInstanceServer(server.Server): 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: @@ -355,10 +355,10 @@ class TestbedInstanceServer(server.Server): 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): @@ -380,41 +380,41 @@ class TestbedInstanceServer(server.Server): 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]) @@ -423,31 +423,31 @@ class TestbedInstanceServer(server.Server): 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): @@ -633,7 +633,7 @@ class TestbedInstanceProxy(object): 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 @@ -648,7 +648,7 @@ class TestbedInstanceProxy(object): 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) @@ -659,7 +659,7 @@ class TestbedInstanceProxy(object): 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 @@ -674,7 +674,7 @@ class TestbedInstanceProxy(object): 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 @@ -689,7 +689,7 @@ class TestbedInstanceProxy(object): 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, @@ -702,7 +702,7 @@ class TestbedInstanceProxy(object): 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, @@ -715,7 +715,7 @@ class TestbedInstanceProxy(object): 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) @@ -726,7 +726,7 @@ class TestbedInstanceProxy(object): 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) @@ -737,7 +737,7 @@ class TestbedInstanceProxy(object): 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) diff --git a/test/core/execute.py b/test/core/execute.py index 34ca0c9d..0c089a38 100755 --- a/test/core/execute.py +++ b/test/core/execute.py @@ -16,20 +16,20 @@ class ExecuteTestCase(unittest.TestCase): 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() diff --git a/test/testbeds/netns/execute.py b/test/testbeds/netns/execute.py index 148df22e..02f5138c 100755 --- a/test/testbeds/netns/execute.py +++ b/test/testbeds/netns/execute.py @@ -20,26 +20,26 @@ class NetnsExecuteTestCase(unittest.TestCase): 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() @@ -63,23 +63,23 @@ class NetnsExecuteTestCase(unittest.TestCase): 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() @@ -103,42 +103,42 @@ class NetnsExecuteTestCase(unittest.TestCase): 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() diff --git a/test/testbeds/ns3/execute.py b/test/testbeds/ns3/execute.py index d7a2a631..40ed1ddc 100755 --- a/test/testbeds/ns3/execute.py +++ b/test/testbeds/ns3/execute.py @@ -19,48 +19,48 @@ class Ns3ExecuteTestCase(unittest.TestCase): 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() diff --git a/test/testbeds/ns3/execute2.py b/test/testbeds/ns3/execute2.py index ae5f18a1..f59e61cd 100755 --- a/test/testbeds/ns3/execute2.py +++ b/test/testbeds/ns3/execute2.py @@ -25,78 +25,78 @@ class Ns3ExecuteTestCase(unittest.TestCase): 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()