From: Salvatore Orlando Date: Tue, 5 Jul 2011 16:50:30 +0000 (+0100) Subject: Adapated plugin infrastructure to allow API to pass options to plugins X-Git-Url: https://review.fuel-infra.org/gitweb?a=commitdiff_plain;h=8af12499a88d4c0892ded9003bb9848d7945589a;p=openstack-build%2Fneutron-build.git Adapated plugin infrastructure to allow API to pass options to plugins Now using in-memory sqlite db for tests on FakePlugin teardown() now 'resets' the in-memory db Adding unit tests for APIs --- 8af12499a88d4c0892ded9003bb9848d7945589a diff --cc quantum/api/__init__.py index 3bf7f113a,fc3476733..40dd058ba --- a/quantum/api/__init__.py +++ b/quantum/api/__init__.py @@@ -40,19 -41,20 +41,20 @@@ class APIRouterV01(wsgi.Router) Routes requests on the Quantum API to the appropriate controller """ -- def __init__(self, ext_mgr=None): ++ def __init__(self, options=None): mapper = routes.Mapper() -- self._setup_routes(mapper) ++ self._setup_routes(mapper, options) super(APIRouterV01, self).__init__(mapper) -- def _setup_routes(self, mapper): - ++ def _setup_routes(self, mapper, options): + # Loads the quantum plugin - plugin = manager.QuantumManager().get_plugin() ++ plugin = manager.QuantumManager(options).get_plugin() uri_prefix = '/tenants/{tenant_id}/' mapper.resource('network', 'networks', - controller=networks.Controller(), + controller=networks.Controller(plugin), path_prefix=uri_prefix) mapper.resource('port', 'ports', - controller=ports.Controller(), + controller=ports.Controller(plugin), parent_resource=dict(member_name='network', collection_name=uri_prefix +\ 'networks')) diff --cc quantum/api/networks.py index e629d40d5,e8d3db51b..b36e2edd9 --- a/quantum/api/networks.py +++ b/quantum/api/networks.py @@@ -78,9 -78,9 +78,9 @@@ class Controller(common.QuantumControll self._network_ops_param_list) except exc.HTTPError as e: return faults.Fault(e) - network = self.network_manager.\ + network = self._plugin.\ create_network(tenant_id, - request_params['network-name']) + request_params['net-name']) builder = networks_view.get_view_builder(request) result = builder.build(network) return dict(networks=result) diff --cc quantum/api/ports.py index 2a38fbe39,b2d4016e5..f9f39c400 --- a/quantum/api/ports.py +++ b/quantum/api/ports.py @@@ -141,9 -140,10 +141,7 @@@ class Controller(common.QuantumControll except exception.PortNotFound as e: return faults.Fault(faults.PortNotFound(e)) -- #TODO - Complete implementation of these APIs def attach_resource(self, request, tenant_id, network_id, id): -- content_type = request.best_match_content_type() - print "Content type:%s" % content_type try: request_params = \ self._parse_request_params(request, diff --cc quantum/common/utils.py index 3a2455963,3a2455963..ea6241e21 --- a/quantum/common/utils.py +++ b/quantum/common/utils.py @@@ -190,7 -190,7 +190,7 @@@ def parse_isotime(timestr) return datetime.datetime.strptime(timestr, TIME_FORMAT) --def getPluginFromConfig(file="config.ini"): ++def get_plugin_from_config(file="config.ini"): Config = ConfigParser.ConfigParser() Config.read(file) return Config.get("PLUGIN", "provider") diff --cc quantum/db/api.py index 898166110,59459cadb..212308e8f --- a/quantum/db/api.py +++ b/quantum/db/api.py @@@ -42,6 -42,6 +42,13 @@@ def configure_db(options) register_models() ++def unconfigure_db(): ++ unregister_models() ++ # Unset the engine ++ global _ENGINE ++ _ENGINE = None ++ ++ def get_session(autocommit=True, expire_on_commit=False): """Helper method to grab session""" global _MAKER, _ENGINE @@@ -72,10 -72,9 +79,10 @@@ def network_create(tenant_id, name) net = None try: net = session.query(models.Network).\ - filter_by(name=name, tenant_id=tenant_id).\ + filter_by(tenant_id=tenant_id, name=name).\ one() - raise Exception("Network with name \"%s\" already exists" % name) + raise Exception("Network with name %(name)s already " \ + "exists for tenant %(tenant_id)s" % locals()) except exc.NoResultFound: with session.begin(): net = models.Network(tenant_id, name) @@@ -155,25 -154,16 +162,26 @@@ def port_get(port_id) raise Exception("No port found with id = %s " % port_id) +def port_set_state(port_id, new_state): + port = port_get(port_id) + if port: + session = get_session() + port.state = new_state + session.merge(port) + session.flush() + return port + + def port_set_attachment(port_id, new_interface_id): session = get_session() - ports = None - try: - ports = session.query(models.Port).\ - filter_by(interface_id=new_interface_id).\ - all() - except exc.NoResultFound: - pass + ports = [] + if new_interface_id != "": + try: + ports = session.query(models.Port).\ + filter_by(interface_id=new_interface_id).\ + all() + except exc.NoResultFound: + pass if len(ports) == 0: port = port_get(port_id) port.interface_id = new_interface_id diff --cc quantum/manager.py index a42f15c68,6ab46d5fe..14b7f979c --- a/quantum/manager.py +++ b/quantum/manager.py @@@ -25,8 -25,8 +25,9 @@@ class The caller should make sure that QuantumManager is a singleton. """ import gettext +import logging import os + gettext.install('quantum', unicode=1) from common import utils @@@ -44,22 -43,21 +45,27 @@@ def find_config(basepath) class QuantumManager(object): -- def __init__(self, config=None): -- if config == None: ++ def __init__(self, options=None, config_file=None): ++ if config_file == None: self.configuration_file = find_config( os.path.abspath(os.path.dirname(__file__))) else: -- self.configuration_file = config -- plugin_location = utils.getPluginFromConfig(self.configuration_file) -- plugin_klass = utils.import_class(plugin_location) - LOG.debug("Plugin location:%s", plugin_location) ++ self.configuration_file = config_file ++ # If no options have been provided, create an empty dict ++ if not options: ++ options = {} ++ if not 'plugin_provider' in options: ++ options['plugin_provider'] = \ ++ utils.get_plugin_from_config(self.configuration_file) ++ LOG.debug("Plugin location:%s", options['plugin_provider']) ++ plugin_klass = utils.import_class(options['plugin_provider']) if not issubclass(plugin_klass, QuantumPluginBase): raise Exception("Configured Quantum plug-in " \ "didn't pass compatibility test") else: - print("Successfully imported Quantum plug-in." \ - "All compatibility tests passed\n") - self.plugin = plugin_klass() + LOG.debug("Successfully imported Quantum plug-in." \ + "All compatibility tests passed") - self.plugin = plugin_klass() ++ self.plugin = plugin_klass(options) - def get_manager(self): + def get_plugin(self): return self.plugin diff --cc quantum/plugins/SamplePlugin.py index 623042a12,376456a6c..1f2b1ce61 --- a/quantum/plugins/SamplePlugin.py +++ b/quantum/plugins/SamplePlugin.py @@@ -233,25 -227,45 +233,29 @@@ class FakePlugin(object) client/cli/api development """ - #static data for networks and ports - _port_dict_1 = { - 1: {'port-id': 1, - 'port-state': 'DOWN', - 'attachment': None}, - 2: {'port-id': 2, - 'port-state': 'UP', - 'attachment': None}} - _port_dict_2 = { - 1: {'port-id': 1, - 'port-state': 'UP', - 'attachment': 'SomeFormOfVIFID'}, - 2: {'port-id': 2, - 'port-state': 'DOWN', - 'attachment': None}} - _networks = {'001': - { - 'net-id': '001', - 'net-name': 'pippotest', - 'net-ports': _port_dict_1}, - '002': - { - 'net-id': '002', - 'net-name': 'cicciotest', - 'net-ports': _port_dict_2}} - -- def __init__(self): - db_options = {"sql_connection": "sqlite:///fake_plugin.sqllite"} - db.configure_db(db_options) - FakePlugin._net_counter = len(FakePlugin._networks) ++ def __init__(self, options): ++ # use supplied options for configuring db ++ if not options: ++ options = {"sql_connection": "sqlite:///fake_plugin.sqllite"} ++ elif not 'sql_connection' in options: ++ options['sql_connection'] = "sqlite:///fake_plugin.sqllite" ++ db.configure_db(options) + FakePlugin._net_counter = 0 def _get_network(self, tenant_id, network_id): - network = FakePlugin._networks.get(network_id) + network = db.network_get(network_id) if not network: raise exc.NetworkNotFound(net_id=network_id) return network def _get_port(self, tenant_id, network_id, port_id): net = self._get_network(tenant_id, network_id) - try: - port = net['net-ports'].get(int(port_id)) - if not port: ++ try: + port = db.port_get(port_id) + except: + raise exc.PortNotFound(net_id=network_id, port_id=port_id) + # Port must exist and belong to the appropriate network. + if port['network_id'] != net['uuid']: raise exc.PortNotFound(net_id=network_id, port_id=port_id) return port diff --cc quantum/quantum_plugin_base.py index 8e3f1f8e1,8e3f1f8e1..e82c55253 --- a/quantum/quantum_plugin_base.py +++ b/quantum/quantum_plugin_base.py @@@ -22,6 -22,6 +22,7 @@@ QuantumPluginBase provides the definiti methods that needs to be implemented by a Quantum Plug-in. """ ++import inspect from abc import ABCMeta, abstractmethod @@@ -29,6 -29,6 +30,14 @@@ class QuantumPluginBase(object) __metaclass__ = ABCMeta ++ @abstractmethod ++ def __init__(self, options): ++ """ ++ Initializes the Quantum plugin using provided options. ++ ++ """ ++ pass ++ @abstractmethod def get_all_networks(self, tenant_id): """ @@@ -242,7 -242,7 +251,17 @@@ """ if cls is QuantumPluginBase: for method in cls.__abstractmethods__: -- if any(method in base.__dict__ for base in klass.__mro__): ++ method_ok = False ++ for base in klass.__mro__: ++ if method in base.__dict__: ++ fn_obj = base.__dict__[method] ++ if inspect.isfunction(fn_obj): ++ abstract_fn_obj = cls.__dict__[method] ++ arg_count = fn_obj.func_code.co_argcount ++ expected_arg_count = \ ++ abstract_fn_obj.func_code.co_argcount ++ method_ok = arg_count == expected_arg_count ++ if method_ok: continue return NotImplemented return True diff --cc tests/unit/test_api.py index 6e4fe1960,000000000..f6997a2cf mode 100644,000000..100644 --- a/tests/unit/test_api.py +++ b/tests/unit/test_api.py @@@ -1,152 -1,0 +1,283 @@@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2010-2011 ???? +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# @author: Brad Hall, Nicira Networks +# @author: Salvatore Orlando, Citrix Systems + +import logging +import unittest + +import tests.unit.testlib as testlib + +from quantum import api as server ++from quantum.db import api as db +from quantum.common.wsgi import Serializer + - LOG = logging.getLogger('quantum.tests.test_api') - - - class APIPortsTest(unittest.TestCase): - def setUp(self): - self.api = server.APIRouterV01() - self.tenant_id = "test_tenant" - self.network_name = "test_network" - - def tearDown(self): - """Clear the test environment""" - # Remove all the networks. - network_req = testlib.create_network_list_request(self.tenant_id) - network_res = network_req.get_response(self.api) - network_data = Serializer().deserialize(network_res.body, - "application/xml") - for network in network_data["networks"].values(): - network_delete_req = testlib. \ - create_network_delete_request(self.tenant_id, network['id']) - network_delete_req.get_response(self.api) + +# Fault names copied here for reference +# +# _fault_names = { +# 400: "malformedRequest", +# 401: "unauthorized", +# 420: "networkNotFound", +# 421: "networkInUse", +# 430: "portNotFound", +# 431: "requestedStateInvalid", +# 432: "portInUse", +# 440: "alreadyAttached", +# 470: "serviceUnavailable", +# 471: "pluginFault"} + - def _test_delete_port(self, format): - LOG.debug("_test_delete_port - format:%s - START", format) ++ ++LOG = logging.getLogger('quantum.tests.test_api') ++ ++ ++class APITest(unittest.TestCase): ++ ++ def _create_network(self, format): ++ LOG.debug("Creating network") + content_type = "application/" + format - port_state = "ACTIVE" - LOG.debug("Creating network and port") - network_req = testlib.create_new_network_request(self.tenant_id, - self.network_name, - format) ++ network_req = testlib.new_network_request(self.tenant_id, ++ self.network_name, ++ format) + network_res = network_req.get_response(self.api) + self.assertEqual(network_res.status_int, 200) + network_data = Serializer().deserialize(network_res.body, + content_type) - network_id = network_data['networks']['network']['id'] - port_req = testlib.create_new_port_request(self.tenant_id, - network_id, port_state, - format) ++ return network_data['networks']['network']['id'] ++ ++ def _create_port(self, network_id, port_state, format): ++ LOG.debug("Creating port for network %s", network_id) ++ content_type = "application/%s" % format ++ port_req = testlib.new_port_request(self.tenant_id, network_id, ++ port_state, format) + port_res = port_req.get_response(self.api) + self.assertEqual(port_res.status_int, 200) + port_data = Serializer().deserialize(port_res.body, content_type) - port_id = port_data['ports']['port']['id'] ++ return port_data['ports']['port']['id'] ++ ++ def _test_create_network(self, format): ++ LOG.debug("_test_create_network - format:%s - START", format) ++ content_type = "application/%s" % format ++ network_id = self._create_network(format) ++ show_network_req = testlib.show_network_request(self.tenant_id, ++ network_id, ++ format) ++ show_network_res = show_network_req.get_response(self.api) ++ self.assertEqual(show_network_res.status_int, 200) ++ network_data = Serializer().deserialize(show_network_res.body, ++ content_type) ++ self.assertEqual(network_id, ++ network_data['networks']['network']['id']) ++ LOG.debug("_test_create_network - format:%s - END", format) ++ ++ def _test_show_network(self, format): ++ LOG.debug("_test_show_network - format:%s - START", format) ++ content_type = "application/%s" % format ++ network_id = self._create_network(format) ++ show_network_req = testlib.show_network_request(self.tenant_id, ++ network_id, ++ format) ++ show_network_res = show_network_req.get_response(self.api) ++ self.assertEqual(show_network_res.status_int, 200) ++ print show_network_res.body ++ network_data = Serializer().deserialize(show_network_res.body, ++ content_type) ++ self.assertEqual({'id': network_id, 'name': self.network_name}, ++ network_data['networks']['network']) ++ LOG.debug("_test_show_network - format:%s - END", format) ++ ++ def _test_delete_network(self, format): ++ LOG.debug("_test_delete_network - format:%s - START", format) ++ content_type = "application/%s" % format ++ network_id = self._create_network(format) ++ LOG.debug("Deleting network %(network_id)s"\ ++ " of tenant %(tenant_id)s", locals()) ++ delete_network_req = testlib.network_delete_request(self.tenant_id, ++ network_id, ++ format) ++ delete_network_res = delete_network_req.get_response(self.api) ++ self.assertEqual(delete_network_res.status_int, 202) ++ list_network_req = testlib.network_list_request(self.tenant_id, format) ++ list_network_res = list_network_req.get_response(self.api) ++ network_list_data = Serializer().deserialize(list_network_res.body, ++ content_type) ++ network_count = len(network_list_data['networks']) ++ self.assertEqual(network_count, 0) ++ LOG.debug("_test_delete_network - format:%s - END", format) ++ ++ def _test_delete_network_in_use(self, format): ++ LOG.debug("_test_delete_network_in_use - format:%s - START", format) ++ content_type = "application/%s" % format ++ port_state = "ACTIVE" ++ attachment_id = "test_attachment" ++ network_id = self._create_network(format) ++ LOG.debug("Deleting network %(network_id)s"\ ++ " of tenant %(tenant_id)s", locals()) ++ port_id = self._create_port(network_id, port_state, format) ++ #plug an attachment into the port ++ LOG.debug("Putting attachment into port %s", port_id) ++ attachment_req = testlib.put_attachment_request(self.tenant_id, ++ network_id, ++ port_id, ++ attachment_id) ++ attachment_res = attachment_req.get_response(self.api) ++ self.assertEquals(attachment_res.status_int, 202) ++ ++ LOG.debug("Deleting network %(network_id)s"\ ++ " of tenant %(tenant_id)s", locals()) ++ delete_network_req = testlib.network_delete_request(self.tenant_id, ++ network_id, ++ format) ++ delete_network_res = delete_network_req.get_response(self.api) ++ self.assertEqual(delete_network_res.status_int, 421) ++ LOG.debug("_test_delete_network_in_use - format:%s - END", format) ++ ++ def _test_create_port(self, format): ++ LOG.debug("_test_create_port - format:%s - START", format) ++ content_type = "application/%s" % format ++ port_state = "ACTIVE" ++ network_id = self._create_network(format) ++ port_id = self._create_port(network_id, port_state, format) ++ show_port_req = testlib.show_port_request(self.tenant_id, network_id, ++ port_id, format) ++ show_port_res = show_port_req.get_response(self.api) ++ self.assertEqual(show_port_res.status_int, 200) ++ port_data = Serializer().deserialize(show_port_res.body, content_type) ++ self.assertEqual(port_id, port_data['ports']['port']['id']) ++ LOG.debug("_test_create_port - format:%s - END", format) ++ ++ def _test_delete_port(self, format): ++ LOG.debug("_test_delete_port - format:%s - START", format) ++ content_type = "application/%s" % format ++ port_state = "ACTIVE" ++ network_id = self._create_network(format) ++ port_id = self._create_port(network_id, port_state, format) + LOG.debug("Deleting port %(port_id)s for network %(network_id)s"\ + " of tenant %(tenant_id)s", locals()) - delete_port_req = testlib.create_port_delete_request(self.tenant_id, - network_id, - port_id, - format) ++ delete_port_req = testlib.port_delete_request(self.tenant_id, ++ network_id, port_id, ++ format) + delete_port_res = delete_port_req.get_response(self.api) + self.assertEqual(delete_port_res.status_int, 202) - list_port_req = testlib.create_port_list_request(self.tenant_id, - network_id, - format) ++ list_port_req = testlib.port_list_request(self.tenant_id, network_id, ++ format) + list_port_res = list_port_req.get_response(self.api) + port_list_data = Serializer().deserialize(list_port_res.body, + content_type) + port_count = len(port_list_data['ports']) + self.assertEqual(port_count, 0) + LOG.debug("_test_delete_port - format:%s - END", format) + ++ def _test_delete_port_in_use(self, format): ++ LOG.debug("_test_delete_port_in_use - format:%s - START", format) ++ content_type = "application/" + format ++ port_state = "ACTIVE" ++ attachment_id = "test_attachment" ++ network_id = self._create_network(format) ++ port_id = self._create_port(network_id, port_state, format) ++ #plug an attachment into the port ++ LOG.debug("Putting attachment into port %s", port_id) ++ attachment_req = testlib.put_attachment_request(self.tenant_id, ++ network_id, ++ port_id, ++ attachment_id) ++ attachment_res = attachment_req.get_response(self.api) ++ self.assertEquals(attachment_res.status_int, 202) ++ LOG.debug("Deleting port %(port_id)s for network %(network_id)s"\ ++ " of tenant %(tenant_id)s", locals()) ++ delete_port_req = testlib.port_delete_request(self.tenant_id, ++ network_id, port_id, ++ format) ++ delete_port_res = delete_port_req.get_response(self.api) ++ self.assertEqual(delete_port_res.status_int, 432) ++ LOG.debug("_test_delete_port_in_use - format:%s - END", format) ++ pass ++ ++ def _test_delete_port_with_bad_id(self, format): ++ LOG.debug("_test_delete_port_with_bad_id - format:%s - START", format) ++ port_state = "ACTIVE" ++ network_id = self._create_network(format) ++ self._create_port(network_id, port_state, format) ++ # Test for portnotfound ++ delete_port_req = testlib.port_delete_request(self.tenant_id, ++ network_id, "A_BAD_ID", ++ format) ++ delete_port_res = delete_port_req.get_response(self.api) ++ self.assertEqual(delete_port_res.status_int, 430) ++ LOG.debug("_test_delete_port_with_bad_id - format:%s - END", format) ++ ++ def setUp(self): ++ self.db_file = ':memory' ++ options = {} ++ options['plugin_provider'] = 'quantum.plugins.SamplePlugin.FakePlugin' ++ options['sql_connection'] = 'sqlite:///%s' % self.db_file ++ self.api = server.APIRouterV01(options) ++ self.tenant_id = "test_tenant" ++ self.network_name = "test_network" ++ ++ def tearDown(self): ++ """Clear the test environment""" ++ # Unconfigure database engine ++ db.unconfigure_db() ++ ++ def test_create_network_json(self): ++ self._test_create_network('json') ++ ++ def test_create_network_xml(self): ++ self._test_create_network('xml') ++ ++ def test_show_network_json(self): ++ self._test_show_network('json') ++ ++ def test_show_network_xml(self): ++ self._test_show_network('xml') ++ ++ def test_delete_network_json(self): ++ self._test_delete_network('json') ++ ++ def test_delete_network_xml(self): ++ self._test_delete_network('xml') ++ ++ def test_delete_network_in_use_json(self): ++ self._test_delete_network_in_use('json') ++ ++ def test_delete_network_in_use_xml(self): ++ self._test_delete_network_in_use('xml') ++ ++ def test_create_port_json(self): ++ self._test_create_port('json') ++ ++ def test_create_port_xml(self): ++ self._test_create_port('xml') ++ + def test_delete_port_xml(self): + self._test_delete_port('xml') + + def test_delete_port_json(self): + self._test_delete_port('json') + - def _test_delete_port_in_use(self): - # Test for portinuse - #rv = self.port.create(req, tenant, network_id) - #port_id = rv["ports"]["port"]["id"] - #req = testlib.create_attachment_request(tenant, network_id, - # port_id, "fudd") - #rv = self.port.attach_resource(req, tenant, network_id, port_id) - #self.assertEqual(rv.status_int, 202) - #rv = self.port.delete("", tenant, network_id, port_id) - #self.assertEqual(rv.wrapped_exc.status_int, 432) - pass - ++ def test_delete_port_in_use_xml(self): ++ self._test_delete_port_in_use('xml') + - def _test_delete_port_with_bad_id(self,format): - LOG.debug("_test_delete_port - format:%s - START", format) - content_type = "application/" + format - port_state = "ACTIVE" - LOG.debug("Creating network and port") - network_req = testlib.create_new_network_request(self.tenant_id, - self.network_name, - format) - network_res = network_req.get_response(self.api) - self.assertEqual(network_res.status_int, 200) - network_data = Serializer().deserialize(network_res.body, - content_type) - network_id = network_data['networks']['network']['id'] - port_req = testlib.create_new_port_request(self.tenant_id, - network_id, port_state, - format) - port_res = port_req.get_response(self.api) - self.assertEqual(port_res.status_int, 200) ++ def test_delete_port_in_use_json(self): ++ self._test_delete_port_in_use('json') + - # Test for portnotfound - delete_port_req = testlib.create_port_delete_request(self.tenant_id, - network_id, - "A_BAD_ID", - format) - delete_port_res = delete_port_req.get_response(self.api) - self.assertEqual(delete_port_res.status_int, 430) - + def test_delete_port_with_bad_id_xml(self): - self._test_delete_port_wth_bad_id('xml') ++ self._test_delete_port_with_bad_id('xml') + + def test_delete_port_with_bad_id_json(self): + self._test_delete_port_with_bad_id('json') - diff --cc tests/unit/testlib.py index 024b8202a,000000000..c78c700cb mode 100644,000000..100644 --- a/tests/unit/testlib.py +++ b/tests/unit/testlib.py @@@ -1,71 -1,0 +1,89 @@@ +import webob + +from quantum.common.wsgi import Serializer + + +def create_request(path, body, content_type, method='GET'): + req = webob.Request.blank(path) + req.method = method + req.headers = {} + req.headers['Accept'] = content_type + req.body = body + return req + + - def create_network_list_request(tenant_id, format='xml'): ++def network_list_request(tenant_id, format='xml'): + method = 'GET' + path = "/tenants/%(tenant_id)s/networks.%(format)s" % locals() - content_type = "application/" + format ++ content_type = "application/%s" % format + return create_request(path, None, content_type, method) + + - def create_new_network_request(tenant_id, network_name, format='xml'): ++def show_network_request(tenant_id, network_id, format='xml'): ++ method = 'GET' ++ path = "/tenants/%(tenant_id)s/networks/" \ ++ "%(network_id)s.%(format)s" % locals() ++ content_type = "application/%s" % format ++ return create_request(path, None, content_type, method) ++ ++ ++def new_network_request(tenant_id, network_name, format='xml'): + method = 'POST' + path = "/tenants/%(tenant_id)s/networks.%(format)s" % locals() + data = {'network': {'net-name': '%s' % network_name}} - content_type = "application/" + format ++ content_type = "application/%s" % format + body = Serializer().serialize(data, content_type) + return create_request(path, body, content_type, method) + + - def create_network_delete_request(tenant_id, network_id, format='xml'): ++def network_delete_request(tenant_id, network_id, format='xml'): + method = 'DELETE' + path = "/tenants/%(tenant_id)s/networks/" \ + "%(network_id)s.%(format)s" % locals() - content_type = "application/" + format ++ content_type = "application/%s" % format + return create_request(path, None, content_type, method) + + - def create_port_list_request(tenant_id, network_id, format='xml'): ++def port_list_request(tenant_id, network_id, format='xml'): + method = 'GET' + path = "/tenants/%(tenant_id)s/networks/" \ + "%(network_id)s/ports.%(format)s" % locals() - content_type = "application/" + format ++ content_type = "application/%s" % format + return create_request(path, None, content_type, method) + + - def create_new_port_request(tenant_id, network_id, port_state, format='xml'): ++def show_port_request(tenant_id, network_id, port_id, format='xml'): ++ method = 'GET' ++ path = "/tenants/%(tenant_id)s/networks/%(network_id)s" \ ++ "/ports/%(port_id)s.%(format)s" % locals() ++ content_type = "application/%s" % format ++ return create_request(path, None, content_type, method) ++ ++ ++def new_port_request(tenant_id, network_id, port_state, format='xml'): + method = 'POST' + path = "/tenants/%(tenant_id)s/networks/" \ + "%(network_id)s/ports.%(format)s" % locals() + data = {'port': {'port-state': '%s' % port_state}} - content_type = "application/" + format ++ content_type = "application/%s" % format + body = Serializer().serialize(data, content_type) + return create_request(path, body, content_type, method) + + - def create_port_delete_request(tenant_id, network_id, port_id, format='xml'): ++def port_delete_request(tenant_id, network_id, port_id, format='xml'): + method = 'DELETE' + path = "/tenants/%(tenant_id)s/networks/" \ + "%(network_id)s/ports/%(port_id)s.%(format)s" % locals() - content_type = "application/" + format ++ content_type = "application/%s" % format + return create_request(path, None, content_type, method) + + - def create_attachment_request(tid, nid, pid, attachment_id): - path = "/v0.1/tenants/%s/networks/%s/ports/%s/attachment.json" % (tid, - nid, pid) ++def put_attachment_request(tenant_id, network_id, port_id, ++ attachment_id, format='xml'): ++ method = 'PUT' ++ path = "/tenants/%(tenant_id)s/networks/" \ ++ "%(network_id)s/ports/%(port_id)s/attachment.%(format)s" % locals() + data = {'port': {'attachment-id': attachment_id}} - content_type = "application/json" ++ content_type = "application/%s" % format + body = Serializer().serialize(data, content_type) - return create_request(path, body) ++ return create_request(path, body, content_type, method)