Merge lp:~rackspace-titan/nova/wsgi-refactor into lp:~hudson-openstack/nova/trunk

[Brian Waldon]

Expanding OSAPI wsgi module to allow handling of headers and status codes

- Expanding OSAPI wsgi module to allow handling of headers and status codes
- Allows us to fix many of our OSAPI-related bugs efficiently:
    https://bugs.launchpad.net/nova/+bug/796709
    https://bugs.launchpad.net/nova/+bug/802656
    https://bugs.launchpad.net/nova/+bug/804087

[Josh Kearney (jk0)]

Changes look good and tests pass.

review: Approve

[Brian Lamar (blamar)]

After talking it through with Waldon I like the separation of serialization between body and headers. Serializing bodies shouldn't include HTTP codes/headers and vice versa. Passes all my tests and I'm looking forward to the other bug fixes using this branch. Thanks!

review: Approve

=== modified file 'nova/api/openstack/accounts.py'
--- nova/api/openstack/accounts.py	2011-05-20 18:42:19 +0000
+++ nova/api/openstack/accounts.py	2011-07-11 17:17:32 +0000
@@ -87,8 +87,8 @@
         },
     }
 
-    serializers = {
+    body_serializers = {
         'application/xml': wsgi.XMLDictSerializer(metadata=metadata),
     }
-
-    return wsgi.Resource(Controller(), serializers=serializers)
+    serializer = wsgi.ResponseSerializer(body_serializers)
+    return wsgi.Resource(Controller(), serializer=serializer)

=== modified file 'nova/api/openstack/backup_schedules.py'
--- nova/api/openstack/backup_schedules.py	2011-05-20 18:42:19 +0000
+++ nova/api/openstack/backup_schedules.py	2011-07-11 17:17:32 +0000
@@ -34,20 +34,20 @@
     def __init__(self):
         pass
 
-    def index(self, req, server_id):
+    def index(self, req, server_id, **kwargs):
         """ Returns the list of backup schedules for a given instance """
         return faults.Fault(exc.HTTPNotImplemented())
 
-    def show(self, req, server_id, id):
+    def show(self, req, server_id, id, **kwargs):
         """ Returns a single backup schedule for a given instance """
         return faults.Fault(exc.HTTPNotImplemented())
 
-    def create(self, req, server_id, body):
+    def create(self, req, server_id, **kwargs):
         """ No actual update method required, since the existing API allows
         both create and update through a POST """
         return faults.Fault(exc.HTTPNotImplemented())
 
-    def delete(self, req, server_id, id):
+    def delete(self, req, server_id, id, **kwargs):
         """ Deletes an existing backup schedule """
         return faults.Fault(exc.HTTPNotImplemented())
 
@@ -59,9 +59,10 @@
         },
     }
 
-    serializers = {
+    body_serializers = {
         'application/xml': wsgi.XMLDictSerializer(xmlns=wsgi.XMLNS_V10,
                                                   metadata=metadata),
     }
 
-    return wsgi.Resource(Controller(), serializers=serializers)
+    serializer = wsgi.ResponseSerializer(body_serializers)
+    return wsgi.Resource(Controller(), serializer=serializer)

=== modified file 'nova/api/openstack/consoles.py'
--- nova/api/openstack/consoles.py	2011-05-20 18:42:19 +0000
+++ nova/api/openstack/consoles.py	2011-07-11 17:17:32 +0000
@@ -90,14 +90,4 @@
 
 
 def create_resource():
-    metadata = {
-        'attributes': {
-            'console': [],
-        },
-    }
-
-    serializers = {
-        'application/xml': wsgi.XMLDictSerializer(metadata=metadata),
-    }
-
-    return wsgi.Resource(Controller(), serializers=serializers)
+    return wsgi.Resource(Controller())

=== modified file 'nova/api/openstack/contrib/floating_ips.py'
--- nova/api/openstack/contrib/floating_ips.py	2011-06-29 17:58:10 +0000
+++ nova/api/openstack/contrib/floating_ips.py	2011-07-11 17:17:32 +0000
@@ -78,7 +78,7 @@
 
         return _translate_floating_ips_view(floating_ips)
 
-    def create(self, req, body):
+    def create(self, req):
         context = req.environ['nova.context']
 
         try:
@@ -124,7 +124,7 @@
                 "floating_ip": floating_ip,
                 "fixed_ip": fixed_ip}}
 
-    def disassociate(self, req, id, body):
+    def disassociate(self, req, id):
         """ POST /floating_ips/{id}/disassociate """
         context = req.environ['nova.context']
         floating_ip = self.network_api.get_floating_ip(context, id)

=== modified file 'nova/api/openstack/create_instance_helper.py'
--- nova/api/openstack/create_instance_helper.py	2011-06-29 22:22:56 +0000
+++ nova/api/openstack/create_instance_helper.py	2011-07-11 17:17:32 +0000
@@ -289,7 +289,7 @@
         """Deserialize an xml-formatted server create request"""
         dom = minidom.parseString(string)
         server = self._extract_server(dom)
-        return {'server': server}
+        return {'body': {'server': server}}
 
     def _extract_server(self, node):
         """Marshal the server attribute of a parsed request"""

=== modified file 'nova/api/openstack/flavors.py'
--- nova/api/openstack/flavors.py	2011-06-30 13:28:21 +0000
+++ nova/api/openstack/flavors.py	2011-07-11 17:17:32 +0000
@@ -85,8 +85,10 @@
         '1.1': wsgi.XMLNS_V11,
     }[version]
 
