merged trunk

27 files changed, 885 insertions, 279 deletions

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 100d1179d..966c3a564 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -536,7 +536,55 @@ class CloudController(object):
             g['ipPermissions'] += [r]
         return g
 
-    def _revoke_rule_args_to_dict(self, context, to_port=None, from_port=None,
+    def _rule_args_to_dict(self, context, kwargs):
+        rules = []
+        if not 'groups' in kwargs and not 'ip_ranges' in kwargs:
+            rule = self._rule_dict_last_step(context, **kwargs)
+            if rule:
+                rules.append(rule)
+            return rules
+        if 'ip_ranges' in kwargs:
+            rules = self._cidr_args_split(kwargs)
+        else:
+            rules = [kwargs]
+        finalset = []
+        for rule in rules:
+            if 'groups' in rule:
+                groups_values = self._groups_args_split(rule)
+                for groups_value in groups_values:
+                    final = self._rule_dict_last_step(context, **groups_value)
+                    finalset.append(final)
+            else:
+                final = self._rule_dict_last_step(context, **rule)
+                finalset.append(final)
+        return finalset
+
+    def _cidr_args_split(self, kwargs):
+        cidr_args_split = []
+        cidrs = kwargs['ip_ranges']
+        for key, cidr in cidrs.iteritems():
+            mykwargs = kwargs.copy()
+            del mykwargs['ip_ranges']
+            mykwargs['cidr_ip'] = cidr['cidr_ip']
+            cidr_args_split.append(mykwargs)
+        return cidr_args_split
+
+    def _groups_args_split(self, kwargs):
+        groups_args_split = []
+        groups = kwargs['groups']
+        for key, group in groups.iteritems():
+            mykwargs = kwargs.copy()
+            del mykwargs['groups']
+            if 'group_name' in group:
+                mykwargs['source_security_group_name'] = group['group_name']
+            if 'user_id' in group:
+                mykwargs['source_security_group_owner_id'] = group['user_id']
+            if 'group_id' in group:
+                mykwargs['source_security_group_id'] = group['group_id']
+            groups_args_split.append(mykwargs)
+        return groups_args_split
+
+    def _rule_dict_last_step(self, context, to_port=None, from_port=None,
                                   ip_protocol=None, cidr_ip=None, user_id=None,
                                   source_security_group_name=None,
                                   source_security_group_owner_id=None):
@@ -551,6 +599,9 @@ class CloudController(object):
                     db.security_group_get_by_name(context.elevated(),
                                                   source_project_id,
                                                   source_security_group_name)
+            notfound = exception.SecurityGroupNotFound
+            if not source_security_group:
+                raise notfound(security_group_id=source_security_group_name)
             values['group_id'] = source_security_group['id']
         elif cidr_ip:
             # If this fails, it throws an exception. This is what we want.
@@ -589,7 +640,7 @@ class CloudController(object):
         for rule in security_group.rules:
             if 'group_id' in values:
                 if rule['group_id'] == values['group_id']:
-                    return True
+                    return rule['id']
             else:
                 is_duplicate = True
                 for key in ('cidr', 'from_port', 'to_port', 'protocol'):
@@ -597,7 +648,7 @@ class CloudController(object):
                         is_duplicate = False
                         break
                 if is_duplicate:
-                    return True
+                    return rule['id']
         return False
 
     def revoke_security_group_ingress(self, context, group_name=None,
@@ -620,22 +671,30 @@ class CloudController(object):
 
         msg = "Revoke security group ingress %s"
         LOG.audit(_(msg), security_group['name'], context=context)
-
-        criteria = self._revoke_rule_args_to_dict(context, **kwargs)
-        if criteria is None:
-            raise exception.ApiError(_("Not enough parameters to build a "
-                                       "valid rule."))
-
-        for rule in security_group.rules:
-            match = True
-            for (k, v) in criteria.iteritems():
-                if getattr(rule, k, False) != v:
-                    match = False
-            if match:
-                db.security_group_rule_destroy(context, rule['id'])
-                self.compute_api.trigger_security_group_rules_refresh(context,
-                                        security_group_id=security_group['id'])
-                return True
+        prevalues = []
+        try:
+            prevalues = kwargs['ip_permissions']
+        except KeyError:
+            prevalues.append(kwargs)
+        rule_id = None
+        for values in prevalues:
+            rulesvalues = self._rule_args_to_dict(context, values)
+            if not rulesvalues:
+                err = "%s Not enough parameters to build a valid rule"
+                raise exception.ApiError(_(err % rulesvalues))
+
+            for values_for_rule in rulesvalues:
+                values_for_rule['parent_group_id'] = security_group.id
+                rule_id = self._security_group_rule_exists(security_group,
+                                                           values_for_rule)
+                if rule_id:
+                    db.security_group_rule_destroy(context, rule_id)
+        if rule_id:
+            # NOTE(vish): we removed a rule, so refresh
+            self.compute_api.trigger_security_group_rules_refresh(
+                    context,
+                    security_group_id=security_group['id'])
+            return True
         raise exception.ApiError(_("No rule for the specified parameters."))
 
     # TODO(soren): This has only been tested with Boto as the client.
@@ -662,22 +721,37 @@ class CloudController(object):
 
         msg = "Authorize security group ingress %s"
         LOG.audit(_(msg), security_group['name'], context=context)
-        values = self._revoke_rule_args_to_dict(context, **kwargs)
-        if values is None:
-            raise exception.ApiError(_("Not enough parameters to build a "
-                                       "valid rule."))
-        values['parent_group_id'] = security_group.id
-
-        if self._security_group_rule_exists(security_group, values):
-            raise exception.ApiError(_('This rule already exists in group %s')
-                                     % group_name)
-
-        security_group_rule = db.security_group_rule_create(context, values)
+        prevalues = []
+        try:
+            prevalues = kwargs['ip_permissions']
+        except KeyError:
+            prevalues.append(kwargs)
+        postvalues = []
+        for values in prevalues:
+            rulesvalues = self._rule_args_to_dict(context, values)
+            if not rulesvalues:
+                err = "%s Not enough parameters to build a valid rule"
+                raise exception.ApiError(_(err % rulesvalues))
+            for values_for_rule in rulesvalues:
+                values_for_rule['parent_group_id'] = security_group.id
+                if self._security_group_rule_exists(security_group,
+                                                    values_for_rule):
+                    err = '%s - This rule already exists in group'
+                    raise exception.ApiError(_(err) % values_for_rule)
+                postvalues.append(values_for_rule)
+
+        for values_for_rule in postvalues:
+            security_group_rule = db.security_group_rule_create(
+                    context,
+                    values_for_rule)
 
-        self.compute_api.trigger_security_group_rules_refresh(context,
-                                      security_group_id=security_group['id'])
+        if postvalues:
+            self.compute_api.trigger_security_group_rules_refresh(
+                    context,
+                    security_group_id=security_group['id'])
+            return True
 
-        return True
+        raise exception.ApiError(_("No rule for the specified parameters."))
 
     def _get_source_project_id(self, context, source_security_group_owner_id):
         if source_security_group_owner_id:
@@ -1165,7 +1239,7 @@ class CloudController(object):
 
     def rescue_instance(self, context, instance_id, **kwargs):
         """This is an extension to the normal ec2_api"""
-        self._do_instance(self.compute_api.rescue, contect, instnace_id)
+        self._do_instance(self.compute_api.rescue, context, instance_id)
         return True
 
     def unrescue_instance(self, context, instance_id, **kwargs):
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index e87d7c754..868b98a31 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -164,11 +164,17 @@ class APIRouterV11(APIRouter):
 
     def _setup_routes(self, mapper):
         super(APIRouterV11, self)._setup_routes(mapper, '1.1')
-        mapper.resource("image_meta", "meta",
-                        controller=image_metadata.create_resource(),
+        image_metadata_controller = image_metadata.create_resource()
+        mapper.resource("image_meta", "metadata",
+                        controller=image_metadata_controller,
                         parent_resource=dict(member_name='image',
                         collection_name='images'))
 
+        mapper.connect("metadata", "/images/{image_id}/metadata",
+                       controller=image_metadata_controller,
+                       action='update_all',
+                       conditions={"method": ['PUT']})
+
         mapper.resource("server_meta", "meta",
                         controller=server_metadata.create_resource(),
                         parent_resource=dict(member_name='server',
diff --git a/nova/api/openstack/accounts.py b/nova/api/openstack/accounts.py
index e3201b14f..a13a758ab 100644
--- a/nova/api/openstack/accounts.py
+++ b/nova/api/openstack/accounts.py
@@ -47,10 +47,10 @@ class Controller(object):
             raise exception.AdminRequired()
 
     def index(self, req):
-        raise faults.Fault(webob.exc.HTTPNotImplemented())
+        raise webob.exc.HTTPNotImplemented()
 
     def detail(self, req):
-        raise faults.Fault(webob.exc.HTTPNotImplemented())
+        raise webob.exc.HTTPNotImplemented()
 
     def show(self, req, id):
         """Return data about the given account id"""
@@ -65,7 +65,7 @@ class Controller(object):
     def create(self, req, body):
         """We use update with create-or-update semantics
            because the id comes from an external source"""
-        raise faults.Fault(webob.exc.HTTPNotImplemented())
+        raise webob.exc.HTTPNotImplemented()
 
     def update(self, req, id, body):
         """This is really create or update."""
diff --git a/nova/api/openstack/backup_schedules.py b/nova/api/openstack/backup_schedules.py
index 3e95aedf3..7ff0d999e 100644
--- a/nova/api/openstack/backup_schedules.py
+++ b/nova/api/openstack/backup_schedules.py
@@ -19,7 +19,6 @@ import time
 
 from webob import exc
 
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 
 
@@ -36,20 +35,20 @@ class Controller(object):
 
     def index(self, req, server_id, **kwargs):
         """ Returns the list of backup schedules for a given instance """
-        return faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def show(self, req, server_id, id, **kwargs):
         """ Returns a single backup schedule for a given instance """
-        return faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     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())
+        raise exc.HTTPNotImplemented()
 
     def delete(self, req, server_id, id, **kwargs):
         """ Deletes an existing backup schedule """
-        return faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
 
 def create_resource():
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 8e12ce0c0..bd14a1389 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -53,10 +53,10 @@ def get_pagination_params(request):
             params[param] = int(request.GET[param])
         except ValueError:
             msg = _('%s param must be an integer') % param
-            raise webob.exc.HTTPBadRequest(msg)
+            raise webob.exc.HTTPBadRequest(explanation=msg)
         if params[param] < 0:
             msg = _('%s param must be positive') % param
-            raise webob.exc.HTTPBadRequest(msg)
+            raise webob.exc.HTTPBadRequest(explanation=msg)
 
     return params
 
@@ -77,18 +77,22 @@ def limited(items, request, max_limit=FLAGS.osapi_max_limit):
     try:
         offset = int(request.GET.get('offset', 0))
     except ValueError:
-        raise webob.exc.HTTPBadRequest(_('offset param must be an integer'))
+        msg = _('offset param must be an integer')
+        raise webob.exc.HTTPBadRequest(explanation=msg)
 
     try:
         limit = int(request.GET.get('limit', max_limit))
     except ValueError:
-        raise webob.exc.HTTPBadRequest(_('limit param must be an integer'))
+        msg = _('limit param must be an integer')
+        raise webob.exc.HTTPBadRequest(explanation=msg)
 
     if limit < 0:
-        raise webob.exc.HTTPBadRequest(_('limit param must be positive'))
+        msg = _('limit param must be positive')
+        raise webob.exc.HTTPBadRequest(explanation=msg)
 
     if offset < 0:
-        raise webob.exc.HTTPBadRequest(_('offset param must be positive'))
+        msg = _('offset param must be positive')
+        raise webob.exc.HTTPBadRequest(explanation=msg)
 
     limit = min(max_limit, limit or max_limit)
     range_end = offset + limit
@@ -111,7 +115,8 @@ def limited_by_marker(items, request, max_limit=FLAGS.osapi_max_limit):
                 start_index = i + 1
                 break
         if start_index < 0:
-            raise webob.exc.HTTPBadRequest(_('marker [%s] not found' % marker))
+            msg = _('marker [%s] not found') % marker
+            raise webob.exc.HTTPBadRequest(explanation=msg)
     range_end = start_index + limit
     return items[start_index:range_end]
 
@@ -162,3 +167,28 @@ def remove_version_from_href(href):
         msg = _('href does not contain version')
         raise ValueError(msg)
     return new_href
+
+
+def get_version_from_href(href):
+    """Returns the api version in the href.
+
+    Returns the api version in the href.
+    If no version is found, 1.0 is returned
+
+    Given: 'http://www.nova.com/123'
+    Returns: '1.0'
+
+    Given: 'http://www.nova.com/v1.1'
+    Returns: '1.1'
+
+    """
+    try:
+        #finds the first instance that matches /v#.#/
+        version = re.findall(r'[/][v][0-9]+\.[0-9]+[/]', href)
+        #if no version was found, try finding /v#.# at the end of the string
+        if not version:
+            version = re.findall(r'[/][v][0-9]+\.[0-9]+$', href)
+        version = re.findall(r'[0-9]+\.[0-9]', version[0])[0]
+    except IndexError:
+        version = '1.0'
+    return version
diff --git a/nova/api/openstack/consoles.py b/nova/api/openstack/consoles.py
index 7a43fba96..d2655acfa 100644
--- a/nova/api/openstack/consoles.py
+++ b/nova/api/openstack/consoles.py
@@ -16,10 +16,10 @@
 #    under the License.
 
 from webob import exc
+import webob
 
 from nova import console
 from nova import exception
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 
 
@@ -71,12 +71,12 @@ class Controller(object):
                                         int(server_id),
                                         int(id))
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
         return _translate_detail_keys(console)
 
     def update(self, req, server_id, id):
         """You can't update a console"""
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def delete(self, req, server_id, id):
         """Deletes a console"""
@@ -85,8 +85,8 @@ class Controller(object):
                                             int(server_id),
                                             int(id))
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()
+            raise exc.HTTPNotFound()
+        return webob.Response(status_int=202)
 
 
 def create_resource():
diff --git a/nova/api/openstack/contrib/multinic.py b/nova/api/openstack/contrib/multinic.py
index 841061721..da8dcee5d 100644
--- a/nova/api/openstack/contrib/multinic.py
+++ b/nova/api/openstack/contrib/multinic.py
@@ -16,6 +16,7 @@
 """The multinic extension."""
 
 from webob import exc
+import webob
 
 from nova import compute
 from nova import log as logging
@@ -103,7 +104,7 @@ class Multinic(extensions.ExtensionDescriptor):
         except Exception, e:
             LOG.exception(_("Error in addFixedIp %s"), e)
             return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+        return webob.Response(status_int=202)
 
     def _remove_fixed_ip(self, input_dict, req, id):
         """Removes an IP from an instance."""
@@ -122,4 +123,4 @@ class Multinic(extensions.ExtensionDescriptor):
         except Exception, e:
             LOG.exception(_("Error in removeFixedIp %s"), e)
             return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+        return webob.Response(status_int=202)
diff --git a/nova/api/openstack/contrib/volumes.py b/nova/api/openstack/contrib/volumes.py
index e5e2c5b50..867fe301e 100644
--- a/nova/api/openstack/contrib/volumes.py
+++ b/nova/api/openstack/contrib/volumes.py
@@ -16,15 +16,18 @@
 """The volumes extension."""
 
 from webob import exc
+import webob
 
 from nova import compute
 from nova import exception
 from nova import flags
 from nova import log as logging
+from nova import quota
 from nova import volume
 from nova.api.openstack import common
 from nova.api.openstack import extensions
 from nova.api.openstack import faults
+from nova.api.openstack import servers
 
 
 LOG = logging.getLogger("nova.api.volumes")
@@ -104,7 +107,7 @@ class VolumeController(object):
             self.volume_api.delete(context, volume_id=id)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()
+        return webob.Response(status_int=202)
 
     def index(self, req):
         """Returns a summary list of volumes."""
@@ -279,7 +282,7 @@ class VolumeAttachmentController(object):
         self.compute_api.detach_volume(context,
                                        volume_id=volume_id)
 
-        return exc.HTTPAccepted()
+        return webob.Response(status_int=202)
 
     def _items(self, req, server_id, entity_maker):
         """Returns a list of attachments, transformed through entity_maker."""
@@ -296,6 +299,53 @@ class VolumeAttachmentController(object):
         return {'volumeAttachments': res}
 
 
+class BootFromVolumeController(servers.ControllerV11):
+    """The boot from volume API controller for the Openstack API."""
+
+    def _create_instance(self, context, instance_type, image_href, **kwargs):
+        try:
+            return self.compute_api.create(context, instance_type,
+                                           image_href, **kwargs)
+        except quota.QuotaError as error:
+            self.helper._handle_quota_error(error)
+        except exception.ImageNotFound as error:
+            msg = _("Can not find requested image")
+            raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+
+    def create(self, req, body):
+        """ Creates a new server for a given user """
+        extra_values = None
+        try:
+
+            def get_kwargs(context, instance_type, image_href, **kwargs):
+                kwargs['context'] = context
+                kwargs['instance_type'] = instance_type
+                kwargs['image_href'] = image_href
+                return kwargs
+
+            extra_values, kwargs = self.helper.create_instance(req, body,
+                                                               get_kwargs)
+
+            block_device_mapping = body['server'].get('block_device_mapping')
+            kwargs['block_device_mapping'] = block_device_mapping
+
+            instances = self._create_instance(**kwargs)
+        except faults.Fault, f:
+            return f
+
+        # We can only return 1 instance via the API, if we happen to
+        # build more than one...  instances is a list, so we'll just
+        # use the first one..
+        inst = instances[0]
+        for key in ['instance_type', 'image_ref']:
+            inst[key] = extra_values[key]
+
+        builder = self._get_view_builder(req)
+        server = builder.build(inst, is_detail=True)
+        server['server']['adminPass'] = extra_values['password']
+        return server
+
+
 class Volumes(extensions.ExtensionDescriptor):
     def get_name(self):
         return "Volumes"
@@ -329,4 +379,8 @@ class Volumes(extensions.ExtensionDescriptor):
                                                 collection_name='servers'))
         resources.append(res)
 
