Update OSAPI v1.1 extensions so that it supports RequestExtensions. ResponseExtensions were removed since the new RequestExtension covers both use cases. This branch also removes some of the odd serialization code in the RequestExtensionController that converted dictionary objects into webob objects. RequestExtension handlers should now always return proper webob objects.

3 files changed, 73 insertions, 82 deletions

diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index 7ea7afef6..8e77b25fb 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -105,15 +105,14 @@ class ExtensionDescriptor(object):
         actions = []
         return actions
 
-    def get_response_extensions(self):
-        """List of extensions.ResponseExtension extension objects.
+    def get_request_extensions(self):
+        """List of extensions.RequestException extension objects.
 
-        Response extensions are used to insert information into existing
-        response data.
+        Request extensions are used to handle custom request data.
 
         """
-        response_exts = []
-        return response_exts
+        request_exts = []
+        return request_exts
 
 
 class ActionExtensionController(common.OpenstackController):
@@ -137,7 +136,7 @@ class ActionExtensionController(common.OpenstackController):
         return res
 
 
-class ResponseExtensionController(common.OpenstackController):
+class RequestExtensionController(common.OpenstackController):
 
     def __init__(self, application):
         self.application = application
@@ -148,20 +147,9 @@ class ResponseExtensionController(common.OpenstackController):
 
     def process(self, req, *args, **kwargs):
         res = req.get_response(self.application)
-        content_type = req.best_match_content_type()
-        # currently response handlers are un-ordered
+        # currently request handlers are un-ordered
         for handler in self.handlers:
-            res = handler(res)
-            try:
-                body = res.body
-                headers = res.headers
-            except AttributeError:
-                default_xmlns = None
-                body = self._serialize(res, content_type, default_xmlns)
-                headers = {"Content-Type": content_type}
-            res = webob.Response()
-            res.body = body
-            res.headers = headers
+            res = handler(req, res)
         return res
 
 
@@ -226,24 +214,24 @@ class ExtensionMiddleware(wsgi.Middleware):
 
         return action_controllers
 
-    def _response_ext_controllers(self, application, ext_mgr, mapper):
-        """Returns a dict of ResponseExtensionController-s by collection."""
-        response_ext_controllers = {}
-        for resp_ext in ext_mgr.get_response_extensions():
-            if not resp_ext.key in response_ext_controllers.keys():
-                controller = ResponseExtensionController(application)
-                mapper.connect(resp_ext.url_route + '.:(format)',
+    def _request_ext_controllers(self, application, ext_mgr, mapper):
+        """Returns a dict of RequestExtensionController-s by collection."""
+        request_ext_controllers = {}
+        for req_ext in ext_mgr.get_request_extensions():
+            if not req_ext.key in request_ext_controllers.keys():
+                controller = RequestExtensionController(application)
+                mapper.connect(req_ext.url_route + '.:(format)',
                                 action='process',
                                 controller=controller,
-                                conditions=resp_ext.conditions)
+                                conditions=req_ext.conditions)
 
-                mapper.connect(resp_ext.url_route,
+                mapper.connect(req_ext.url_route,
                                 action='process',
                                 controller=controller,
-                                conditions=resp_ext.conditions)
-                response_ext_controllers[resp_ext.key] = controller
+                                conditions=req_ext.conditions)
+                request_ext_controllers[req_ext.key] = controller
 
-        return response_ext_controllers
+        return request_ext_controllers
 
     def __init__(self, application, ext_mgr=None):
 
@@ -271,13 +259,13 @@ class ExtensionMiddleware(wsgi.Middleware):
             controller = action_controllers[action.collection]
             controller.add_action(action.action_name, action.handler)
 
-        # extended responses
-        resp_controllers = self._response_ext_controllers(application, ext_mgr,
+        # extended requests
+        req_controllers = self._request_ext_controllers(application, ext_mgr,
                                                             mapper)
-        for response_ext in ext_mgr.get_response_extensions():
-            LOG.debug(_('Extended response: %s'), response_ext.key)
-            controller = resp_controllers[response_ext.key]
-            controller.add_handler(response_ext.handler)
+        for request_ext in ext_mgr.get_request_extensions():
+            LOG.debug(_('Extended request: %s'), request_ext.key)
+            controller = req_controllers[request_ext.key]
+            controller.add_handler(request_ext.handler)
 
         self._router = routes.middleware.RoutesMiddleware(self._dispatch,
                                                           mapper)
@@ -347,17 +335,17 @@ class ExtensionManager(object):
                 pass
         return actions
 
-    def get_response_extensions(self):
-        """Returns a list of ResponseExtension objects."""
-        response_exts = []
+    def get_request_extensions(self):
+        """Returns a list of RequestExtension objects."""
+        request_exts = []
         for alias, ext in self.extensions.iteritems():
             try:
-                response_exts.extend(ext.get_response_extensions())
+                request_exts.extend(ext.get_request_extensions())
             except AttributeError:
-                # NOTE(dprince): Extension aren't required to have response
+                # NOTE(dprince): Extension aren't required to have request
                 # extensions
                 pass
-        return response_exts
+        return request_exts
 
     def _check_extension(self, extension):
         """Checks for required methods in extension objects."""
@@ -421,9 +409,13 @@ class ExtensionManager(object):
         self.extensions[alias] = ext
 
 
-class ResponseExtension(object):
-    """Add data to responses from core nova OpenStack API controllers."""
+class RequestExtension(object):
+    """Extend requests and responses of core nova OpenStack API controllers.
 