-    serializers = {
+    body_serializers = {
         'application/xml': wsgi.XMLDictSerializer(xmlns=xmlns),
     }
 
-    return wsgi.Resource(controller, serializers=serializers)
+    serializer = wsgi.ResponseSerializer(body_serializers)
+
+    return wsgi.Resource(controller, serializer=serializer)

=== modified file 'nova/api/openstack/image_metadata.py'
--- nova/api/openstack/image_metadata.py	2011-06-28 15:59:46 +0000
+++ nova/api/openstack/image_metadata.py	2011-07-11 17:17:32 +0000
@@ -160,8 +160,9 @@
 
 
 def create_resource():
-    serializers = {
+    body_serializers = {
         'application/xml': ImageMetadataXMLSerializer(),
     }
+    serializer = wsgi.ResponseSerializer(body_serializers)
 
-    return wsgi.Resource(Controller(), serializers=serializers)
+    return wsgi.Resource(Controller(), serializer=serializer)

=== modified file 'nova/api/openstack/images.py'
--- nova/api/openstack/images.py	2011-07-11 13:13:22 +0000
+++ nova/api/openstack/images.py	2011-07-11 17:17:32 +0000
@@ -348,8 +348,10 @@
         '1.1': ImageXMLSerializer(),
     }[version]
 
-    serializers = {
+    body_serializers = {
         'application/xml': xml_serializer,
     }
 
-    return wsgi.Resource(controller, serializers=serializers)
+    serializer = wsgi.ResponseSerializer(body_serializers)
+
+    return wsgi.Resource(controller, serializer=serializer)

=== modified file 'nova/api/openstack/ips.py'
--- nova/api/openstack/ips.py	2011-06-24 12:01:51 +0000
+++ nova/api/openstack/ips.py	2011-07-11 17:17:32 +0000
@@ -70,9 +70,10 @@
         },
     }
 
-    serializers = {
+    body_serializers = {
         'application/xml': wsgi.XMLDictSerializer(metadata=metadata,
                                                   xmlns=wsgi.XMLNS_V10),
     }
+    serializer = wsgi.ResponseSerializer(body_serializers)
 
-    return wsgi.Resource(Controller(), serializers=serializers)
+    return wsgi.Resource(Controller(), serializer=serializer)

=== modified file 'nova/api/openstack/limits.py'
--- nova/api/openstack/limits.py	2011-06-14 01:14:26 +0000
+++ nova/api/openstack/limits.py	2011-07-11 17:17:32 +0000
@@ -97,12 +97,14 @@
         },
     }
 
-    serializers = {
+    body_serializers = {
         'application/xml': wsgi.XMLDictSerializer(xmlns=xmlns,
                                                   metadata=metadata),
     }
 
-    return wsgi.Resource(controller, serializers=serializers)
+    serializer = wsgi.ResponseSerializer(body_serializers)
+
+    return wsgi.Resource(controller, serializer=serializer)
 
 
 class Limit(object):

=== modified file 'nova/api/openstack/server_metadata.py'
--- nova/api/openstack/server_metadata.py	2011-06-24 12:01:51 +0000
+++ nova/api/openstack/server_metadata.py	2011-07-11 17:17:32 +0000
@@ -123,8 +123,10 @@
 
 
 def create_resource():
-    serializers = {
+    body_serializers = {
         'application/xml': wsgi.XMLDictSerializer(xmlns=wsgi.XMLNS_V11),
     }
 
-    return wsgi.Resource(Controller(), serializers=serializers)
+    serializer = wsgi.ResponseSerializer(body_serializers)
+
+    return wsgi.Resource(Controller(), serializer=serializer)

=== modified file 'nova/api/openstack/servers.py'
--- nova/api/openstack/servers.py	2011-07-08 15:59:17 +0000
+++ nova/api/openstack/servers.py	2011-07-11 17:17:32 +0000
@@ -624,14 +624,16 @@
         '1.1': wsgi.XMLNS_V11,
     }[version]
 
-    serializers = {
+    body_serializers = {
         'application/xml': wsgi.XMLDictSerializer(metadata=metadata,
                                                   xmlns=xmlns),
     }
 
-    deserializers = {
+    body_deserializers = {
         'application/xml': helper.ServerXMLDeserializer(),
     }
 
-    return wsgi.Resource(controller, serializers=serializers,
-                         deserializers=deserializers)
+    serializer = wsgi.ResponseSerializer(body_serializers)
+    deserializer = wsgi.RequestDeserializer(body_deserializers)
+
+    return wsgi.Resource(controller, deserializer, serializer)

=== modified file 'nova/api/openstack/shared_ip_groups.py'
--- nova/api/openstack/shared_ip_groups.py	2011-05-20 18:42:19 +0000
+++ nova/api/openstack/shared_ip_groups.py	2011-07-11 17:17:32 +0000
@@ -24,27 +24,27 @@
 class Controller(object):
     """ The Shared IP Groups Controller for the Openstack API """
 
-    def index(self, req):
+    def index(self, req, **kwargs):
         """ Returns a list of Shared IP Groups for the user """
         raise faults.Fault(exc.HTTPNotImplemented())
 
-    def show(self, req, id):
+    def show(self, req, id, **kwargs):
         """ Shows in-depth information on a specific Shared IP Group """
         raise faults.Fault(exc.HTTPNotImplemented())
 
-    def update(self, req, id, body):
+    def update(self, req, id, **kwargs):
         """ You can't update a Shared IP Group """
         raise faults.Fault(exc.HTTPNotImplemented())
 
-    def delete(self, req, id):
+    def delete(self, req, id, **kwargs):
         """ Deletes a Shared IP Group """
         raise faults.Fault(exc.HTTPNotImplemented())
 
-    def detail(self, req):
+    def detail(self, req, **kwargs):
         """ Returns a complete list of Shared IP Groups """
         raise faults.Fault(exc.HTTPNotImplemented())
 
-    def create(self, req, body):
+    def create(self, req, **kwargs):
         """ Creates a new Shared IP group """
         raise faults.Fault(exc.HTTPNotImplemented())
 

=== modified file 'nova/api/openstack/users.py'
--- nova/api/openstack/users.py	2011-05-20 18:42:19 +0000
+++ nova/api/openstack/users.py	2011-07-11 17:17:32 +0000
@@ -105,8 +105,10 @@
         },
     }
 
-    serializers = {
+    body_serializers = {
         'application/xml': wsgi.XMLDictSerializer(metadata=metadata),
     }
 
-    return wsgi.Resource(Controller(), serializers=serializers)
+    serializer = wsgi.ResponseSerializer(body_serializers)
+
+    return wsgi.Resource(Controller(), serializer=serializer)

=== modified file 'nova/api/openstack/versions.py'
--- nova/api/openstack/versions.py	2011-06-07 18:48:13 +0000
+++ nova/api/openstack/versions.py	2011-07-11 17:17:32 +0000
@@ -31,11 +31,12 @@
             }
         }
 