+        res = extensions.ResourceExtension('os-volumes_boot',
+                                           BootFromVolumeController())
+        resources.append(res)
+
         return resources
diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 2654e3c40..f8317565e 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -28,7 +28,6 @@ from nova import quota
 from nova import utils
 
 from nova.compute import instance_types
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 from nova.auth import manager as auth_manager
 
@@ -70,11 +69,14 @@ class CreateInstanceHelper(object):
         return type from this method is left to the caller.
         """
         if not body:
-            raise faults.Fault(exc.HTTPUnprocessableEntity())
+            raise exc.HTTPUnprocessableEntity()
 
-        context = req.environ['nova.context']
+        if not 'server' in body:
+            raise exc.HTTPUnprocessableEntity()
 
-        password = self.controller._get_server_admin_password(body['server'])
+        server_dict = body['server']
+        context = req.environ['nova.context']
+        password = self.controller._get_server_admin_password(server_dict)
 
         key_name = None
         key_data = None
@@ -94,28 +96,32 @@ class CreateInstanceHelper(object):
         except Exception, e:
             msg = _("Cannot find requested image %(image_href)s: %(e)s" %
                                                                     locals())
-            raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+            raise exc.HTTPBadRequest(explanation=msg)
 
-        personality = body['server'].get('personality')
+        personality = server_dict.get('personality')
 
         injected_files = []
         if personality:
             injected_files = self._get_injected_files(personality)
 
-        flavor_id = self.controller._flavor_id_from_req_data(body)
+        try:
+            flavor_id = self.controller._flavor_id_from_req_data(body)
+        except ValueError as error:
+            msg = _("Invalid flavorRef provided.")
+            raise exc.HTTPBadRequest(explanation=msg)
 
-        if not 'name' in body['server']:
+        if not 'name' in server_dict:
             msg = _("Server name is not defined")
             raise exc.HTTPBadRequest(explanation=msg)
 
-        zone_blob = body['server'].get('blob')
-        name = body['server']['name']
+        zone_blob = server_dict.get('blob')
+        name = server_dict['name']
         self._validate_server_name(name)
         name = name.strip()
 
-        reservation_id = body['server'].get('reservation_id')
-        min_count = body['server'].get('min_count')
-        max_count = body['server'].get('max_count')
+        reservation_id = server_dict.get('reservation_id')
+        min_count = server_dict.get('min_count')
+        max_count = server_dict.get('max_count')
         # min_count and max_count are optional.  If they exist, they come
         # in as strings.  We want to default 'min_count' to 1, and default
         # 'max_count' to be 'min_count'.
@@ -142,7 +148,7 @@ class CreateInstanceHelper(object):
                                   display_description=name,
                                   key_name=key_name,
                                   key_data=key_data,
-                                  metadata=body['server'].get('metadata', {}),
+                                  metadata=server_dict.get('metadata', {}),
                                   injected_files=injected_files,
                                   admin_password=password,
                                   zone_blob=zone_blob,
@@ -153,8 +159,10 @@ class CreateInstanceHelper(object):
             self._handle_quota_error(error)
         except exception.ImageNotFound as error:
             msg = _("Can not find requested image")
-            raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
-
+            raise exc.HTTPBadRequest(explanation=msg)
+        except exception.FlavorNotFound as error:
+            msg = _("Invalid flavorRef provided.")
+            raise exc.HTTPBadRequest(explanation=msg)
         # Let the caller deal with unhandled exceptions.
 
     def _handle_quota_error(self, error):
@@ -277,7 +285,7 @@ class CreateInstanceHelper(object):
         return password
 
 
-class ServerXMLDeserializer(wsgi.XMLDeserializer):
+class ServerXMLDeserializer(wsgi.MetadataXMLDeserializer):
     """
     Deserializer to handle xml-formatted server create requests.
 