+    Provide a way to add data to responses and handle custom request data
+    that is sent to core nova OpenStack API controllers.
+
+    """
     def __init__(self, method, url_route, handler):
         self.url_route = url_route
         self.handler = handler
diff --git a/nova/tests/api/openstack/extensions/foxinsocks.py b/nova/tests/api/openstack/extensions/foxinsocks.py
index 0860b51ac..dbdd0928a 100644
--- a/nova/tests/api/openstack/extensions/foxinsocks.py
+++ b/nova/tests/api/openstack/extensions/foxinsocks.py
@@ -63,31 +63,33 @@ class Foxinsocks(object):
                                                     self._delete_tweedle))
         return actions
 
-    def get_response_extensions(self):
-        response_exts = []
+    def get_request_extensions(self):
+        request_exts = []
 
-        def _goose_handler(res):
+        def _goose_handler(req, res):
             #NOTE: This only handles JSON responses.
             # You can use content type header to test for XML.
             data = json.loads(res.body)
-            data['flavor']['googoose'] = "Gooey goo for chewy chewing!"
-            return data
+            data['flavor']['googoose'] = req.GET.get('chewing')
+            res.body = json.dumps(data)
+            return res
 
-        resp_ext = extensions.ResponseExtension('GET', '/v1.1/flavors/:(id)',
+        req_ext1 = extensions.RequestExtension('GET', '/v1.1/flavors/:(id)',
                                                 _goose_handler)
-        response_exts.append(resp_ext)
+        request_exts.append(req_ext1)
 
-        def _bands_handler(res):
+        def _bands_handler(req, res):
             #NOTE: This only handles JSON responses.
             # You can use content type header to test for XML.
             data = json.loads(res.body)
             data['big_bands'] = 'Pig Bands!'
-            return data
+            res.body = json.dumps(data)
+            return res
 
-        resp_ext2 = extensions.ResponseExtension('GET', '/v1.1/flavors/:(id)',
+        req_ext2 = extensions.RequestExtension('GET', '/v1.1/flavors/:(id)',
                                                 _bands_handler)
-        response_exts.append(resp_ext2)
-        return response_exts
+        request_exts.append(req_ext2)
+        return request_exts
 
     def _add_tweedle(self, input_dict, req, id):
 
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 481d34ed1..544298602 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -45,10 +45,10 @@ class StubController(nova.wsgi.Controller):
 
 class StubExtensionManager(object):
 
-    def __init__(self, resource_ext=None, action_ext=None, response_ext=None):
+    def __init__(self, resource_ext=None, action_ext=None, request_ext=None):
         self.resource_ext = resource_ext
         self.action_ext = action_ext
-        self.response_ext = response_ext
+        self.request_ext = request_ext
 
     def get_name(self):
         return "Tweedle Beetle Extension"
@@ -71,11 +71,11 @@ class StubExtensionManager(object):
             action_exts.append(self.action_ext)
         return action_exts
 
-    def get_response_extensions(self):
-        response_exts = []
-        if self.response_ext:
-            response_exts.append(self.response_ext)
-        return response_exts
+    def get_request_extensions(self):
+        request_extensions = []
+        if self.request_ext:
+            request_extensions.append(self.request_ext)
+        return request_extensions
 
 
 class ExtensionControllerTest(unittest.TestCase):
@@ -183,10 +183,10 @@ class ActionExtensionTest(unittest.TestCase):
         self.assertEqual(404, response.status_int)
 
 
-class ResponseExtensionTest(unittest.TestCase):
+class RequestExtensionTest(unittest.TestCase):
 
     def setUp(self):
-        super(ResponseExtensionTest, self).setUp()
+        super(RequestExtensionTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
         fakes.FakeAuthManager.reset_fake_data()
         fakes.FakeAuthDatabase.data = {}
@@ -195,42 +195,39 @@ class ResponseExtensionTest(unittest.TestCase):
 
     def tearDown(self):
         self.stubs.UnsetAll()
-        super(ResponseExtensionTest, self).tearDown()
+        super(RequestExtensionTest, self).tearDown()
 
     def test_get_resources_with_stub_mgr(self):
 
-        test_resp = "Gooey goo for chewy chewing!"
-
-        def _resp_handler(res):
+        def _req_handler(req, res):
             # only handle JSON responses
             data = json.loads(res.body)
-            data['flavor']['googoose'] = test_resp
-            return data
+            data['flavor']['googoose'] = req.GET.get('chewing')
+            res.body = json.dumps(data)
+            return res
 
-        resp_ext = extensions.ResponseExtension('GET',
+        req_ext = extensions.RequestExtension('GET',
                                                 '/v1.1/flavors/:(id)',
-                                                _resp_handler)
+                                                _req_handler)
 
-        manager = StubExtensionManager(None, None, resp_ext)
+        manager = StubExtensionManager(None, None, req_ext)
         app = fakes.wsgi_app()
         ext_midware = extensions.ExtensionMiddleware(app, manager)
-        request = webob.Request.blank("/v1.1/flavors/1")
+        request = webob.Request.blank("/v1.1/flavors/1?chewing=bluegoo")
         request.environ['api.version'] = '1.1'
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
         response_data = json.loads(response.body)
-        self.assertEqual(test_resp, response_data['flavor']['googoose'])
+        self.assertEqual('bluegoo', response_data['flavor']['googoose'])
 
     def test_get_resources_with_mgr(self):
 
-        test_resp = "Gooey goo for chewy chewing!"
-
         app = fakes.wsgi_app()
         ext_midware = extensions.ExtensionMiddleware(app)
-        request = webob.Request.blank("/v1.1/flavors/1")
+        request = webob.Request.blank("/v1.1/flavors/1?chewing=newblue")
         request.environ['api.version'] = '1.1'
         response = request.get_response(ext_midware)
         self.assertEqual(200, response.status_int)
         response_data = json.loads(response.body)
-        self.assertEqual(test_resp, response_data['flavor']['googoose'])
+        self.assertEqual('newblue', response_data['flavor']['googoose'])
         self.assertEqual("Pig Bands!", response_data['big_bands'])