-        serializers = {
+        body_serializers = {
             'application/xml': wsgi.XMLDictSerializer(metadata=metadata),
         }
+        serializer = wsgi.ResponseSerializer(body_serializers)
 
-        wsgi.Resource.__init__(self, None, serializers=serializers)
+        wsgi.Resource.__init__(self, None, serializer=serializer)
 
     def dispatch(self, request, *args):
         """Respond to a request for all OpenStack API versions."""

=== modified file 'nova/api/openstack/wsgi.py'
--- nova/api/openstack/wsgi.py	2011-07-01 19:53:06 +0000
+++ nova/api/openstack/wsgi.py	2011-07-11 17:17:32 +0000
@@ -46,38 +46,51 @@
 
         """
         if not "Content-Type" in self.headers:
-            raise exception.InvalidContentType(content_type=None)
+            return None
 
         allowed_types = ("application/xml", "application/json")
         content_type = self.content_type
 
         if content_type not in allowed_types:
             raise exception.InvalidContentType(content_type=content_type)
-        else:
-            return content_type
-
-
-class TextDeserializer(object):
-    """Custom request body deserialization based on controller action name."""
+
+        return content_type
+
+
+class ActionDispatcher(object):
+    """Maps method name to local methods through action name."""
+
+    def dispatch(self, *args, **kwargs):
+        """Find and call local method."""
+        action = kwargs.pop('action', 'default')
+        action_method = getattr(self, str(action), self.default)
+        return action_method(*args, **kwargs)
+
+    def default(self, data):
+        raise NotImplementedError()
+
+
+class TextDeserializer(ActionDispatcher):
+    """Default request body deserialization"""
 
     def deserialize(self, datastring, action='default'):
-        """Find local deserialization method and parse request body."""
-        action_method = getattr(self, str(action), self.default)
-        return action_method(datastring)
+        return self.dispatch(datastring, action=action)
 
     def default(self, datastring):
-        """Default deserialization code should live here"""
-        raise NotImplementedError()
+        return {}
 
 
 class JSONDeserializer(TextDeserializer):
 
-    def default(self, datastring):
+    def _from_json(self, datastring):
         try:
             return utils.loads(datastring)
         except ValueError:
-            raise exception.MalformedRequestBody(
-                               reason=_("malformed JSON in request body"))
+            msg = _("cannot understand JSON")
+            raise exception.MalformedRequestBody(reason=msg)
+
+    def default(self, datastring):
+        return {'body': self._from_json(datastring)}
 
 
 class XMLDeserializer(TextDeserializer):
@@ -90,15 +103,15 @@
         super(XMLDeserializer, self).__init__()
         self.metadata = metadata or {}
 
-    def default(self, datastring):
+    def _from_xml(self, datastring):
         plurals = set(self.metadata.get('plurals', {}))
 
         try:
             node = minidom.parseString(datastring).childNodes[0]
             return {node.nodeName: self._from_xml_node(node, plurals)}
         except expat.ExpatError:
-            raise exception.MalformedRequestBody(
-                                    reason=_("malformed XML in request body"))
+            msg = _("cannot understand XML")
+            raise exception.MalformedRequestBody(reason=msg)
 
     def _from_xml_node(self, node, listnames):
         """Convert a minidom node to a simple Python type.
@@ -121,21 +134,32 @@
                                                                  listnames)
             return result
 
+    def default(self, datastring):
+        return {'body': self._from_xml(datastring)}
+
+
+class RequestHeadersDeserializer(ActionDispatcher):
+    """Default request headers deserializer"""
+
+    def deserialize(self, request, action):
+        return self.dispatch(request, action=action)
+
+    def default(self, request):
+        return {}
+
 
 class RequestDeserializer(object):
     """Break up a Request object into more useful pieces."""
 