@@ -294,11 +302,12 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer):
     def _extract_server(self, node):
         """Marshal the server attribute of a parsed request"""
         server = {}
-        server_node = self._find_first_child_named(node, 'server')
+        server_node = self.find_first_child_named(node, 'server')
         for attr in ["name", "imageId", "flavorId", "imageRef", "flavorRef"]:
             if server_node.getAttribute(attr):
                 server[attr] = server_node.getAttribute(attr)
-        metadata = self._extract_metadata(server_node)
+        metadata_node = self.find_first_child_named(server_node, "metadata")
+        metadata = self.extract_metadata(metadata_node)
         if metadata is not None:
             server["metadata"] = metadata
         personality = self._extract_personality(server_node)
@@ -306,49 +315,17 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer):
             server["personality"] = personality
         return server
 
-    def _extract_metadata(self, server_node):
-        """Marshal the metadata attribute of a parsed request"""
-        metadata_node = self._find_first_child_named(server_node, "metadata")
-        if metadata_node is None:
-            return None
-        metadata = {}
-        for meta_node in self._find_children_named(metadata_node, "meta"):
-            key = meta_node.getAttribute("key")
-            metadata[key] = self._extract_text(meta_node)
-        return metadata
-
     def _extract_personality(self, server_node):
         """Marshal the personality attribute of a parsed request"""
         personality_node = \
-                self._find_first_child_named(server_node, "personality")
+                self.find_first_child_named(server_node, "personality")
         if personality_node is None:
             return None
         personality = []
-        for file_node in self._find_children_named(personality_node, "file"):
+        for file_node in self.find_children_named(personality_node, "file"):
             item = {}
             if file_node.hasAttribute("path"):
                 item["path"] = file_node.getAttribute("path")
-            item["contents"] = self._extract_text(file_node)
+            item["contents"] = self.extract_text(file_node)
             personality.append(item)
         return personality
-
-    def _find_first_child_named(self, parent, name):
-        """Search a nodes children for the first child with a given name"""
-        for node in parent.childNodes:
-            if node.nodeName == name:
-                return node
-        return None
-
-    def _find_children_named(self, parent, name):
-        """Return all of a nodes children who have the given name"""
-        for node in parent.childNodes:
-            if node.nodeName == name:
-                yield node
-
-    def _extract_text(self, node):
-        """Get the text field contained by the given node"""
-        if len(node.childNodes) == 1:
-            child = node.childNodes[0]
-            if child.nodeType == child.TEXT_NODE:
-                return child.nodeValue
-        return ""
diff --git a/nova/api/openstack/extensions.py b/nova/api/openstack/extensions.py
index da06ecd15..cc889703e 100644
--- a/nova/api/openstack/extensions.py
+++ b/nova/api/openstack/extensions.py
@@ -23,6 +23,7 @@ import sys
 import routes
 import webob.dec
 import webob.exc
+from xml.etree import ElementTree
 
 from nova import exception
 from nova import flags
@@ -194,7 +195,7 @@ class ExtensionsResource(wsgi.Resource):
     def show(self, req, id):
         # NOTE(dprince): the extensions alias is used as the 'id' for show
         ext = self.extension_manager.extensions[id]
-        return self._translate(ext)
+        return dict(extension=self._translate(ext))
 
     def delete(self, req, id):
         raise faults.Fault(webob.exc.HTTPNotFound())
@@ -258,15 +259,18 @@ class ExtensionMiddleware(base_wsgi.Middleware):
 
         mapper = routes.Mapper()
 
+        serializer = wsgi.ResponseSerializer(
+            {'application/xml': ExtensionsXMLSerializer()})
         # extended resources
         for resource in ext_mgr.get_resources():
             LOG.debug(_('Extended resource: %s'),
                         resource.collection)
             mapper.resource(resource.collection, resource.collection,
-                            controller=wsgi.Resource(resource.controller),
-                            collection=resource.collection_actions,
-                            member=resource.member_actions,
-                            parent_resource=resource.parent)
+                controller=wsgi.Resource(
+                    resource.controller, serializer=serializer),
+                collection=resource.collection_actions,
+                member=resource.member_actions,
+                parent_resource=resource.parent)
 
         # extended actions
         action_resources = self._action_ext_resources(application, ext_mgr,
@@ -462,3 +466,40 @@ class ResourceExtension(object):
         self.parent = parent
         self.collection_actions = collection_actions
         self.member_actions = member_actions
+
+
+class ExtensionsXMLSerializer(wsgi.XMLDictSerializer):
+
+    def show(self, ext_dict):
+        ext = self._create_ext_elem(ext_dict['extension'])
+        return self._to_xml(ext)
+
+    def index(self, exts_dict):
+        exts = ElementTree.Element('extensions')
+        for ext_dict in exts_dict['extensions']:
+            exts.append(self._create_ext_elem(ext_dict))
+        return self._to_xml(exts)
+
+    def _create_ext_elem(self, ext_dict):
+        """Create an extension xml element from a dict."""
+        ext_elem = ElementTree.Element('extension')
+        ext_elem.set('name', ext_dict['name'])
+        ext_elem.set('namespace', ext_dict['namespace'])
+        ext_elem.set('alias', ext_dict['alias'])
+        ext_elem.set('updated', ext_dict['updated'])
+        desc = ElementTree.Element('description')
+        desc.text = ext_dict['description']
+        ext_elem.append(desc)
+        for link in ext_dict.get('links', []):
+            elem = ElementTree.Element('atom:link')
+            elem.set('rel', link['rel'])
+            elem.set('href', link['href'])
+            elem.set('type', link['type'])
+            ext_elem.append(elem)
+        return ext_elem
+
+    def _to_xml(self, root):
+        """Convert the xml tree object to an xml string."""
+        root.set('xmlns', wsgi.XMLNS_V11)
+        root.set('xmlns:atom', wsgi.XMLNS_ATOM)
+        return ElementTree.tostring(root, encoding='UTF-8')
diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
index b9a23c126..1ab45d4f1 100644
--- a/nova/api/openstack/faults.py
+++ b/nova/api/openstack/faults.py
@@ -19,6 +19,7 @@
 import webob.dec
 import webob.exc
 
+from nova.api.openstack import common
 from nova.api.openstack import wsgi
 
 
@@ -40,6 +41,7 @@ class Fault(webob.exc.HTTPException):
     def __init__(self, exception):
         """Create a Fault for the given webob.exc.exception."""
         self.wrapped_exc = exception
+        self.status_int = exception.status_int
 
     @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
@@ -60,9 +62,13 @@ class Fault(webob.exc.HTTPException):
 
         content_type = req.best_match_content_type()
 
+        xml_serializer = {
+            '1.0': wsgi.XMLDictSerializer(metadata, wsgi.XMLNS_V10),
+            '1.1': wsgi.XMLDictSerializer(metadata, wsgi.XMLNS_V11),
+        }[common.get_version_from_href(req.url)]
+
         serializer = {
-            'application/xml': wsgi.XMLDictSerializer(metadata=metadata,
-                                                      xmlns=wsgi.XMLNS_V10),
+            'application/xml': xml_serializer,
             'application/json': wsgi.JSONDictSerializer(),
         }[content_type]
 
@@ -99,9 +105,13 @@ class OverLimitFault(webob.exc.HTTPException):
         content_type = request.best_match_content_type()
         metadata = {"attributes": {"overLimitFault": "code"}}
 
+        xml_serializer = {
+            '1.0': wsgi.XMLDictSerializer(metadata, wsgi.XMLNS_V10),
+            '1.1': wsgi.XMLDictSerializer(metadata, wsgi.XMLNS_V11),
+        }[common.get_version_from_href(request.url)]
+
         serializer = {
-            'application/xml': wsgi.XMLDictSerializer(metadata=metadata,
-                                                      xmlns=wsgi.XMLNS_V10),
+            'application/xml': xml_serializer,
             'application/json': wsgi.JSONDictSerializer(),
         }[content_type]
 
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 6fab13147..b4bda68d4 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -16,6 +16,7 @@
 #    under the License.
 
 import webob
+import xml.dom.minidom as minidom
 
 from nova import db
 from nova import exception
@@ -74,19 +75,65 @@ class ControllerV11(Controller):
         return views.flavors.ViewBuilderV11(base_url)
 
 
+class FlavorXMLSerializer(wsgi.XMLDictSerializer):
+
+    def __init__(self):
+        super(FlavorXMLSerializer, self).__init__(xmlns=wsgi.XMLNS_V11)
+
+    def _flavor_to_xml(self, xml_doc, flavor, detailed):
+        flavor_node = xml_doc.createElement('flavor')
+        flavor_node.setAttribute('id', str(flavor['id']))
+        flavor_node.setAttribute('name', flavor['name'])
+
+        if detailed:
+            flavor_node.setAttribute('ram', str(flavor['ram']))
+            flavor_node.setAttribute('disk', str(flavor['disk']))
+
+        link_nodes = self._create_link_nodes(xml_doc, flavor['links'])
+        for link_node in link_nodes:
+            flavor_node.appendChild(link_node)
+        return flavor_node
+
+    def _flavors_list_to_xml(self, xml_doc, flavors, detailed):
+        container_node = xml_doc.createElement('flavors')
+
+        for flavor in flavors:
+            item_node = self._flavor_to_xml(xml_doc, flavor, detailed)
+            container_node.appendChild(item_node)
+        return container_node
+
+    def show(self, flavor_container):
+        xml_doc = minidom.Document()
+        flavor = flavor_container['flavor']
+        node = self._flavor_to_xml(xml_doc, flavor, True)
+        return self.to_xml_string(node, True)
+
+    def detail(self, flavors_container):
+        xml_doc = minidom.Document()
+        flavors = flavors_container['flavors']
+        node = self._flavors_list_to_xml(xml_doc, flavors, True)
+        return self.to_xml_string(node, True)
+
+    def index(self, flavors_container):
+        xml_doc = minidom.Document()
+        flavors = flavors_container['flavors']
+        node = self._flavors_list_to_xml(xml_doc, flavors, False)
+        return self.to_xml_string(node, True)
+
+
 def create_resource(version='1.0'):
     controller = {
         '1.0': ControllerV10,
         '1.1': ControllerV11,
     }[version]()
 
-    xmlns = {
-        '1.0': wsgi.XMLNS_V10,
-        '1.1': wsgi.XMLNS_V11,
+    xml_serializer = {
+        '1.0': wsgi.XMLDictSerializer(xmlns=wsgi.XMLNS_V10),
+        '1.1': FlavorXMLSerializer(),
     }[version]
 
     body_serializers = {
-        'application/xml': wsgi.XMLDictSerializer(xmlns=xmlns),
+        'application/xml': xml_serializer,
     }
 
     serializer = wsgi.ResponseSerializer(body_serializers)
diff --git a/nova/api/openstack/image_metadata.py b/nova/api/openstack/image_metadata.py
index 4f33844fa..ee181c924 100644
--- a/nova/api/openstack/image_metadata.py
+++ b/nova/api/openstack/image_metadata.py
@@ -22,7 +22,6 @@ from nova import flags
 from nova import image
 from nova import quota
 from nova import utils
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 
 
@@ -62,7 +61,7 @@ class Controller(object):
         if id in metadata:
             return {'meta': {id: metadata[id]}}
         else:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
 
     def create(self, req, image_id, body):
         context = req.environ['nova.context']
@@ -97,20 +96,54 @@ class Controller(object):
         self._check_quota_limit(context, metadata)
         img['properties'] = metadata
         self.image_service.update(context, image_id, img, None)
+        return dict(meta=meta)
 
-        return req.body
+    def update_all(self, req, image_id, body):
+        context = req.environ['nova.context']
+        img = self.image_service.show(context, image_id)
+        metadata = body.get('metadata', {})
+        self._check_quota_limit(context, metadata)
+        img['properties'] = metadata
+        self.image_service.update(context, image_id, img, None)
+        return dict(metadata=metadata)
 
     def delete(self, req, image_id, id):
         context = req.environ['nova.context']
         img = self.image_service.show(context, image_id)
         metadata = self._get_metadata(context, image_id)
         if not id in metadata:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
         metadata.pop(id)
         img['properties'] = metadata
         self.image_service.update(context, image_id, img, None)
 
 
+class ImageMetadataXMLDeserializer(wsgi.MetadataXMLDeserializer):
+
+    def _extract_metadata_container(self, datastring):
+        dom = minidom.parseString(datastring)
+        metadata_node = self.find_first_child_named(dom, "metadata")
+        metadata = self.extract_metadata(metadata_node)
+        return {'body': {'metadata': metadata}}
+
+    def create(self, datastring):
+        return self._extract_metadata_container(datastring)
+
+    def update_all(self, datastring):
+        return self._extract_metadata_container(datastring)
+
+    def update(self, datastring):
+        dom = minidom.parseString(datastring)
+        metadata_item = self.extract_metadata(dom)
+        return {'body': {'meta': metadata_item}}
+
+
+class HeadersSerializer(wsgi.ResponseHeadersSerializer):
+
+    def delete(self, response, data):
+        response.status_int = 204
+
+
 class ImageMetadataXMLSerializer(wsgi.XMLDictSerializer):
     def __init__(self, xmlns=wsgi.XMLNS_V11):
         super(ImageMetadataXMLSerializer, self).__init__(xmlns=xmlns)
@@ -144,6 +177,9 @@ class ImageMetadataXMLSerializer(wsgi.XMLDictSerializer):
     def create(self, metadata_dict):
         return self._meta_list_to_xml_string(metadata_dict)
 
+    def update_all(self, metadata_dict):
+        return self._meta_list_to_xml_string(metadata_dict)
+
     def _meta_item_to_xml_string(self, meta_item_dict):
         xml_doc = minidom.Document()
         item_key, item_value = meta_item_dict.items()[0]
@@ -158,11 +194,21 @@ class ImageMetadataXMLSerializer(wsgi.XMLDictSerializer):
     def update(self, meta_item_dict):
         return self._meta_item_to_xml_string(meta_item_dict['meta'])
 
+    def default(self, *args, **kwargs):
+        return ''
+
 
 def create_resource():
+    headers_serializer = HeadersSerializer()
+
+    body_deserializers = {
+        'application/xml': ImageMetadataXMLDeserializer(),
+    }
+
     body_serializers = {
         'application/xml': ImageMetadataXMLSerializer(),
     }
-    serializer = wsgi.ResponseSerializer(body_serializers)
+    serializer = wsgi.ResponseSerializer(body_serializers, headers_serializer)
+    deserializer = wsgi.RequestDeserializer(body_deserializers)
 
-    return wsgi.Resource(Controller(), serializer=serializer)
+    return wsgi.Resource(Controller(), deserializer, serializer)
diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index d0317583e..30e4fd389 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -25,7 +25,6 @@ from nova import flags
 import nova.image
 from nova import log
 from nova.api.openstack import common
-from nova.api.openstack import faults
 from nova.api.openstack import image_metadata
 from nova.api.openstack import servers
 from nova.api.openstack.views import images as images_view
@@ -35,7 +34,13 @@ from nova.api.openstack import wsgi
 LOG = log.getLogger('nova.api.openstack.images')
 FLAGS = flags.FLAGS
 
-SUPPORTED_FILTERS = ['name', 'status']
+SUPPORTED_FILTERS = {
+    'name': 'name',
+    'status': 'status',
+    'changes-since': 'changes-since',
+    'server': 'property-instance_ref',
+    'type': 'property-image_type',
+}
 
 
 class Controller(object):
@@ -62,8 +67,9 @@ class Controller(object):
         filters = {}
         for param in req.str_params:
             if param in SUPPORTED_FILTERS or param.startswith('property-'):
-                filters[param] = req.str_params.get(param)
-
+                # map filter name or carry through if property-*
+                filter_name = SUPPORTED_FILTERS.get(param, param)
+                filters[filter_name] = req.str_params.get(param)
         return filters
 
     def show(self, req, id):
@@ -78,7 +84,7 @@ class Controller(object):
             image = self._image_service.show(context, id)
         except (exception.NotFound, exception.InvalidImageRef):
             explanation = _("Image not found.")
-            raise faults.Fault(webob.exc.HTTPNotFound(explanation=explanation))
+            raise webob.exc.HTTPNotFound(explanation=explanation)
 
         return dict(image=self.get_builder(req).build(image, detail=True))
 
diff --git a/nova/api/openstack/ips.py b/nova/api/openstack/ips.py
index 1ebfdb831..a74fae487 100644
--- a/nova/api/openstack/ips.py
+++ b/nova/api/openstack/ips.py
@@ -16,11 +16,11 @@
 #    under the License.
 
 import time
+from xml.dom import minidom
 
 from webob import exc
 
 import nova
-from nova.api.openstack import faults
 import nova.api.openstack.views.addresses
 from nova.api.openstack import wsgi
 from nova import db
@@ -37,14 +37,14 @@ class Controller(object):
             instance = self.compute_api.get(
                 req.environ['nova.context'], server_id)
         except nova.exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
         return instance
 
     def create(self, req, server_id, body):
-        return faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def delete(self, req, server_id, id):
-        return faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
 
 class ControllerV10(Controller):
@@ -63,7 +63,7 @@ class ControllerV10(Controller):
             view = builder.build_public_parts(instance)
         else:
             msg = _("Only private and public networks available")
-            return faults.Fault(exc.HTTPNotFound(explanation=msg))
+            raise exc.HTTPNotFound(explanation=msg)
 
         return {id: view}
 
@@ -86,7 +86,7 @@ class ControllerV11(Controller):
 
         if network is None:
             msg = _("Instance is not a member of specified network")
-            return faults.Fault(exc.HTTPNotFound(explanation=msg))
+            raise exc.HTTPNotFound(explanation=msg)
 
         return network
 
@@ -101,17 +101,51 @@ class ControllerV11(Controller):
         return nova.api.openstack.views.addresses.ViewBuilderV11()
 
 
+class IPXMLSerializer(wsgi.XMLDictSerializer):
+    def __init__(self, xmlns=wsgi.XMLNS_V11):
+        super(IPXMLSerializer, self).__init__(xmlns=xmlns)
+
+    def _ip_to_xml(self, xml_doc, ip_dict):
+        ip_node = xml_doc.createElement('ip')
+        ip_node.setAttribute('addr', ip_dict['addr'])
+        ip_node.setAttribute('version', str(ip_dict['version']))
+        return ip_node
+
+    def _network_to_xml(self, xml_doc, network_id, ip_dicts):
+        network_node = xml_doc.createElement('network')
+        network_node.setAttribute('id', network_id)
+
+        for ip_dict in ip_dicts:
+            ip_node = self._ip_to_xml(xml_doc, ip_dict)
+            network_node.appendChild(ip_node)
+
+        return network_node
+
+    def networks_to_xml(self, xml_doc, networks_container):
+        addresses_node = xml_doc.createElement('addresses')
+        for (network_id, ip_dicts) in networks_container.items():
+            network_node = self._network_to_xml(xml_doc, network_id, ip_dicts)
+            addresses_node.appendChild(network_node)
+        return addresses_node
+
+    def show(self, network_container):
+        (network_id, ip_dicts) = network_container.items()[0]
+        xml_doc = minidom.Document()
+        node = self._network_to_xml(xml_doc, network_id, ip_dicts)
+        return self.to_xml_string(node, False)
+
+    def index(self, addresses_container):
+        xml_doc = minidom.Document()
+        node = self.networks_to_xml(xml_doc, addresses_container['addresses'])
+        return self.to_xml_string(node, False)
+
+
 def create_resource(version):
     controller = {
         '1.0': ControllerV10,
         '1.1': ControllerV11,
     }[version]()
 
-    xmlns = {
-        '1.0': wsgi.XMLNS_V10,
-        '1.1': wsgi.XMLNS_V11,
-    }[version]
-
     metadata = {
         'list_collections': {
             'public':  {'item_name': 'ip', 'item_key': 'addr'},
@@ -119,10 +153,11 @@ def create_resource(version):
         },
     }
 
-    body_serializers = {
-        'application/xml': wsgi.XMLDictSerializer(metadata=metadata,
-                                                  xmlns=xmlns),
-    }
-    serializer = wsgi.ResponseSerializer(body_serializers)
+    xml_serializer = {
+        '1.0': wsgi.XMLDictSerializer(metadata=metadata, xmlns=wsgi.XMLNS_V11),
+        '1.1': IPXMLSerializer(),
+    }[version]
+
+    serializer = wsgi.ResponseSerializer({'application/xml': xml_serializer})
 
     return wsgi.Resource(controller, serializer=serializer)
diff --git a/nova/api/openstack/limits.py b/nova/api/openstack/limits.py
index bc76547d8..86afa3b62 100644
--- a/nova/api/openstack/limits.py
+++ b/nova/api/openstack/limits.py
@@ -25,6 +25,7 @@ import re
 import time
 import urllib
 import webob.exc
+from xml.dom import minidom
 
 from collections import defaultdict
 
@@ -76,6 +77,58 @@ class LimitsControllerV11(LimitsController):
         return limits_views.ViewBuilderV11()
 
 
+class LimitsXMLSerializer(wsgi.XMLDictSerializer):
+
+    xmlns = wsgi.XMLNS_V11
+
+    def __init__(self):
+        pass
+
+    def _create_rates_node(self, xml_doc, rates):
+        rates_node = xml_doc.createElement('rates')
+        for rate in rates:
+            rate_node = xml_doc.createElement('rate')
+            rate_node.setAttribute('uri', rate['uri'])
+            rate_node.setAttribute('regex', rate['regex'])
+
+            for limit in rate['limit']:
+                limit_node = xml_doc.createElement('limit')
+                limit_node.setAttribute('value', str(limit['value']))
+                limit_node.setAttribute('verb', limit['verb'])
+                limit_node.setAttribute('remaining', str(limit['remaining']))
+                limit_node.setAttribute('unit', limit['unit'])
+                limit_node.setAttribute('next-available',
+                                        str(limit['next-available']))
+                rate_node.appendChild(limit_node)
+
+            rates_node.appendChild(rate_node)
+        return rates_node
+
+    def _create_absolute_node(self, xml_doc, absolutes):
+        absolute_node = xml_doc.createElement('absolute')
+        for key, value in absolutes.iteritems():
+            limit_node = xml_doc.createElement('limit')
+            limit_node.setAttribute('name', key)
+            limit_node.setAttribute('value', str(value))
+            absolute_node.appendChild(limit_node)
+        return absolute_node
+
+    def _limits_to_xml(self, xml_doc, limits):
+        limits_node = xml_doc.createElement('limits')
+        rates_node = self._create_rates_node(xml_doc, limits['rate'])
+        limits_node.appendChild(rates_node)
+
+        absolute_node = self._create_absolute_node(xml_doc, limits['absolute'])
+        limits_node.appendChild(absolute_node)
+
+        return limits_node
+
+    def index(self, limits_dict):
+        xml_doc = minidom.Document()
+        node = self._limits_to_xml(xml_doc, limits_dict['limits'])
+        return self.to_xml_string(node, False)
+
+
 def create_resource(version='1.0'):
     controller = {
         '1.0': LimitsControllerV10,
@@ -97,9 +150,13 @@ def create_resource(version='1.0'):
         },
     }
 
+    xml_serializer = {
+        '1.0': wsgi.XMLDictSerializer(xmlns=xmlns, metadata=metadata),
+        '1.1': LimitsXMLSerializer(),
+    }[version]
+
     body_serializers = {
-        'application/xml': wsgi.XMLDictSerializer(xmlns=xmlns,
-                                                  metadata=metadata),
+        'application/xml': xml_serializer,
     }
 
     serializer = wsgi.ResponseSerializer(body_serializers)
diff --git a/nova/api/openstack/server_metadata.py b/nova/api/openstack/server_metadata.py
index 3b9169f81..d4f42bbf5 100644
--- a/nova/api/openstack/server_metadata.py
+++ b/nova/api/openstack/server_metadata.py
@@ -18,7 +18,6 @@
 from webob import exc
 
 from nova import compute
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 from nova import exception
 from nova import quota
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 8ec74b387..2573fc48c 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -17,6 +17,7 @@ import base64
 import traceback
 
 from webob import exc
+import webob
 
 from nova import compute
 from nova import db
@@ -26,7 +27,6 @@ from nova import log as logging
 from nova import utils
 from nova.api.openstack import common
 from nova.api.openstack import create_instance_helper as helper
-from nova.api.openstack import faults
 import nova.api.openstack.views.addresses
 import nova.api.openstack.views.flavors
 import nova.api.openstack.views.images
@@ -155,17 +155,14 @@ class Controller(object):
                 req.environ['nova.context'], id)
             return self._build_view(req, instance, is_detail=True)
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
 
     def create(self, req, body):
         """ Creates a new server for a given user """
         extra_values = None
         result = None