-    def __init__(self, deserializers=None):
-        """
-        :param deserializers: dictionary of content-type-specific deserializers
-
-        """
-        self.deserializers = {
+    def __init__(self, body_deserializers=None, headers_deserializer=None):
+        self.body_deserializers = {
             'application/xml': XMLDeserializer(),
             'application/json': JSONDeserializer(),
         }
+        self.body_deserializers.update(body_deserializers or {})
 
-        self.deserializers.update(deserializers or {})
+        self.headers_deserializer = headers_deserializer or \
+                                        RequestHeadersDeserializer()
 
     def deserialize(self, request):
         """Extract necessary pieces of the request.
@@ -149,26 +173,42 @@
         action_args = self.get_action_args(request.environ)
         action = action_args.pop('action', None)
 
-        if request.method.lower() in ('post', 'put'):
-            if len(request.body) == 0:
-                action_args['body'] = None
-            else:
-                content_type = request.get_content_type()
-                deserializer = self.get_deserializer(content_type)
-
-                try:
-                    body = deserializer.deserialize(request.body, action)
-                    action_args['body'] = body
-                except exception.InvalidContentType:
-                    action_args['body'] = None
+        action_args.update(self.deserialize_headers(request, action))
+        action_args.update(self.deserialize_body(request, action))
 
         accept = self.get_expected_content_type(request)
 
         return (action, action_args, accept)
 
-    def get_deserializer(self, content_type):
-        try:
-            return self.deserializers[content_type]
+    def deserialize_headers(self, request, action):
+        return self.headers_deserializer.deserialize(request, action)
+
+    def deserialize_body(self, request, action):
+        try:
+            content_type = request.get_content_type()
+        except exception.InvalidContentType:
+            LOG.debug(_("Unrecognized Content-Type provided in request"))
+            return {}
+
+        if content_type is None:
+            LOG.debug(_("No Content-Type provided in request"))
+            return {}
+
+        if not len(request.body) > 0:
+            LOG.debug(_("Empty body provided in request"))
+            return {}
+
+        try:
+            deserializer = self.get_body_deserializer(content_type)
+        except exception.InvalidContentType:
+            LOG.debug(_("Unable to deserialize body as provided Content-Type"))
+            raise
+
+        return deserializer.deserialize(request.body, action)
+
+    def get_body_deserializer(self, content_type):
+        try:
+            return self.body_deserializers[content_type]
         except (KeyError, TypeError):
             raise exception.InvalidContentType(content_type=content_type)
 
@@ -195,20 +235,18 @@
         return args
 
 
-class DictSerializer(object):
-    """Custom response body serialization based on controller action name."""
+class DictSerializer(ActionDispatcher):
+    """Default request body serialization"""
 
     def serialize(self, data, action='default'):
-        """Find local serialization method and encode response body."""
-        action_method = getattr(self, str(action), self.default)
-        return action_method(data)
+        return self.dispatch(data, action=action)
 
     def default(self, data):
-        """Default serialization code should live here"""
-        raise NotImplementedError()
+        return ""
 
 
 class JSONDictSerializer(DictSerializer):
+    """Default JSON request body serialization"""
 
     def default(self, data):
         return utils.dumps(data)
@@ -295,19 +333,28 @@
         return result
 
 
+class ResponseHeadersSerializer(ActionDispatcher):
+    """Default response headers serialization"""
+
+    def serialize(self, response, data, action):
+        self.dispatch(response, data, action=action)
+
+    def default(self, response, data):
+        response.status_int = 200
+
+
 class ResponseSerializer(object):
     """Encode the necessary pieces into a response object"""
 
-    def __init__(self, serializers=None):
-        """
-        :param serializers: dictionary of content-type-specific serializers
-
-        """
-        self.serializers = {
+    def __init__(self, body_serializers=None, headers_serializer=None):
+        self.body_serializers = {
             'application/xml': XMLDictSerializer(),
             'application/json': JSONDictSerializer(),
         }
-        self.serializers.update(serializers or {})
+        self.body_serializers.update(body_serializers or {})
+
+        self.headers_serializer = headers_serializer or \
+                                    ResponseHeadersSerializer()
 
     def serialize(self, response_data, content_type, action='default'):
         """Serialize a dict into a string and wrap in a wsgi.Request object.
@@ -317,16 +364,21 @@
 
         """
         response = webob.Response()
+        self.serialize_headers(response, response_data, action)
+        self.serialize_body(response, response_data, content_type, action)
+        return response
+
+    def serialize_headers(self, response, data, action):
+        self.headers_serializer.serialize(response, data, action)
+
+    def serialize_body(self, response, data, content_type, action):
         response.headers['Content-Type'] = content_type
-
-        serializer = self.get_serializer(content_type)
-        response.body = serializer.serialize(response_data, action)
-
-        return response
-
-    def get_serializer(self, content_type):
+        serializer = self.get_body_serializer(content_type)
+        response.body = serializer.serialize(data, action)
+
+    def get_body_serializer(self, content_type):
         try:
-            return self.serializers[content_type]
+            return self.body_serializers[content_type]
         except (KeyError, TypeError):
             raise exception.InvalidContentType(content_type=content_type)
 
@@ -343,16 +395,18 @@
     serialized by requested content type.
 
     """
-    def __init__(self, controller, serializers=None, deserializers=None):
+    def __init__(self, controller, deserializer=None, serializer=None):
         """
         :param controller: object that implement methods created by routes lib
-        :param serializers: dict of content-type specific text serializers
-        :param deserializers: dict of content-type specific text deserializers
+        :param deserializer: object that can serialize the output of a
+                             controller into a webob response
+        :param serializer: object that can deserialize a webob request
+                           into necessary pieces
 
         """
         self.controller = controller
-        self.serializer = ResponseSerializer(serializers)
-        self.deserializer = RequestDeserializer(deserializers)
+        self.deserializer = deserializer or RequestDeserializer()
+        self.serializer = serializer or ResponseSerializer()
 
     @webob.dec.wsgify(RequestClass=Request)
     def __call__(self, request):
@@ -362,8 +416,7 @@
                                           "url": request.url})
 
         try:
-            action, action_args, accept = self.deserializer.deserialize(
-                                                                      request)
+            action, args, accept = self.deserializer.deserialize(request)
         except exception.InvalidContentType:
             msg = _("Unsupported Content-Type")
             return webob.exc.HTTPBadRequest(explanation=msg)
@@ -371,11 +424,13 @@
             msg = _("Malformed request body")
             return faults.Fault(webob.exc.HTTPBadRequest(explanation=msg))
 
-        action_result = self.dispatch(request, action, action_args)
+        action_result = self.dispatch(request, action, args)
 
         #TODO(bcwaldon): find a more elegant way to pass through non-dict types
-        if type(action_result) is dict:
-            response = self.serializer.serialize(action_result, accept, action)
+        if type(action_result) is dict or action_result is None:
+            response = self.serializer.serialize(action_result,
+                                                 accept,
+                                                 action=action)
         else:
             response = action_result
 
@@ -394,4 +449,8 @@
         """Find action-spefic method on controller and call it."""
 
         controller_method = getattr(self.controller, action)
-        return controller_method(req=request, **action_args)
+        try:
+            return controller_method(req=request, **action_args)
+        except TypeError, exc:
+            LOG.debug(str(exc))
+            return webob.exc.HTTPBadRequest()

=== modified file 'nova/api/openstack/zones.py'
--- nova/api/openstack/zones.py	2011-06-14 19:59:16 +0000
+++ nova/api/openstack/zones.py	2011-07-11 17:17:32 +0000
@@ -196,14 +196,15 @@
         },
     }
 
-    serializers = {
+    body_serializers = {
         'application/xml': wsgi.XMLDictSerializer(xmlns=wsgi.XMLNS_V10,
                                                   metadata=metadata),
     }
+    serializer = wsgi.ResponseSerializer(body_serializers)
 
-    deserializers = {
+    body_deserializers = {
         'application/xml': helper.ServerXMLDeserializer(),
     }
+    deserializer = wsgi.RequestDeserializer(body_deserializers)
 
-    return wsgi.Resource(controller, serializers=serializers,
-                         deserializers=deserializers)
+    return wsgi.Resource(controller, deserializer, serializer)

=== modified file 'nova/tests/api/openstack/contrib/test_floating_ips.py'
--- nova/tests/api/openstack/contrib/test_floating_ips.py	2011-06-27 16:36:53 +0000
+++ nova/tests/api/openstack/contrib/test_floating_ips.py	2011-07-11 17:17:32 +0000
@@ -139,7 +139,9 @@
     def test_floating_ip_allocate(self):
         req = webob.Request.blank('/v1.1/os-floating-ips')
         req.method = 'POST'
+        req.headers['Content-Type'] = 'application/json'
         res = req.get_response(fakes.wsgi_app())
+        print res
         self.assertEqual(res.status_int, 200)
         ip = json.loads(res.body)['allocated']
         expected = {
@@ -177,6 +179,7 @@
     def test_floating_ip_disassociate(self):
         req = webob.Request.blank('/v1.1/os-floating-ips/1/disassociate')
         req.method = 'POST'
+        req.headers['Content-Type'] = 'application/json'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
         ip = json.loads(res.body)['disassociated']

=== modified file 'nova/tests/api/openstack/test_servers.py'
--- nova/tests/api/openstack/test_servers.py	2011-07-08 16:47:34 +0000
+++ nova/tests/api/openstack/test_servers.py	2011-07-11 17:17:32 +0000
@@ -905,7 +905,7 @@
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 422)
+        self.assertEqual(res.status_int, 400)
 
     def test_update_nonstring_name(self):
         """ Confirm that update is filtering params """
@@ -1608,7 +1608,7 @@
                 "imageId": "1",
                 "flavorId": "1",
                 }}
-        self.assertEquals(request, expected)
+        self.assertEquals(request['body'], expected)
 
     def test_request_with_empty_metadata(self):
         serial_request = """
@@ -1623,7 +1623,7 @@
                 "flavorId": "1",
                 "metadata": {},
                 }}
-        self.assertEquals(request, expected)
+        self.assertEquals(request['body'], expected)
 
     def test_request_with_empty_personality(self):
         serial_request = """
@@ -1638,7 +1638,7 @@
                 "flavorId": "1",
                 "personality": [],
                 }}
-        self.assertEquals(request, expected)
+        self.assertEquals(request['body'], expected)
 
     def test_request_with_empty_metadata_and_personality(self):
         serial_request = """
@@ -1655,7 +1655,7 @@
                 "metadata": {},
                 "personality": [],
                 }}
-        self.assertEquals(request, expected)
+        self.assertEquals(request['body'], expected)
 
     def test_request_with_empty_metadata_and_personality_reversed(self):
         serial_request = """
@@ -1672,7 +1672,7 @@
                 "metadata": {},
                 "personality": [],
                 }}