-        try:
-            extra_values, instances = self.helper.create_instance(
-                    req, body, self.compute_api.create)
-        except faults.Fault, f:
-            return f
+        extra_values, instances = self.helper.create_instance(
+                req, body, self.compute_api.create)
 
         # We can only return 1 instance via the API, if we happen to
         # build more than one...  instances is a list, so we'll just
@@ -185,7 +182,7 @@ class Controller(object):
             raise exc.HTTPUnprocessableEntity()
 
         if not body:
-            return faults.Fault(exc.HTTPUnprocessableEntity())
+            raise exc.HTTPUnprocessableEntity()
 
         ctxt = req.environ['nova.context']
         update_dict = {}
@@ -200,7 +197,7 @@ class Controller(object):
         try:
             self.compute_api.update(ctxt, id, **update_dict)
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
 
         return exc.HTTPNoContent()
 
@@ -224,7 +221,7 @@ class Controller(object):
         for key in actions.keys():
             if key in body:
                 return actions[key](body, req, id)
-        return faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def _action_change_password(self, input_dict, req, id):
         return exc.HTTPNotImplemented()
@@ -234,7 +231,7 @@ class Controller(object):
             self.compute_api.confirm_resize(req.environ['nova.context'], id)
         except Exception, e:
             LOG.exception(_("Error in confirm-resize %s"), e)
-            return faults.Fault(exc.HTTPBadRequest())
+            raise exc.HTTPBadRequest()
         return exc.HTTPNoContent()
 
     def _action_revert_resize(self, input_dict, req, id):
@@ -242,8 +239,8 @@ class Controller(object):
             self.compute_api.revert_resize(req.environ['nova.context'], id)
         except Exception, e:
             LOG.exception(_("Error in revert-resize %s"), e)
-            return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+            raise exc.HTTPBadRequest()
+        return webob.Response(status_int=202)
 
     def _action_resize(self, input_dict, req, id):
         return exc.HTTPNotImplemented()