-        self.assertEquals(request, expected)
+        self.assertEquals(request['body'], expected)
 
     def test_request_with_one_personality(self):
         serial_request = """
@@ -1684,7 +1684,7 @@
 </server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = [{"path": "/etc/conf", "contents": "aabbccdd"}]
-        self.assertEquals(request["server"]["personality"], expected)
+        self.assertEquals(request['body']["server"]["personality"], expected)
 
     def test_request_with_two_personalities(self):
         serial_request = """
@@ -1695,7 +1695,7 @@
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = [{"path": "/etc/conf", "contents": "aabbccdd"},
                     {"path": "/etc/sudoers", "contents": "abcd"}]
-        self.assertEquals(request["server"]["personality"], expected)
+        self.assertEquals(request['body']["server"]["personality"], expected)
 
     def test_request_second_personality_node_ignored(self):
         serial_request = """
@@ -1710,7 +1710,7 @@
 </server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = [{"path": "/etc/conf", "contents": "aabbccdd"}]
-        self.assertEquals(request["server"]["personality"], expected)
+        self.assertEquals(request['body']["server"]["personality"], expected)
 
     def test_request_with_one_personality_missing_path(self):
         serial_request = """
@@ -1719,7 +1719,7 @@
 <personality><file>aabbccdd</file></personality></server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = [{"contents": "aabbccdd"}]
-        self.assertEquals(request["server"]["personality"], expected)
+        self.assertEquals(request['body']["server"]["personality"], expected)
 
     def test_request_with_one_personality_empty_contents(self):
         serial_request = """
@@ -1728,7 +1728,7 @@
 <personality><file path="/etc/conf"></file></personality></server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = [{"path": "/etc/conf", "contents": ""}]
-        self.assertEquals(request["server"]["personality"], expected)
+        self.assertEquals(request['body']["server"]["personality"], expected)
 
     def test_request_with_one_personality_empty_contents_variation(self):
         serial_request = """
@@ -1737,7 +1737,7 @@
 <personality><file path="/etc/conf"/></personality></server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = [{"path": "/etc/conf", "contents": ""}]
-        self.assertEquals(request["server"]["personality"], expected)
+        self.assertEquals(request['body']["server"]["personality"], expected)
 
     def test_request_with_one_metadata(self):
         serial_request = """
@@ -1749,7 +1749,7 @@
 </server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = {"alpha": "beta"}
-        self.assertEquals(request["server"]["metadata"], expected)
+        self.assertEquals(request['body']["server"]["metadata"], expected)
 
     def test_request_with_two_metadata(self):
         serial_request = """
@@ -1762,7 +1762,7 @@
 </server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = {"alpha": "beta", "foo": "bar"}
-        self.assertEquals(request["server"]["metadata"], expected)
+        self.assertEquals(request['body']["server"]["metadata"], expected)
 
     def test_request_with_metadata_missing_value(self):
         serial_request = """
@@ -1774,7 +1774,7 @@
 </server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = {"alpha": ""}
-        self.assertEquals(request["server"]["metadata"], expected)
+        self.assertEquals(request['body']["server"]["metadata"], expected)
 
     def test_request_with_two_metadata_missing_value(self):
         serial_request = """
@@ -1787,7 +1787,7 @@
 </server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = {"alpha": "", "delta": ""}
-        self.assertEquals(request["server"]["metadata"], expected)
+        self.assertEquals(request['body']["server"]["metadata"], expected)
 
     def test_request_with_metadata_missing_key(self):
         serial_request = """
@@ -1799,7 +1799,7 @@
 </server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = {"": "beta"}
-        self.assertEquals(request["server"]["metadata"], expected)
+        self.assertEquals(request['body']["server"]["metadata"], expected)
 
     def test_request_with_two_metadata_missing_key(self):
         serial_request = """
@@ -1812,7 +1812,7 @@
 </server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = {"": "gamma"}
-        self.assertEquals(request["server"]["metadata"], expected)
+        self.assertEquals(request['body']["server"]["metadata"], expected)
 
     def test_request_with_metadata_duplicate_key(self):
         serial_request = """
@@ -1825,7 +1825,7 @@
 </server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
         expected = {"foo": "baz"}
-        self.assertEquals(request["server"]["metadata"], expected)
+        self.assertEquals(request['body']["server"]["metadata"], expected)
 
     def test_canonical_request_from_docs(self):
         serial_request = """
@@ -1871,7 +1871,7 @@
             ],
         }}
         request = self.deserializer.deserialize(serial_request, 'create')
-        self.assertEqual(request, expected)
+        self.assertEqual(request['body'], expected)
 
     def test_request_xmlser_with_flavor_image_href(self):
         serial_request = """
@@ -1881,9 +1881,9 @@
                     flavorRef="http://localhost:8774/v1.1/flavors/1">
                 </server>"""
         request = self.deserializer.deserialize(serial_request, 'create')
-        self.assertEquals(request["server"]["flavorRef"],
+        self.assertEquals(request['body']["server"]["flavorRef"],
                           "http://localhost:8774/v1.1/flavors/1")
-        self.assertEquals(request["server"]["imageRef"],
+        self.assertEquals(request['body']["server"]["imageRef"],
                           "http://localhost:8774/v1.1/images/1")
 
 
@@ -1948,7 +1948,7 @@
 
     def _get_create_request_json(self, body_dict):
         req = webob.Request.blank('/v1.0/servers')
-        req.content_type = 'application/json'
+        req.headers['Content-Type'] = 'application/json'
         req.method = 'POST'
         req.body = json.dumps(body_dict)
         return req

=== modified file 'nova/tests/api/openstack/test_wsgi.py'
--- nova/tests/api/openstack/test_wsgi.py	2011-06-24 12:01:51 +0000
+++ nova/tests/api/openstack/test_wsgi.py	2011-07-11 17:17:32 +0000
@@ -12,8 +12,7 @@
     def test_content_type_missing(self):
         request = wsgi.Request.blank('/tests/123', method='POST')
         request.body = "<body />"
-        self.assertRaises(exception.InvalidContentType,
-                          request.get_content_type)
+        self.assertEqual(None, request.get_content_type())
 
     def test_content_type_unsupported(self):
         request = wsgi.Request.blank('/tests/123', method='POST')
@@ -76,24 +75,48 @@
         self.assertEqual(result, "application/json")
 
 
+class ActionDispatcherTest(test.TestCase):
+    def test_dispatch(self):
+        serializer = wsgi.ActionDispatcher()
+        serializer.create = lambda x: 'pants'
+        self.assertEqual(serializer.dispatch({}, action='create'), 'pants')
+
+    def test_dispatch_action_None(self):
+        serializer = wsgi.ActionDispatcher()
+        serializer.create = lambda x: 'pants'
+        serializer.default = lambda x: 'trousers'
+        self.assertEqual(serializer.dispatch({}, action=None), 'trousers')
+
+    def test_dispatch_default(self):
+        serializer = wsgi.ActionDispatcher()
+        serializer.create = lambda x: 'pants'
+        serializer.default = lambda x: 'trousers'
+        self.assertEqual(serializer.dispatch({}, action='update'), 'trousers')
+
+
+class ResponseHeadersSerializerTest(test.TestCase):
+    def test_default(self):
+        serializer = wsgi.ResponseHeadersSerializer()
+        response = webob.Response()
+        serializer.serialize(response, {'v': '123'}, 'asdf')
+        self.assertEqual(response.status_int, 200)
+
+    def test_custom(self):
+        class Serializer(wsgi.ResponseHeadersSerializer):
+            def update(self, response, data):
+                response.status_int = 404
+                response.headers['X-Custom-Header'] = data['v']
+        serializer = Serializer()
+        response = webob.Response()
+        serializer.serialize(response, {'v': '123'}, 'update')
+        self.assertEqual(response.status_int, 404)
+        self.assertEqual(response.headers['X-Custom-Header'], '123')
+
+
 class DictSerializerTest(test.TestCase):
-    def test_dispatch(self):
-        serializer = wsgi.DictSerializer()
-        serializer.create = lambda x: 'pants'
-        serializer.default = lambda x: 'trousers'
-        self.assertEqual(serializer.serialize({}, 'create'), 'pants')
-
     def test_dispatch_default(self):
         serializer = wsgi.DictSerializer()
-        serializer.create = lambda x: 'pants'
-        serializer.default = lambda x: 'trousers'
-        self.assertEqual(serializer.serialize({}, 'update'), 'trousers')
-
-    def test_dispatch_action_None(self):
-        serializer = wsgi.DictSerializer()
-        serializer.create = lambda x: 'pants'
-        serializer.default = lambda x: 'trousers'
-        self.assertEqual(serializer.serialize({}, None), 'trousers')
+        self.assertEqual(serializer.serialize({}, 'update'), '')
 
 
 class XMLDictSerializerTest(test.TestCase):
@@ -117,23 +140,9 @@
 
 
 class TextDeserializerTest(test.TestCase):
-    def test_dispatch(self):
-        deserializer = wsgi.TextDeserializer()
-        deserializer.create = lambda x: 'pants'
-        deserializer.default = lambda x: 'trousers'
-        self.assertEqual(deserializer.deserialize({}, 'create'), 'pants')
-
     def test_dispatch_default(self):
         deserializer = wsgi.TextDeserializer()
-        deserializer.create = lambda x: 'pants'
-        deserializer.default = lambda x: 'trousers'
-        self.assertEqual(deserializer.deserialize({}, 'update'), 'trousers')
-
-    def test_dispatch_action_None(self):
-        deserializer = wsgi.TextDeserializer()
-        deserializer.create = lambda x: 'pants'
-        deserializer.default = lambda x: 'trousers'
-        self.assertEqual(deserializer.deserialize({}, None), 'trousers')
+        self.assertEqual(deserializer.deserialize({}, 'update'), {})
 
 
 class JSONDeserializerTest(test.TestCase):
@@ -144,12 +153,17 @@
                 "bs": ["1", "2", "3", {"c": {"c1": "1"}}],
                 "d": {"e": "1"},
                 "f": "1"}}"""
-        as_dict = dict(a={
-                'a1': '1',
-                'a2': '2',
-                'bs': ['1', '2', '3', {'c': dict(c1='1')}],
-                'd': {'e': '1'},
-                'f': '1'})
+        as_dict = {
+            'body': {
+                'a': {
+                    'a1': '1',
+                    'a2': '2',
+                    'bs': ['1', '2', '3', {'c': {'c1': '1'}}],
+                    'd': {'e': '1'},
+                    'f': '1',
+                },
+            },
+        }
         deserializer = wsgi.JSONDeserializer()
         self.assertEqual(deserializer.deserialize(data), as_dict)
 
@@ -163,23 +177,44 @@
               <f>1</f>
             </a>
             """.strip()