@@ -253,23 +250,23 @@ class Controller(object):
             reboot_type = input_dict['reboot']['type']
         else:
             LOG.exception(_("Missing argument 'type' for reboot"))
-            return faults.Fault(exc.HTTPUnprocessableEntity())
+            raise exc.HTTPUnprocessableEntity()
         try:
             # TODO(gundlach): pass reboot_type, support soft reboot in
             # virt driver
             self.compute_api.reboot(req.environ['nova.context'], id)
         except Exception, e:
             LOG.exception(_("Error in reboot %s"), e)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     def _action_migrate(self, input_dict, req, id):
         try:
             self.compute_api.resize(req.environ['nova.context'], id)
         except Exception, e:
             LOG.exception(_("Error in migrate %s"), e)
-            return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+            raise exc.HTTPBadRequest()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def lock(self, req, id):
@@ -284,8 +281,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::lock %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def unlock(self, req, id):
@@ -300,8 +297,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::unlock %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def get_lock(self, req, id):
@@ -315,8 +312,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::get_lock %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def reset_network(self, req, id, body):
@@ -330,8 +327,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::reset_network %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def inject_network_info(self, req, id, body):
@@ -345,8 +342,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::inject_network_info %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def pause(self, req, id, body):
@@ -357,8 +354,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::pause %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def unpause(self, req, id, body):
@@ -369,8 +366,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::unpause %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def suspend(self, req, id, body):
@@ -381,8 +378,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("compute.api::suspend %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def resume(self, req, id, body):
@@ -393,8 +390,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("compute.api::resume %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def rescue(self, req, id):
@@ -405,8 +402,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("compute.api::rescue %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def unrescue(self, req, id):
@@ -417,8 +414,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("compute.api::unrescue %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def get_ajax_console(self, req, id):
@@ -427,8 +424,8 @@ class Controller(object):
             self.compute_api.get_ajax_console(req.environ['nova.context'],
                 int(id))
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()
+            raise exc.HTTPNotFound()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def get_vnc_console(self, req, id):
@@ -437,8 +434,8 @@ class Controller(object):
             self.compute_api.get_vnc_console(req.environ['nova.context'],
                                              int(id))
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()
+            raise exc.HTTPNotFound()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def diagnostics(self, req, id):
@@ -469,8 +466,8 @@ class ControllerV10(Controller):
         try:
             self.compute_api.delete(req.environ['nova.context'], id)
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()
+            raise exc.HTTPNotFound()
+        return webob.Response(status_int=202)
 
     def _items(self, req, is_detail):
         """Returns a list of servers based on the request.
@@ -532,40 +529,33 @@ class ControllerV10(Controller):
 
     def _action_resize(self, input_dict, req, id):
         """ Resizes a given instance to the flavor size requested """
-        try:
-            if 'resize' in input_dict and 'flavorId' in input_dict['resize']:
-                flavor_id = input_dict['resize']['flavorId']
-                self.compute_api.resize(req.environ['nova.context'], id,
-                        flavor_id)
-            else:
-                LOG.exception(_("Missing 'flavorId' argument for resize"))
-                return faults.Fault(exc.HTTPUnprocessableEntity())
-        except Exception, e:
-            LOG.exception(_("Error in resize %s"), e)
-            return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+        if 'resize' in input_dict and 'flavorId' in input_dict['resize']:
+            flavor_id = input_dict['resize']['flavorId']
+            self.compute_api.resize(req.environ['nova.context'], id,
+                    flavor_id)
+        else:
+            LOG.exception(_("Missing 'flavorId' argument for resize"))
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     def _action_rebuild(self, info, request, instance_id):
         context = request.environ['nova.context']
-        instance_id = int(instance_id)
 
         try:
             image_id = info["rebuild"]["imageId"]
         except (KeyError, TypeError):
             msg = _("Could not parse imageId from request.")
             LOG.debug(msg)
-            return faults.Fault(exc.HTTPBadRequest(explanation=msg))
+            raise exc.HTTPBadRequest(explanation=msg)
 
         try:
             self.compute_api.rebuild(context, instance_id, image_id)
         except exception.BuildInProgress:
-            msg = _("Instance %d is currently being rebuilt.") % instance_id
+            msg = _("Instance %s is currently being rebuilt.") % instance_id
             LOG.debug(msg)
-            return faults.Fault(exc.HTTPConflict(explanation=msg))
+            raise exc.HTTPConflict(explanation=msg)
 
-        response = exc.HTTPAccepted()
-        response.empty_body = True
-        return response
+        return webob.Response(status_int=202)
 
     def _get_server_admin_password(self, server):
         """ Determine the admin password for a server on creation """
@@ -580,7 +570,7 @@ class ControllerV11(Controller):
         try:
             self.compute_api.delete(req.environ['nova.context'], id)
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
 
     def _items(self, req, is_detail):
         """Returns a list of servers based on the request.
@@ -643,7 +633,7 @@ class ControllerV11(Controller):
             msg = _("Invalid adminPass")
             return exc.HTTPBadRequest(explanation=msg)
         self.compute_api.set_admin_password(context, id, password)
-        return exc.HTTPAccepted()
+        return webob.Response(status_int=202)
 
     def _limit_items(self, items, req):
         return common.limited_by_marker(items, req)
@@ -655,7 +645,7 @@ class ControllerV11(Controller):
         except AttributeError as ex:
             msg = _("Unable to parse metadata key/value pairs.")
             LOG.debug(msg)
-            raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+            raise exc.HTTPBadRequest(explanation=msg)
 
     def _decode_personalities(self, personalities):
         """Decode the Base64-encoded personalities."""
@@ -666,14 +656,14 @@ class ControllerV11(Controller):
             except (KeyError, TypeError):
                 msg = _("Unable to parse personality path/contents.")
                 LOG.info(msg)
-                raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+                raise exc.HTTPBadRequest(explanation=msg)
 
             try:
                 personality["contents"] = base64.b64decode(contents)
             except TypeError:
                 msg = _("Personality content could not be Base64 decoded.")
                 LOG.info(msg)
-                raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+                raise exc.HTTPBadRequest(explanation=msg)
 
     def _action_resize(self, input_dict, req, id):
         """ Resizes a given instance to the flavor size requested """
@@ -685,22 +675,21 @@ class ControllerV11(Controller):
                         flavor_id)
             else:
                 LOG.exception(_("Missing 'flavorRef' argument for resize"))
-                return faults.Fault(exc.HTTPUnprocessableEntity())
+                raise exc.HTTPUnprocessableEntity()
         except Exception, e:
             LOG.exception(_("Error in resize %s"), e)
-            return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+            raise exc.HTTPBadRequest()
+        return webob.Response(status_int=202)
 
     def _action_rebuild(self, info, request, instance_id):
         context = request.environ['nova.context']
-        instance_id = int(instance_id)
 
         try:
             image_href = info["rebuild"]["imageRef"]
         except (KeyError, TypeError):
             msg = _("Could not parse imageRef from request.")
             LOG.debug(msg)
-            return faults.Fault(exc.HTTPBadRequest(explanation=msg))
+            raise exc.HTTPBadRequest(explanation=msg)
 
         personalities = info["rebuild"].get("personality", [])
         metadata = info["rebuild"].get("metadata")
@@ -714,13 +703,11 @@ class ControllerV11(Controller):
             self.compute_api.rebuild(context, instance_id, image_href, name,
                                      metadata, personalities)
         except exception.BuildInProgress:
-            msg = _("Instance %d is currently being rebuilt.") % instance_id
+            msg = _("Instance %s is currently being rebuilt.") % instance_id
             LOG.debug(msg)
-            return faults.Fault(exc.HTTPConflict(explanation=msg))
+            raise exc.HTTPConflict(explanation=msg)
 
-        response = exc.HTTPAccepted()
-        response.empty_body = True
-        return response
+        return webob.Response(status_int=202)
 
     def get_default_xmlns(self, req):
         return common.XML_NS_V11
diff --git a/nova/api/openstack/shared_ip_groups.py b/nova/api/openstack/shared_ip_groups.py
index cf2ddbabb..54d0a8334 100644
--- a/nova/api/openstack/shared_ip_groups.py
+++ b/nova/api/openstack/shared_ip_groups.py
@@ -17,7 +17,6 @@
 
 from webob import exc
 
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 
 
@@ -26,27 +25,27 @@ class Controller(object):
 
     def index(self, req, **kwargs):
         """ Returns a list of Shared IP Groups for the user """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def show(self, req, id, **kwargs):
         """ Shows in-depth information on a specific Shared IP Group """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def update(self, req, id, **kwargs):
         """ You can't update a Shared IP Group """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def delete(self, req, id, **kwargs):
         """ Deletes a Shared IP Group """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def detail(self, req, **kwargs):
         """ Returns a complete list of Shared IP Groups """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def create(self, req, **kwargs):
         """ Creates a new Shared IP group """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
 
 def create_resource():
diff --git a/nova/api/openstack/users.py b/nova/api/openstack/users.py
index 6ae1eaf2a..8dd72d559 100644
--- a/nova/api/openstack/users.py
+++ b/nova/api/openstack/users.py
@@ -19,7 +19,6 @@ from nova import exception
 from nova import flags
 from nova import log as logging
 from nova.api.openstack import common
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 from nova.auth import manager
 
@@ -69,7 +68,7 @@ class Controller(object):
             user = None
 
         if user is None:
-            raise faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
 
         return dict(user=_translate_keys(user))
 
diff --git a/nova/api/openstack/versions.py b/nova/api/openstack/versions.py
index a634c3267..df7a94b7e 100644
--- a/nova/api/openstack/versions.py
+++ b/nova/api/openstack/versions.py
@@ -15,13 +15,18 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from datetime import datetime
 import webob
 import webob.dec
+from xml.dom import minidom
 
 import nova.api.openstack.views.versions
 from nova.api.openstack import wsgi
 
 
+ATOM_XMLNS = "http://www.w3.org/2005/Atom"
+
+
 class Versions(wsgi.Resource):
     def __init__(self):
         metadata = {
@@ -32,11 +37,19 @@ class Versions(wsgi.Resource):
         }
 
         body_serializers = {
-            'application/xml': wsgi.XMLDictSerializer(metadata=metadata),
+            'application/atom+xml': VersionsAtomSerializer(metadata=metadata),
+            'application/xml': VersionsXMLSerializer(metadata=metadata),
         }
         serializer = wsgi.ResponseSerializer(body_serializers)
 
-        wsgi.Resource.__init__(self, None, serializer=serializer)
+        supported_content_types = ('application/json',
+                                   'application/xml',
+                                   'application/atom+xml')
+        deserializer = wsgi.RequestDeserializer(
+            supported_content_types=supported_content_types)
+
+        wsgi.Resource.__init__(self, None, serializer=serializer,
+                               deserializer=deserializer)
 
     def dispatch(self, request, *args):
         """Respond to a request for all OpenStack API versions."""
@@ -44,13 +57,143 @@ class Versions(wsgi.Resource):
             {
                 "id": "v1.1",
                 "status": "CURRENT",
+                #TODO(wwolf) get correct value for these
+                "updated": "2011-07-18T11:30:00Z",
             },
             {
                 "id": "v1.0",
                 "status": "DEPRECATED",
+                #TODO(wwolf) get correct value for these
+                "updated": "2010-10-09T11:30:00Z",
             },
         ]
 
         builder = nova.api.openstack.views.versions.get_view_builder(request)
         versions = [builder.build(version) for version in version_objs]
         return dict(versions=versions)
+
+
+class VersionsXMLSerializer(wsgi.XMLDictSerializer):
+    def _versions_to_xml(self, versions):
+        root = self._xml_doc.createElement('versions')
+
+        for version in versions:
+            root.appendChild(self._create_version_node(version))
+
+        return root
+
+    def _create_version_node(self, version):
+        version_node = self._xml_doc.createElement('version')
+        version_node.setAttribute('id', version['id'])
+        version_node.setAttribute('status', version['status'])
+        version_node.setAttribute('updated', version['updated'])
+
+        for link in version['links']:
+            link_node = self._xml_doc.createElement('atom:link')
+            link_node.setAttribute('rel', link['rel'])
+            link_node.setAttribute('href', link['href'])
+            version_node.appendChild(link_node)
+
+        return version_node
+
+    def default(self, data):
+        self._xml_doc = minidom.Document()
+        node = self._versions_to_xml(data['versions'])
+
+        return self.to_xml_string(node)
+
+
+class VersionsAtomSerializer(wsgi.XMLDictSerializer):
+    def __init__(self, metadata=None, xmlns=None):
+        if not xmlns:
+            self.xmlns = ATOM_XMLNS
+        else:
+            self.xmlns = xmlns
+
+    def _create_text_elem(self, name, text, type=None):
+        elem = self._xml_doc.createElement(name)
+        if type:
+            elem.setAttribute('type', type)
+        elem_text = self._xml_doc.createTextNode(text)
+        elem.appendChild(elem_text)
+        return elem
+
+    def _get_most_recent_update(self, versions):
+        recent = None
+        for version in versions:
+            updated = datetime.strptime(version['updated'],
+                                        '%Y-%m-%dT%H:%M:%SZ')
+            if not recent:
+                recent = updated
+            elif updated > recent:
+                recent = updated
+
+        return recent.strftime('%Y-%m-%dT%H:%M:%SZ')
+
+    def _get_base_url(self, link_href):
+        # Make sure no trailing /
+        link_href = link_href.rstrip('/')
+        return link_href.rsplit('/', 1)[0] + '/'
+
+    def _create_meta(self, root, versions):
+        title = self._create_text_elem('title', 'Available API Versions',
+                                       type='text')
+        # Set this updated to the most recently updated version
+        recent = self._get_most_recent_update(versions)
+        updated = self._create_text_elem('updated', recent)
+
+        base_url = self._get_base_url(versions[0]['links'][0]['href'])
+        id = self._create_text_elem('id', base_url)
+        link = self._xml_doc.createElement('link')
+        link.setAttribute('rel', 'self')
+        link.setAttribute('href', base_url)
+
+        author = self._xml_doc.createElement('author')
+        author_name = self._create_text_elem('name', 'Rackspace')
+        author_uri = self._create_text_elem('uri', 'http://www.rackspace.com/')
+        author.appendChild(author_name)
+        author.appendChild(author_uri)
+
+        root.appendChild(title)
+        root.appendChild(updated)
+        root.appendChild(id)
+        root.appendChild(author)
+        root.appendChild(link)
+
+    def _create_version_entries(self, root, versions):
+        for version in versions:
+            entry = self._xml_doc.createElement('entry')
+
+            id = self._create_text_elem('id', version['links'][0]['href'])
+            title = self._create_text_elem('title',
+                                           'Version %s' % version['id'],
+                                           type='text')
+            updated = self._create_text_elem('updated', version['updated'])
+
+            entry.appendChild(id)
+            entry.appendChild(title)
+            entry.appendChild(updated)
+
+            for link in version['links']:
+                link_node = self._xml_doc.createElement('link')
+                link_node.setAttribute('rel', link['rel'])
+                link_node.setAttribute('href', link['href'])
+            entry.appendChild(link_node)
+
+            content = self._create_text_elem('content',
+                'Version %s %s (%s)' %
+                    (version['id'],
+                     version['status'],
+                     version['updated']),
+                type='text')
+
+            entry.appendChild(content)
+            root.appendChild(entry)
+
+    def default(self, data):
+        self._xml_doc = minidom.Document()
+        node = self._xml_doc.createElementNS(self.xmlns, 'feed')
+        self._create_meta(node, data['versions'])
+        self._create_version_entries(node, data['versions'])
+
+        return self.to_xml_string(node)
diff --git a/nova/api/openstack/views/addresses.py b/nova/api/openstack/views/addresses.py
index a242efa45..ddbf7a144 100644
--- a/nova/api/openstack/views/addresses.py
+++ b/nova/api/openstack/views/addresses.py
@@ -15,9 +15,12 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from nova import flags
 from nova import utils
 from nova.api.openstack import common
 
+FLAGS = flags.FLAGS
+
 
 class ViewBuilder(object):
     """Models a server addresses response as a python dictionary."""
@@ -50,22 +53,37 @@ class ViewBuilderV11(ViewBuilder):
             if network_label not in networks:
                 networks[network_label] = []
 
-            networks[network_label].extend(self._extract_ipv4(interface))
+            ip_addresses = list(self._extract_ipv4_addresses(interface))
+
+            if FLAGS.use_ipv6:
+                ipv6_address = self._extract_ipv6_address(interface)
+                if ipv6_address is not None:
+                    ip_addresses.append(ipv6_address)
+
+            networks[network_label].extend(ip_addresses)
 
         return networks
 
     def build_network(self, interfaces, network_label):
         for interface in interfaces:
             if interface['network']['label'] == network_label:
-                ips = self._extract_ipv4(interface)
-                return {network_label: list(ips)}
+                ips = list(self._extract_ipv4_addresses(interface))
+                ipv6 = self._extract_ipv6_address(interface)
+                if ipv6 is not None:
+                    ips.append(ipv6)
+                return {network_label: ips}
         return None
 
-    def _extract_ipv4(self, interface):
+    def _extract_ipv4_addresses(self, interface):
         for fixed_ip in interface['fixed_ips']:
             yield self._build_ip_entity(fixed_ip['address'], 4)
             for floating_ip in fixed_ip.get('floating_ips', []):
                 yield self._build_ip_entity(floating_ip['address'], 4)
 
+    def _extract_ipv6_address(self, interface):
+        fixed_ipv6 = interface.get('fixed_ipv6')
+        if fixed_ipv6 is not None:
+            return self._build_ip_entity(fixed_ipv6, 6)
+
     def _build_ip_entity(self, address, version):
         return {'addr': address, 'version': version}
diff --git a/nova/api/openstack/views/limits.py b/nova/api/openstack/views/limits.py
index 934b4921a..f603d7cb4 100644
--- a/nova/api/openstack/views/limits.py
+++ b/nova/api/openstack/views/limits.py
@@ -15,9 +15,11 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import datetime
 import time
 
 from nova.api.openstack import common
+from nova import utils
 
 
 class ViewBuilder(object):
@@ -113,10 +115,12 @@ class ViewBuilderV11(ViewBuilder):
         return limits
 
     def _build_rate_limit(self, rate_limit):
+        next_avail = \
+            datetime.datetime.utcfromtimestamp(rate_limit["resetTime"])
         return {
             "verb": rate_limit["verb"],
             "value": rate_limit["value"],
             "remaining": int(rate_limit["remaining"]),
             "unit": rate_limit["unit"],
-            "next-available": rate_limit["resetTime"],
+            "next-available": utils.isotime(at=next_avail),
         }
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index caa4664ee..c96e14553 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -50,7 +50,7 @@ class ViewBuilder(object):
             else:
                 server = self._build_simple(inst)
 
-            self._build_extra(server, inst)
+            self._build_extra(server['server'], inst)
 
         return server
 
@@ -69,7 +69,7 @@ class ViewBuilder(object):
         ctxt = nova.context.get_admin_context()
         compute_api = nova.compute.API()
 
-        if compute_api.has_finished_migration(ctxt, inst['id']):
+        if compute_api.has_finished_migration(ctxt, inst['uuid']):
             inst_dict['status'] = 'RESIZE-CONFIRM'
 
         # Return the metadata as a dictionary
@@ -86,7 +86,6 @@ class ViewBuilder(object):
         self._build_flavor(inst_dict, inst)
         self._build_addresses(inst_dict, inst)
 
-        inst_dict['uuid'] = inst['uuid']
         return dict(server=inst_dict)
 
     def _build_addresses(self, response, inst):
@@ -108,6 +107,9 @@ class ViewBuilder(object):
 class ViewBuilderV10(ViewBuilder):
     """Model an Openstack API V1.0 server response."""
 
+    def _build_extra(self, response, inst):
+        response['uuid'] = inst['uuid']
+
     def _build_image(self, response, inst):
         if 'image_ref' in dict(inst):
             image_ref = inst['image_ref']
@@ -132,18 +134,46 @@ class ViewBuilderV11(ViewBuilder):
         self.image_builder = image_builder
         self.base_url = base_url
 
+    def _build_detail(self, inst):
+        response = super(ViewBuilderV11, self)._build_detail(inst)
+        response['server']['created'] = inst['created_at']
+        response['server']['updated'] = inst['updated_at']
+        if 'status' in response['server']:
+            if response['server']['status'] == "ACTIVE":
+                response['server']['progress'] = 100
+            elif response['server']['status'] == "BUILD":
+                response['server']['progress'] = 0
+        return response
+
     def _build_image(self, response, inst):
         if 'image_ref' in dict(inst):
             image_href = inst['image_ref']
-            if str(image_href).isdigit():
-                image_href = int(image_href)
-            response['imageRef'] = image_href
+            image_id = str(common.get_id_from_href(image_href))
+            _bookmark = self.image_builder.generate_bookmark(image_id)
+            response['image'] = {
+                "id": image_id,
+                "links": [
+                    {
+                        "rel": "bookmark",
+                        "href": _bookmark,
+                    },
+                ]
+            }
 
     def _build_flavor(self, response, inst):
         if "instance_type" in dict(inst):
             flavor_id = inst["instance_type"]['flavorid']
             flavor_ref = self.flavor_builder.generate_href(flavor_id)
-            response["flavorRef"] = flavor_ref
+            flavor_bookmark = self.flavor_builder.generate_bookmark(flavor_id)
+            response["flavor"] = {
+                "id": str(common.get_id_from_href(flavor_ref)),
+                "links": [
+                    {
+                        "rel": "bookmark",
+                        "href": flavor_bookmark,
+                    },
+                ]
+            }
 
     def _build_addresses(self, response, inst):
         interfaces = inst.get('virtual_interfaces', [])
@@ -151,6 +181,7 @@ class ViewBuilderV11(ViewBuilder):
 
     def _build_extra(self, response, inst):
         self._build_links(response, inst)
+        response['uuid'] = inst['uuid']
 
     def _build_links(self, response, inst):
         href = self.generate_href(inst["id"])
@@ -167,7 +198,7 @@ class ViewBuilderV11(ViewBuilder):
             },
         ]
 