-        as_dict = dict(a={
-                'a1': '1',
-                'a2': '2',
-                'bs': ['1', '2', '3', {'c': dict(c1='1')}],
-                'd': {'e': '1'},
-                'f': '1'})
+        as_dict = {
+            'body': {
+                'a': {
+                    'a1': '1',
+                    'a2': '2',
+                    'bs': ['1', '2', '3', {'c': {'c1': '1'}}],
+                    'd': {'e': '1'},
+                    'f': '1',
+                },
+            },
+        }
         metadata = {'plurals': {'bs': 'b', 'ts': 't'}}
         deserializer = wsgi.XMLDeserializer(metadata=metadata)
         self.assertEqual(deserializer.deserialize(xml), as_dict)
 
     def test_xml_empty(self):
         xml = """<a></a>"""
-        as_dict = {"a": {}}
+        as_dict = {"body": {"a": {}}}
         deserializer = wsgi.XMLDeserializer()
         self.assertEqual(deserializer.deserialize(xml), as_dict)
 
 
+class RequestHeadersDeserializerTest(test.TestCase):
+    def test_default(self):
+        deserializer = wsgi.RequestHeadersDeserializer()
+        req = wsgi.Request.blank('/')
+        self.assertEqual(deserializer.deserialize(req, 'asdf'), {})
+
+    def test_custom(self):
+        class Deserializer(wsgi.RequestHeadersDeserializer):
+            def update(self, request):
+                return {'a': request.headers['X-Custom-Header']}
+        deserializer = Deserializer()
+        req = wsgi.Request.blank('/')
+        req.headers['X-Custom-Header'] = 'b'
+        self.assertEqual(deserializer.deserialize(req, 'update'), {'a': 'b'})
+
+
 class ResponseSerializerTest(test.TestCase):
     def setUp(self):
         class JSONSerializer(object):
@@ -190,29 +225,36 @@
             def serialize(self, data, action='default'):
                 return 'pew_xml'
 
-        self.serializers = {
+        class HeadersSerializer(object):
+            def serialize(self, response, data, action):
+                response.status_int = 404
+
+        self.body_serializers = {
             'application/json': JSONSerializer(),
             'application/XML': XMLSerializer(),
         }
 
-        self.serializer = wsgi.ResponseSerializer(serializers=self.serializers)
+        self.serializer = wsgi.ResponseSerializer(self.body_serializers,
+                                                  HeadersSerializer())
 
     def tearDown(self):
         pass
 
     def test_get_serializer(self):
-        self.assertEqual(self.serializer.get_serializer('application/json'),
-                         self.serializers['application/json'])
+        ctype = 'application/json'
+        self.assertEqual(self.serializer.get_body_serializer(ctype),
+                         self.body_serializers[ctype])
 
     def test_get_serializer_unknown_content_type(self):
         self.assertRaises(exception.InvalidContentType,
-                          self.serializer.get_serializer,
+                          self.serializer.get_body_serializer,
                           'application/unknown')
 
     def test_serialize_response(self):
         response = self.serializer.serialize({}, 'application/json')
         self.assertEqual(response.headers['Content-Type'], 'application/json')
         self.assertEqual(response.body, 'pew_json')
+        self.assertEqual(response.status_int, 404)
 
     def test_serialize_response_dict_to_unknown_content_type(self):
         self.assertRaises(exception.InvalidContentType,
@@ -230,24 +272,23 @@
             def deserialize(self, data, action='default'):
                 return 'pew_xml'
 
-        self.deserializers = {
+        self.body_deserializers = {
             'application/json': JSONDeserializer(),
             'application/XML': XMLDeserializer(),
         }
 
-        self.deserializer = wsgi.RequestDeserializer(
-                                            deserializers=self.deserializers)
+        self.deserializer = wsgi.RequestDeserializer(self.body_deserializers)
 
     def tearDown(self):
         pass
 
     def test_get_deserializer(self):
-        expected = self.deserializer.get_deserializer('application/json')
-        self.assertEqual(expected, self.deserializers['application/json'])
+        expected = self.deserializer.get_body_deserializer('application/json')
+        self.assertEqual(expected, self.body_deserializers['application/json'])
 
     def test_get_deserializer_unknown_content_type(self):
         self.assertRaises(exception.InvalidContentType,
-                          self.deserializer.get_deserializer,
+                          self.deserializer.get_body_deserializer,
                           'application/unknown')
 
     def test_get_expected_content_type(self):

=== modified file 'nova/tests/integrated/api/client.py'
--- nova/tests/integrated/api/client.py	2011-06-24 12:01:51 +0000
+++ nova/tests/integrated/api/client.py	2011-07-11 17:17:32 +0000
@@ -71,8 +71,8 @@
         self.auth_uri = auth_uri
 
     def request(self, url, method='GET', body=None, headers=None):
-        if headers is None:
-            headers = {}
+        _headers = {'Content-Type': 'application/json'}
+        _headers.update(headers or {})
 
         parsed_url = urlparse.urlparse(url)
         port = parsed_url.port
@@ -94,9 +94,8 @@
         LOG.info(_("Doing %(method)s on %(relative_url)s") % locals())
         if body:
             LOG.info(_("Body: %s") % body)
-            headers.setdefault('Content-Type', 'application/json')
 
-        conn.request(method, relative_url, body, headers)
+        conn.request(method, relative_url, body, _headers)
         response = conn.getresponse()
         return response