-        response["server"]["links"] = links
+        response["links"] = links
 
     def generate_href(self, server_id):
         """Create an url that refers to a specific server id."""
diff --git a/nova/api/openstack/views/versions.py b/nova/api/openstack/views/versions.py
index d0145c94a..9fa8f49dc 100644
--- a/nova/api/openstack/views/versions.py
+++ b/nova/api/openstack/views/versions.py
@@ -36,6 +36,7 @@ class ViewBuilder(object):
         version = {
             "id": version_data["id"],
             "status": version_data["status"],
+            "updated": version_data["updated"],
             "links": self._build_links(version_data),
         }
 
@@ -56,4 +57,4 @@ class ViewBuilder(object):
 
     def generate_href(self, version_number):
         """Create an url that refers to a specific version_number."""
-        return os.path.join(self.base_url, version_number)
+        return os.path.join(self.base_url, version_number) + '/'
diff --git a/nova/api/openstack/wsgi.py b/nova/api/openstack/wsgi.py
index c3f841aa5..a28443d12 100644
--- a/nova/api/openstack/wsgi.py
+++ b/nova/api/openstack/wsgi.py
@@ -13,6 +13,7 @@ from nova import wsgi
 
 XMLNS_V10 = 'http://docs.rackspacecloud.com/servers/api/v1.0'
 XMLNS_V11 = 'http://docs.openstack.org/compute/api/v1.1'
+XMLNS_ATOM = 'http://www.w3.org/2005/Atom'
 
 LOG = logging.getLogger('nova.api.openstack.wsgi')
 
@@ -20,21 +21,22 @@ LOG = logging.getLogger('nova.api.openstack.wsgi')
 class Request(webob.Request):
     """Add some Openstack API-specific logic to the base webob.Request."""
 
-    def best_match_content_type(self):
+    def best_match_content_type(self, supported_content_types=None):
         """Determine the requested response content-type.
 
         Based on the query extension then the Accept header.
 
         """
-        supported = ('application/json', 'application/xml')
+        supported_content_types = supported_content_types or \
+            ('application/json', 'application/xml')
 
         parts = self.path.rsplit('.', 1)
         if len(parts) > 1:
             ctype = 'application/{0}'.format(parts[1])
-            if ctype in supported:
+            if ctype in supported_content_types:
                 return ctype
 
-        bm = self.accept.best_match(supported)
+        bm = self.accept.best_match(supported_content_types)
 
         # default to application/json if we don't find a preference
         return bm or 'application/json'
@@ -134,10 +136,44 @@ class XMLDeserializer(TextDeserializer):
                                                                  listnames)
             return result
 
+    def find_first_child_named(self, parent, name):
+        """Search a nodes children for the first child with a given name"""
+        for node in parent.childNodes:
+            if node.nodeName == name:
+                return node
+        return None
+
+    def find_children_named(self, parent, name):
+        """Return all of a nodes children who have the given name"""
+        for node in parent.childNodes:
+            if node.nodeName == name:
+                yield node
+
+    def extract_text(self, node):
+        """Get the text field contained by the given node"""
+        if len(node.childNodes) == 1:
+            child = node.childNodes[0]
+            if child.nodeType == child.TEXT_NODE:
+                return child.nodeValue
+        return ""
+
     def default(self, datastring):
         return {'body': self._from_xml(datastring)}
 
 
+class MetadataXMLDeserializer(XMLDeserializer):
+
+    def extract_metadata(self, metadata_node):
+        """Marshal the metadata attribute of a parsed request"""
+        if metadata_node is None:
+            return None
+        metadata = {}
+        for meta_node in self.find_children_named(metadata_node, "meta"):
+            key = meta_node.getAttribute("key")
+            metadata[key] = self.extract_text(meta_node)
+        return metadata
+
+
 class RequestHeadersDeserializer(ActionDispatcher):
     """Default request headers deserializer"""
 
@@ -151,7 +187,12 @@ class RequestHeadersDeserializer(ActionDispatcher):
 class RequestDeserializer(object):
     """Break up a Request object into more useful pieces."""
 
-    def __init__(self, body_deserializers=None, headers_deserializer=None):
+    def __init__(self, body_deserializers=None, headers_deserializer=None,
+                 supported_content_types=None):
+
+        self.supported_content_types = supported_content_types or \
+                ('application/json', 'application/xml')
+
         self.body_deserializers = {
             'application/xml': XMLDeserializer(),
             'application/json': JSONDeserializer(),
@@ -213,7 +254,7 @@ class RequestDeserializer(object):
             raise exception.InvalidContentType(content_type=content_type)
 
     def get_expected_content_type(self, request):
-        return request.best_match_content_type()
+        return request.best_match_content_type(self.supported_content_types)
 
     def get_action_args(self, request_environment):
         """Parse dictionary created by routes library."""
@@ -390,8 +431,9 @@ class ResponseSerializer(object):
 
     def serialize_body(self, response, data, content_type, action):
         response.headers['Content-Type'] = content_type
-        serializer = self.get_body_serializer(content_type)
-        response.body = serializer.serialize(data, action)
+        if data is not None:
+            serializer = self.get_body_serializer(content_type)
+            response.body = serializer.serialize(data, action)
 
     def get_body_serializer(self, content_type):
         try:
@@ -412,6 +454,7 @@ class Resource(wsgi.Application):
     serialized by requested content type.
 
     """
+
     def __init__(self, controller, deserializer=None, serializer=None):
         """
         :param controller: object that implement methods created by routes lib
@@ -436,14 +479,17 @@ class Resource(wsgi.Application):
             action, args, accept = self.deserializer.deserialize(request)
         except exception.InvalidContentType:
             msg = _("Unsupported Content-Type")
-            return webob.exc.HTTPBadRequest(explanation=msg)
+            return faults.Fault(webob.exc.HTTPBadRequest(explanation=msg))
         except exception.MalformedRequestBody:
             msg = _("Malformed request body")
             return faults.Fault(webob.exc.HTTPBadRequest(explanation=msg))
 
-        action_result = self.dispatch(request, action, args)
+        try:
+            action_result = self.dispatch(request, action, args)
+        except webob.exc.HTTPException as ex:
+            LOG.info(_("HTTP exception thrown: %s"), unicode(ex))
+            action_result = faults.Fault(ex)
 
-        #TODO(bcwaldon): find a more elegant way to pass through non-dict types
         if type(action_result) is dict or action_result is None:
             response = self.serializer.serialize(action_result,
                                                  accept,
diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index 2e02ec380..f7fd87bcd 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -27,7 +27,6 @@ from nova.scheduler import api
 
 from nova.api.openstack import create_instance_helper as helper
 from nova.api.openstack import common
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 
 
@@ -127,11 +126,8 @@ class Controller(object):
         Returns a reservation ID (a UUID).
         """
         result = None
-        try:
-            extra_values, result = self.helper.create_instance(req, body,
-                                    self.compute_api.create_all_at_once)
-        except faults.Fault, f:
-            return f
+        extra_values, result = self.helper.create_instance(req, body,
+                                self.compute_api.create_all_at_once)
 
         reservation_id = result
         return {'reservation_id': reservation_id}