Merge lp:~ethuleau/nova/lp838154 into lp:~hudson-openstack/nova/milestone-proposed

[Vish Ishaya]

Fixes libvirt rescue to use the same strategy as xen. Use a new copy of the base image as the rescue image. It leaves the original rescue image flags in, so a hand picked rescue image can still be used if desired.

[Thierry Carrez (ttx)]

Change description sounds unrelated

[Vish Ishaya (vishvananda)]

this looks like an error.

Unmerged revisions

1544. By Édouard Thuleau on 2011-09-16

Merged trunk.

1543. By Édouard Thuleau on 2011-09-09

Authorize to start a LXC instance withour, key, network file to inject or metadata.

1542. By Thierry Carrez on 2011-09-09

Open Essex (switch version to 2012.1)

=== modified file 'MANIFEST.in'
--- MANIFEST.in	2011-08-09 13:25:52 +0000
+++ MANIFEST.in	2011-09-17 02:16:44 +0000
@@ -37,7 +37,7 @@
 include nova/tests/bundle/1mb.no_kernel_or_ramdisk.manifest.xml
 include nova/tests/bundle/1mb.part.0
 include nova/tests/bundle/1mb.part.1
-include nova/tests/public_key/*
+include nova/tests/api/ec2/public_key/*
 include nova/tests/db/nova.austin.sqlite
 include plugins/xenapi/README
 include plugins/xenapi/etc/xapi.d/plugins/objectstore

=== modified file 'nova/api/ec2/cloud.py'
--- nova/api/ec2/cloud.py	2011-09-15 20:40:49 +0000
+++ nova/api/ec2/cloud.py	2011-09-17 02:16:44 +0000
@@ -1489,7 +1489,7 @@
         return image
 
     def _format_image(self, image):
-        """Convert from format defined by BaseImageService to S3 format."""
+        """Convert from format defined by GlanceImageService to S3 format."""
         i = {}
         image_type = self._image_type(image.get('container_format'))
         ec2_id = self.image_ec2_id(image.get('id'), image_type)

=== modified file 'nova/api/openstack/common.py'
--- nova/api/openstack/common.py	2011-08-25 21:27:10 +0000
+++ nova/api/openstack/common.py	2011-09-17 02:16:44 +0000
@@ -16,6 +16,7 @@
 #    under the License.
 
 import functools
+from lxml import etree
 import re
 import urlparse
 from xml.dom import minidom
@@ -27,8 +28,14 @@
 from nova import log as logging
 from nova import quota
 from nova.api.openstack import wsgi
-from nova.compute import vm_states
-from nova.compute import task_states
+<<<<<<< TREE
+from nova.compute import vm_states
+from nova.compute import task_states
+=======
+from nova.api.openstack import xmlutil
+from nova.compute import vm_states
+from nova.compute import task_states
+>>>>>>> MERGE-SOURCE
 
 
 LOG = logging.getLogger('nova.api.openstack.common')
@@ -185,30 +192,16 @@
 
 
 def get_id_from_href(href):
-    """Return the id portion of a url as an int.
+    """Return the id or uuid portion of a url.
 
     Given: 'http://www.foo.com/bar/123?q=4'
-    Returns: 123
+    Returns: '123'
 
-    In order to support local hrefs, the href argument can be just an id:
-    Given: '123'
-    Returns: 123
+    Given: 'http://www.foo.com/bar/abc123?q=4'
+    Returns: 'abc123'
 
     """
-    LOG.debug(_("Attempting to treat %(href)s as an integer ID.") % locals())
-
-    try:
-        return int(href)
-    except ValueError:
-        pass
-
-    LOG.debug(_("Attempting to treat %(href)s as a URL.") % locals())
-
-    try:
-        return int(urlparse.urlsplit(href).path.split('/')[-1])
-    except ValueError as error:
-        LOG.debug(_("Failed to parse ID from %(href)s: %(error)s") % locals())
-        raise
+    return urlparse.urlsplit("%s" % href).path.split('/')[-1]
 
 
 def remove_version_from_href(href):
@@ -308,54 +301,48 @@
 
 
 class MetadataXMLSerializer(wsgi.XMLDictSerializer):
+
+    NSMAP = {None: xmlutil.XMLNS_V11}
+
     def __init__(self, xmlns=wsgi.XMLNS_V11):
         super(MetadataXMLSerializer, self).__init__(xmlns=xmlns)
 
-    def _meta_item_to_xml(self, doc, key, value):
-        node = doc.createElement('meta')
-        doc.appendChild(node)
-        node.setAttribute('key', '%s' % key)
-        text = doc.createTextNode('%s' % value)
-        node.appendChild(text)
-        return node
-
-    def meta_list_to_xml(self, xml_doc, meta_items):
-        container_node = xml_doc.createElement('metadata')
-        for (key, value) in meta_items:
-            item_node = self._meta_item_to_xml(xml_doc, key, value)
-            container_node.appendChild(item_node)
-        return container_node
-
-    def _meta_list_to_xml_string(self, metadata_dict):
-        xml_doc = minidom.Document()
-        items = metadata_dict['metadata'].items()
-        container_node = self.meta_list_to_xml(xml_doc, items)
-        xml_doc.appendChild(container_node)
-        self._add_xmlns(container_node)
-        return xml_doc.toxml('UTF-8')
+    def populate_metadata(self, metadata_elem, meta_dict):
+        for (key, value) in meta_dict.items():
+            elem = etree.SubElement(metadata_elem, 'meta')
+            elem.set('key', str(key))
+            elem.text = value
+
+    def _populate_meta_item(self, meta_elem, meta_item_dict):
+        """Populate a meta xml element from a dict."""
+        (key, value) = meta_item_dict.items()[0]
+        meta_elem.set('key', str(key))
+        meta_elem.text = value
 
     def index(self, metadata_dict):
-        return self._meta_list_to_xml_string(metadata_dict)
+        metadata = etree.Element('metadata', nsmap=self.NSMAP)
+        self.populate_metadata(metadata, metadata_dict.get('metadata', {}))
+        return self._to_xml(metadata)
 
     def create(self, metadata_dict):
-        return self._meta_list_to_xml_string(metadata_dict)
+        metadata = etree.Element('metadata', nsmap=self.NSMAP)
+        self.populate_metadata(metadata, metadata_dict.get('metadata', {}))
+        return self._to_xml(metadata)
 
     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]
-        item_node = self._meta_item_to_xml(xml_doc, item_key, item_value)
-        xml_doc.appendChild(item_node)
-        self._add_xmlns(item_node)
-        return xml_doc.toxml('UTF-8')
+        metadata = etree.Element('metadata', nsmap=self.NSMAP)
+        self.populate_metadata(metadata, metadata_dict.get('metadata', {}))
+        return self._to_xml(metadata)
 
     def show(self, meta_item_dict):
-        return self._meta_item_to_xml_string(meta_item_dict['meta'])
+        meta = etree.Element('meta', nsmap=self.NSMAP)
+        self._populate_meta_item(meta, meta_item_dict['meta'])
+        return self._to_xml(meta)
 
     def update(self, meta_item_dict):
-        return self._meta_item_to_xml_string(meta_item_dict['meta'])
+        meta = etree.Element('meta', nsmap=self.NSMAP)
+        self._populate_meta_item(meta, meta_item_dict['meta'])
+        return self._to_xml(meta)
 
     def default(self, *args, **kwargs):
         return ''

=== added file 'nova/api/openstack/contrib/flavorextradata.py'
--- nova/api/openstack/contrib/flavorextradata.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/contrib/flavorextradata.py	2011-09-17 02:16:44 +0000
@@ -0,0 +1,46 @@
+# Copyright 2011 Canonical Ltd.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+The Flavor extra data extension
+Openstack API version 1.1 lists "name", "ram", "disk", "vcpus" as flavor
+attributes.  This extension adds to that list:
+   rxtx_cap
+   rxtx_quota
+   swap
+"""
+
+from nova.api.openstack import extensions
+
+
+class Flavorextradata(extensions.ExtensionDescriptor):
+    """The Flavor extra data extension for the OpenStack API."""
+
+    def get_name(self):
+        return "FlavorExtraData"
+
+    def get_alias(self):
+        return "os-flavor-extra-data"
+
+    def get_description(self):
+        return "Provide additional data for flavors"
+
+    def get_namespace(self):
+        return "http://docs.openstack.org/ext/flavor_extra_data/api/v1.1"
+
+    def get_updated(self):
+        return "2011-09-14T00:00:00+00:00"
+
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

=== modified file 'nova/api/openstack/flavors.py'
--- nova/api/openstack/flavors.py	2011-08-10 06:01:03 +0000
+++ nova/api/openstack/flavors.py	2011-09-17 02:16:44 +0000
@@ -16,12 +16,13 @@
 #    under the License.
 
 import webob
-import xml.dom.minidom as minidom
+from lxml import etree
 
 from nova import db
 from nova import exception
 from nova.api.openstack import views
 from nova.api.openstack import wsgi
+from nova.api.openstack import xmlutil
 
 
 class Controller(object):
@@ -78,48 +79,48 @@
 
 class FlavorXMLSerializer(wsgi.XMLDictSerializer):
 
+    NSMAP = {None: xmlutil.XMLNS_V11, 'atom': xmlutil.XMLNS_ATOM}
+
     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'])
+    def _populate_flavor(self, flavor_elem, flavor_dict, detailed=False):
+        """Populate a flavor xml element from a dict."""
 
+        flavor_elem.set('name', flavor_dict['name'])
+        flavor_elem.set('id', str(flavor_dict['id']))
         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
+            flavor_elem.set('ram', str(flavor_dict['ram']))
+            flavor_elem.set('disk', str(flavor_dict['disk']))
+
+            for attr in ("vcpus", "swap", "rxtx_quota", "rxtx_cap"):
+                flavor_elem.set(attr, str(flavor_dict.get(attr, "")))
+
+        for link in flavor_dict.get('links', []):
+            elem = etree.SubElement(flavor_elem,
+                                    '{%s}link' % xmlutil.XMLNS_ATOM)
+            elem.set('rel', link['rel'])
+            elem.set('href', link['href'])
+        return flavor_elem
 
     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)
+        flavor = etree.Element('flavor', nsmap=self.NSMAP)
+        self._populate_flavor(flavor, flavor_container['flavor'], True)
+        return self._to_xml(flavor)
+
+    def detail(self, flavors_dict):
+        flavors = etree.Element('flavors', nsmap=self.NSMAP)
+        for flavor_dict in flavors_dict['flavors']:
+            flavor = etree.SubElement(flavors, 'flavor')
+            self._populate_flavor(flavor, flavor_dict, True)
+        return self._to_xml(flavors)
+
+    def index(self, flavors_dict):
+        flavors = etree.Element('flavors', nsmap=self.NSMAP)
+        for flavor_dict in flavors_dict['flavors']:
+            flavor = etree.SubElement(flavors, 'flavor')
+            self._populate_flavor(flavor, flavor_dict, False)
+        return self._to_xml(flavors)
 
 
 def create_resource(version='1.0'):

=== modified file 'nova/api/openstack/image_metadata.py'
--- nova/api/openstack/image_metadata.py	2011-08-06 00:05:33 +0000
+++ nova/api/openstack/image_metadata.py	2011-09-17 02:16:44 +0000
@@ -17,6 +17,7 @@
 
 from webob import exc
 
+from nova import exception
 from nova import flags
 from nova import image
 from nova import utils
@@ -33,21 +34,22 @@
     def __init__(self):
         self.image_service = image.get_default_image_service()
 
-    def _get_metadata(self, context, image_id, image=None):
-        if not image:
-            image = self.image_service.show(context, image_id)
-        metadata = image.get('properties', {})
-        return metadata
+    def _get_image(self, context, image_id):
+        try:
+            return self.image_service.show(context, image_id)
+        except exception.NotFound:
+            msg = _("Image not found.")
+            raise exc.HTTPNotFound(explanation=msg)
 
     def index(self, req, image_id):
         """Returns the list of metadata for a given instance"""
         context = req.environ['nova.context']
-        metadata = self._get_metadata(context, image_id)
+        metadata = self._get_image(context, image_id)['properties']
         return dict(metadata=metadata)
 
     def show(self, req, image_id, id):
         context = req.environ['nova.context']
-        metadata = self._get_metadata(context, image_id)
+        metadata = self._get_image(context, image_id)['properties']
         if id in metadata:
             return {'meta': {id: metadata[id]}}
         else:
@@ -55,15 +57,13 @@
 
     def create(self, req, image_id, body):
         context = req.environ['nova.context']
-        img = self.image_service.show(context, image_id)
-        metadata = self._get_metadata(context, image_id, img)
+        image = self._get_image(context, image_id)
         if 'metadata' in body:
             for key, value in body['metadata'].iteritems():
-                metadata[key] = value
-        common.check_img_metadata_quota_limit(context, metadata)
-        img['properties'] = metadata
-        self.image_service.update(context, image_id, img, None)
-        return dict(metadata=metadata)
+                image['properties'][key] = value
+        common.check_img_metadata_quota_limit(context, image['properties'])
+        self.image_service.update(context, image_id, image, None)
+        return dict(metadata=image['properties'])
 
     def update(self, req, image_id, id, body):
         context = req.environ['nova.context']
@@ -80,32 +80,30 @@
         if len(meta) > 1:
             expl = _('Request body contains too many items')
             raise exc.HTTPBadRequest(explanation=expl)
-        img = self.image_service.show(context, image_id)
-        metadata = self._get_metadata(context, image_id, img)
-        metadata[id] = meta[id]
-        common.check_img_metadata_quota_limit(context, metadata)
-        img['properties'] = metadata
-        self.image_service.update(context, image_id, img, None)
+
+        image = self._get_image(context, image_id)
+        image['properties'][id] = meta[id]
+        common.check_img_metadata_quota_limit(context, image['properties'])
+        self.image_service.update(context, image_id, image, None)
         return dict(meta=meta)
 
     def update_all(self, req, image_id, body):
         context = req.environ['nova.context']
-        img = self.image_service.show(context, image_id)
+        image = self._get_image(context, image_id)
         metadata = body.get('metadata', {})
         common.check_img_metadata_quota_limit(context, metadata)
-        img['properties'] = metadata
-        self.image_service.update(context, image_id, img, None)
+        image['properties'] = metadata
+        self.image_service.update(context, image_id, image, 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:
-            raise exc.HTTPNotFound()
-        metadata.pop(id)
-        img['properties'] = metadata
-        self.image_service.update(context, image_id, img, None)
+        image = self._get_image(context, image_id)
+        if not id in image['properties']:
+            msg = _("Invalid metadata key")
+            raise exc.HTTPNotFound(explanation=msg)
+        image['properties'].pop(id)
+        self.image_service.update(context, image_id, image, None)
 
 
 def create_resource():

=== modified file 'nova/api/openstack/images.py'
--- nova/api/openstack/images.py	2011-08-10 06:01:03 +0000
+++ nova/api/openstack/images.py	2011-09-17 02:16:44 +0000
@@ -16,8 +16,8 @@
 import urlparse
 import os.path
 
+from lxml import etree
 import webob.exc
-from xml.dom import minidom
 
 from nova import compute
 from nova import exception
@@ -29,6 +29,7 @@
 from nova.api.openstack import servers
 from nova.api.openstack.views import images as images_view
 from nova.api.openstack import wsgi
+from nova.api.openstack import xmlutil
 
 
 LOG = log.getLogger('nova.api.openstack.images')
@@ -50,7 +51,7 @@
         """Initialize new `ImageController`.
 
         :param compute_service: `nova.compute.api:API`
-        :param image_service: `nova.image.service:BaseImageService`
+        :param image_service: `nova.image.glance:GlancemageService`
 
         """
         self._compute_service = compute_service or compute.API()
@@ -206,93 +207,71 @@
 
 class ImageXMLSerializer(wsgi.XMLDictSerializer):
 
-    xmlns = wsgi.XMLNS_V11
+    NSMAP = {None: xmlutil.XMLNS_V11, 'atom': xmlutil.XMLNS_ATOM}
 
     def __init__(self):
         self.metadata_serializer = common.MetadataXMLSerializer()
 
-    def _image_to_xml(self, xml_doc, image):
-        image_node = xml_doc.createElement('image')
-        image_node.setAttribute('id', str(image['id']))
-        image_node.setAttribute('name', image['name'])
-        link_nodes = self._create_link_nodes(xml_doc,
-                                             image['links'])
-        for link_node in link_nodes:
-            image_node.appendChild(link_node)
-        return image_node
-
-    def _image_to_xml_detailed(self, xml_doc, image):
-        image_node = xml_doc.createElement('image')
-        self._add_image_attributes(image_node, image)
-
-        if 'server' in image:
-            server_node = self._create_server_node(xml_doc, image['server'])
-            image_node.appendChild(server_node)
-
-        metadata = image.get('metadata', {}).items()
-        if len(metadata) > 0:
-            metadata_node = self._create_metadata_node(xml_doc, metadata)
-            image_node.appendChild(metadata_node)
-
-        link_nodes = self._create_link_nodes(xml_doc,
-                                             image['links'])
-        for link_node in link_nodes:
-            image_node.appendChild(link_node)
-
-        return image_node
-
-    def _add_image_attributes(self, node, image):
-        node.setAttribute('id', str(image['id']))
-        node.setAttribute('name', image['name'])
-        node.setAttribute('created', image['created'])
-        node.setAttribute('updated', image['updated'])
-        node.setAttribute('status', image['status'])
-        if 'progress' in image:
-            node.setAttribute('progress', str(image['progress']))
-
-    def _create_metadata_node(self, xml_doc, metadata):
-        return self.metadata_serializer.meta_list_to_xml(xml_doc, metadata)
-
-    def _create_server_node(self, xml_doc, server):
-        server_node = xml_doc.createElement('server')
-        server_node.setAttribute('id', str(server['id']))
-        link_nodes = self._create_link_nodes(xml_doc,
-                                             server['links'])
-        for link_node in link_nodes:
-            server_node.appendChild(link_node)
-        return server_node
-
-    def _image_list_to_xml(self, xml_doc, images, detailed):
-        container_node = xml_doc.createElement('images')
+    def _create_metadata_node(self, metadata_dict):
+        metadata_elem = etree.Element('metadata', nsmap=self.NSMAP)
+        self.metadata_serializer.populate_metadata(metadata_elem,
+                                                   metadata_dict)
+        return metadata_elem
+
+    def _create_server_node(self, server_dict):
+        server_elem = etree.Element('server', nsmap=self.NSMAP)
+        server_elem.set('id', str(server_dict['id']))
+        for link in server_dict.get('links', []):
+            elem = etree.SubElement(server_elem,
+                                    '{%s}link' % xmlutil.XMLNS_ATOM)
+            elem.set('rel', link['rel'])
+            elem.set('href', link['href'])
+        return server_elem
+
+    def _populate_image(self, image_elem, image_dict, detailed=False):
+        """Populate an image xml element from a dict."""
+
+        image_elem.set('name', image_dict['name'])
+        image_elem.set('id', str(image_dict['id']))
         if detailed:
-            image_to_xml = self._image_to_xml_detailed
-        else:
-            image_to_xml = self._image_to_xml
-
-        for image in images:
-            item_node = image_to_xml(xml_doc, image)
-            container_node.appendChild(item_node)
-        return container_node
+            image_elem.set('updated', str(image_dict['updated']))
+            image_elem.set('created', str(image_dict['created']))
+            image_elem.set('status', str(image_dict['status']))
+            if 'progress' in image_dict:
+                image_elem.set('progress', str(image_dict['progress']))
+            if 'server' in image_dict:
+                server_elem = self._create_server_node(image_dict['server'])
+                image_elem.append(server_elem)
+
+            meta_elem = self._create_metadata_node(
+                            image_dict.get('metadata', {}))
+            image_elem.append(meta_elem)
+
+        for link in image_dict.get('links', []):
+            elem = etree.SubElement(image_elem,
+                                    '{%s}link' % xmlutil.XMLNS_ATOM)
+            elem.set('rel', link['rel'])
+            elem.set('href', link['href'])
+        return image_elem
 
     def index(self, images_dict):
-        xml_doc = minidom.Document()
-        node = self._image_list_to_xml(xml_doc,
-                                       images_dict['images'],
-                                       detailed=False)
-        return self.to_xml_string(node, True)
+        images = etree.Element('images', nsmap=self.NSMAP)
+        for image_dict in images_dict['images']:
+            image = etree.SubElement(images, 'image')
+            self._populate_image(image, image_dict, False)
+        return self._to_xml(images)
 
     def detail(self, images_dict):
-        xml_doc = minidom.Document()
-        node = self._image_list_to_xml(xml_doc,
-                                       images_dict['images'],
-                                       detailed=True)
-        return self.to_xml_string(node, True)
+        images = etree.Element('images', nsmap=self.NSMAP)
+        for image_dict in images_dict['images']:
+            image = etree.SubElement(images, 'image')
+            self._populate_image(image, image_dict, True)
+        return self._to_xml(images)
 
     def show(self, image_dict):
-        xml_doc = minidom.Document()
-        node = self._image_to_xml_detailed(xml_doc,
-                                       image_dict['image'])
-        return self.to_xml_string(node, True)
+        image = etree.Element('image', nsmap=self.NSMAP)
+        self._populate_image(image, image_dict['image'], True)
+        return self._to_xml(image)
 
 
 def create_resource(version='1.0'):

=== modified file 'nova/api/openstack/ips.py'
--- nova/api/openstack/ips.py	2011-07-25 21:00:19 +0000
+++ nova/api/openstack/ips.py	2011-09-17 02:16:44 +0000
@@ -15,14 +15,15 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from lxml import etree
 import time
-from xml.dom import minidom
 
 from webob import exc
 
 import nova
 import nova.api.openstack.views.addresses
 from nova.api.openstack import wsgi
+from nova.api.openstack import xmlutil
 from nova import db
 
 
@@ -102,42 +103,36 @@
 
 
 class IPXMLSerializer(wsgi.XMLDictSerializer):
+
+    NSMAP = {None: xmlutil.XMLNS_V11}
+
     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)
-
+    def populate_addresses_node(self, addresses_elem,  addresses_dict):
+        for (network_id, ip_dicts) in addresses_dict.items():
+            network_elem = self._create_network_node(network_id, ip_dicts)
+            addresses_elem.append(network_elem)
+
+    def _create_network_node(self, network_id, ip_dicts):
+        network_elem = etree.Element('network', nsmap=self.NSMAP)
+        network_elem.set('id', str(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)
+            ip_elem = etree.SubElement(network_elem, 'ip')
+            ip_elem.set('version', str(ip_dict['version']))
+            ip_elem.set('addr', ip_dict['addr'])
+        return network_elem
+
+    def show(self, network_dict):
+        (network_id, ip_dicts) = network_dict.items()[0]
+        network = self._create_network_node(network_id, ip_dicts)
+        return self._to_xml(network)
+
+    def index(self, addresses_dict):
+        addresses = etree.Element('addresses', nsmap=self.NSMAP)
+        self.populate_addresses_node(addresses,
+                                     addresses_dict.get('addresses', {}))
+        return self._to_xml(addresses)
 
 
 def create_resource(version):

=== modified file 'nova/api/openstack/limits.py'
--- nova/api/openstack/limits.py	2011-07-21 13:43:25 +0000
+++ nova/api/openstack/limits.py	2011-09-17 02:16:44 +0000
@@ -20,12 +20,12 @@
 import copy
 import httplib
 import json
+from lxml import etree
 import math
 import re
 import time
 import urllib
 import webob.exc
-from xml.dom import minidom
 
 from collections import defaultdict
 
@@ -38,6 +38,7 @@
 from nova.api.openstack import faults
 from nova.api.openstack.views import limits as limits_views
 from nova.api.openstack import wsgi
+from nova.api.openstack import xmlutil
 
 
 # Convenience constants for the limits dictionary passed to Limiter().
@@ -81,52 +82,49 @@
 
     xmlns = wsgi.XMLNS_V11
 
+    NSMAP = {None: xmlutil.XMLNS_V11, 'atom': xmlutil.XMLNS_ATOM}
+
     def __init__(self):
         pass
 
-    def _create_rates_node(self, xml_doc, rates):
-        rates_node = xml_doc.createElement('rates')
+    def _create_rates_node(self, rates):
+        rates_elem = etree.Element('rates', nsmap=self.NSMAP)
         for rate in rates:
-            rate_node = xml_doc.createElement('rate')
-            rate_node.setAttribute('uri', rate['uri'])
-            rate_node.setAttribute('regex', rate['regex'])
-
+            rate_node = etree.SubElement(rates_elem, 'rate')
+            rate_node.set('uri', rate['uri'])
+            rate_node.set('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
+                limit_elem = etree.SubElement(rate_node, 'limit')
+                limit_elem.set('value', str(limit['value']))
+                limit_elem.set('verb', str(limit['verb']))
+                limit_elem.set('remaining', str(limit['remaining']))
+                limit_elem.set('unit', str(limit['unit']))
+                limit_elem.set('next-available', str(limit['next-available']))
+        return rates_elem
+
+    def _create_absolute_node(self, absolute_dict):
+        absolute_elem = etree.Element('absolute', nsmap=self.NSMAP)
+        for key, value in absolute_dict.items():
+            limit_elem = etree.SubElement(absolute_elem, 'limit')
+            limit_elem.set('name', str(key))
+            limit_elem.set('value', str(value))
+        return absolute_elem
+
+    def _populate_limits(self, limits_elem, limits_dict):
+        """Populate a limits xml element from a dict."""
+
+        rates_elem = self._create_rates_node(
+                        limits_dict.get('rate', []))
+        limits_elem.append(rates_elem)
+
+        absolutes_elem = self._create_absolute_node(
+                        limits_dict.get('absolute', {}))
+        limits_elem.append(absolutes_elem)
 
     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)
+        limits = etree.Element('limits', nsmap=self.NSMAP)
+        self._populate_limits(limits, limits_dict['limits'])
+        return self._to_xml(limits)
 
 
 def create_resource(version='1.0'):

=== added file 'nova/api/openstack/schemas/v1.1/addresses.rng'
--- nova/api/openstack/schemas/v1.1/addresses.rng	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/schemas/v1.1/addresses.rng	2011-09-17 02:16:44 +0000
@@ -0,0 +1,14 @@
+<element name="addresses" ns="http://docs.openstack.org/compute/api/v1.1"
+    xmlns="http://relaxng.org/ns/structure/1.0">
+  <zeroOrMore>
+    <element name="network">
+      <attribute name="id"> <text/> </attribute>
+        <zeroOrMore>
+          <element name="ip">
+            <attribute name="version"> <text/> </attribute>
+            <attribute name="addr"> <text/> </attribute>
+          </element>
+        </zeroOrMore>
+    </element>
+  </zeroOrMore>
+</element>

=== added file 'nova/api/openstack/schemas/v1.1/flavor.rng'
--- nova/api/openstack/schemas/v1.1/flavor.rng	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/schemas/v1.1/flavor.rng	2011-09-17 02:16:44 +0000
@@ -0,0 +1,14 @@
+<element name="flavor" ns="http://docs.openstack.org/compute/api/v1.1"
+    xmlns="http://relaxng.org/ns/structure/1.0">
+  <attribute name="name">      <text/> </attribute>
+  <attribute name="id">      <text/> </attribute>
+  <attribute name="ram"> <text/> </attribute>
+  <attribute name="disk">   <text/> </attribute>
+  <attribute name="rxtx_cap">   <text/> </attribute>
+  <attribute name="rxtx_quota">   <text/> </attribute>
+  <attribute name="swap">   <text/> </attribute>
+  <attribute name="vcpus">   <text/> </attribute>
+  <zeroOrMore>
+    <externalRef href="../atom-link.rng"/>
+  </zeroOrMore>
+</element>

=== added file 'nova/api/openstack/schemas/v1.1/flavors.rng'
--- nova/api/openstack/schemas/v1.1/flavors.rng	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/schemas/v1.1/flavors.rng	2011-09-17 02:16:44 +0000
@@ -0,0 +1,6 @@
+<element name="flavors" xmlns="http://relaxng.org/ns/structure/1.0"
+         ns="http://docs.openstack.org/compute/api/v1.1">
+  <zeroOrMore>
+    <externalRef href="flavor.rng"/>
+  </zeroOrMore>
+</element>

=== added file 'nova/api/openstack/schemas/v1.1/flavors_index.rng'
--- nova/api/openstack/schemas/v1.1/flavors_index.rng	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/schemas/v1.1/flavors_index.rng	2011-09-17 02:16:44 +0000
@@ -0,0 +1,12 @@
+<element name="flavors" ns="http://docs.openstack.org/compute/api/v1.1"
+    xmlns="http://relaxng.org/ns/structure/1.0">
+  <zeroOrMore>
+    <element name="flavor">
+      <attribute name="name"> <text/> </attribute>
+      <attribute name="id"> <text/> </attribute>
+      <zeroOrMore>
+        <externalRef href="../atom-link.rng"/>
+      </zeroOrMore>
+    </element>
+  </zeroOrMore>
+</element>

=== added file 'nova/api/openstack/schemas/v1.1/image.rng'
--- nova/api/openstack/schemas/v1.1/image.rng	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/schemas/v1.1/image.rng	2011-09-17 02:16:44 +0000
@@ -0,0 +1,30 @@
+<element name="image" ns="http://docs.openstack.org/compute/api/v1.1"
+    xmlns="http://relaxng.org/ns/structure/1.0">
+  <attribute name="name">      <text/> </attribute>
+  <attribute name="id">      <text/> </attribute>
+  <attribute name="updated">   <text/> </attribute>
+  <attribute name="created">   <text/> </attribute>
+  <attribute name="status">   <text/> </attribute>
+  <optional>
+    <attribute name="progress">   <text/> </attribute>
+  </optional>
+  <optional>
+    <element name="server">
+      <attribute name="id"> <text/> </attribute>
+      <zeroOrMore>
+        <externalRef href="../atom-link.rng"/>
+      </zeroOrMore>
+    </element>
+  </optional>
+  <element name="metadata">
+    <zeroOrMore>
+      <element name="meta">
+        <attribute name="key"> <text/> </attribute>
+        <text/>
+      </element>
+    </zeroOrMore>
+  </element>
+  <zeroOrMore>
+    <externalRef href="../atom-link.rng"/>
+  </zeroOrMore>
+</element>

=== added file 'nova/api/openstack/schemas/v1.1/images.rng'
--- nova/api/openstack/schemas/v1.1/images.rng	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/schemas/v1.1/images.rng	2011-09-17 02:16:44 +0000
@@ -0,0 +1,6 @@
+<element name="images" xmlns="http://relaxng.org/ns/structure/1.0"
+         ns="http://docs.openstack.org/compute/api/v1.1">
+  <zeroOrMore>
+    <externalRef href="image.rng"/>
+  </zeroOrMore>
+</element>

=== added file 'nova/api/openstack/schemas/v1.1/images_index.rng'
--- nova/api/openstack/schemas/v1.1/images_index.rng	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/schemas/v1.1/images_index.rng	2011-09-17 02:16:44 +0000
@@ -0,0 +1,12 @@
+<element name="images" ns="http://docs.openstack.org/compute/api/v1.1"
+    xmlns="http://relaxng.org/ns/structure/1.0">
+  <zeroOrMore>
+    <element name="image">
+      <attribute name="name"> <text/> </attribute>
+      <attribute name="id"> <text/> </attribute>
+      <zeroOrMore>
+        <externalRef href="../atom-link.rng"/>
+      </zeroOrMore>
+    </element>
+  </zeroOrMore>
+</element>

=== added file 'nova/api/openstack/schemas/v1.1/limits.rng'
--- nova/api/openstack/schemas/v1.1/limits.rng	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/schemas/v1.1/limits.rng	2011-09-17 02:16:44 +0000
@@ -0,0 +1,28 @@
+<element name="limits" ns="http://docs.openstack.org/compute/api/v1.1"
+  xmlns="http://relaxng.org/ns/structure/1.0">
+  <element name="rates">
+    <zeroOrMore>
+      <element name="rate">
+        <attribute name="uri"> <text/> </attribute>
+        <attribute name="regex"> <text/> </attribute>
+        <zeroOrMore>
+          <element name="limit">
+            <attribute name="value"> <text/> </attribute>
+            <attribute name="verb"> <text/> </attribute>
+            <attribute name="remaining"> <text/> </attribute>
+            <attribute name="unit"> <text/> </attribute>
+            <attribute name="next-available"> <text/> </attribute>
+          </element>
+        </zeroOrMore>
+      </element>
+    </zeroOrMore>
+  </element>
+  <element name="absolute">
+    <zeroOrMore>
+      <element name="limit">
+        <attribute name="name"> <text/> </attribute>
+        <attribute name="value"> <text/> </attribute>
+      </element>
+    </zeroOrMore>
+  </element>
+</element>

=== added file 'nova/api/openstack/schemas/v1.1/metadata.rng'
--- nova/api/openstack/schemas/v1.1/metadata.rng	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/schemas/v1.1/metadata.rng	2011-09-17 02:16:44 +0000
@@ -0,0 +1,9 @@
+  <element name="metadata" ns="http://docs.openstack.org/compute/api/v1.1"
+    xmlns="http://relaxng.org/ns/structure/1.0">
+    <zeroOrMore>
+      <element name="meta">
+        <attribute name="key"> <text/> </attribute>
+        <text/>
+      </element>
+    </zeroOrMore>
+  </element>

=== modified file 'nova/api/openstack/schemas/v1.1/server.rng'
--- nova/api/openstack/schemas/v1.1/server.rng	2011-09-02 19:52:02 +0000
+++ nova/api/openstack/schemas/v1.1/server.rng	2011-09-17 02:16:44 +0000
@@ -17,9 +17,6 @@
   <optional>
     <attribute name="adminPass">   <text/> </attribute>
   </optional>
-  <zeroOrMore>
-    <externalRef href="../atom-link.rng"/>
-  </zeroOrMore>
   <element name="image">
     <attribute name="id"> <text/> </attribute>
     <externalRef href="../atom-link.rng"/>
@@ -49,4 +46,7 @@
       </element>
     </zeroOrMore>
   </element>
+  <zeroOrMore>
+    <externalRef href="../atom-link.rng"/>
+  </zeroOrMore>
 </element>

=== modified file 'nova/api/openstack/servers.py'
--- nova/api/openstack/servers.py	2011-09-06 19:47:09 +0000
+++ nova/api/openstack/servers.py	2011-09-17 02:16:44 +0000
@@ -17,8 +17,8 @@
 import os
 import traceback
 
+from lxml import etree
 from webob import exc
-from xml.dom import minidom
 import webob
 
 from nova import compute
@@ -38,6 +38,7 @@
 import nova.api.openstack.views.flavors
 import nova.api.openstack.views.images
 import nova.api.openstack.views.servers
+from nova.api.openstack import xmlutil
 
 
 LOG = logging.getLogger('nova.api.openstack.servers')
@@ -334,9 +335,8 @@
             LOG.exception(msg)
             raise exc.HTTPBadRequest(explanation=msg)
         try:
-            # TODO(gundlach): pass reboot_type, support soft reboot in
-            # virt driver
-            self.compute_api.reboot(req.environ['nova.context'], id)
+            self.compute_api.reboot(req.environ['nova.context'], id,
+                    reboot_type)
         except Exception, e:
             LOG.exception(_("Error in reboot %s"), e)
             raise exc.HTTPUnprocessableEntity()
@@ -851,12 +851,13 @@
 
 class ServerXMLSerializer(wsgi.XMLDictSerializer):
 
-    xmlns = wsgi.XMLNS_V11
+    NSMAP = {None: xmlutil.XMLNS_V11, 'atom': xmlutil.XMLNS_ATOM}
 
     def __init__(self):
         self.metadata_serializer = common.MetadataXMLSerializer()
         self.addresses_serializer = ips.IPXMLSerializer()
 
+<<<<<<< TREE
     def _create_basic_entity_node(self, xml_doc, id, links, name):
         basic_node = xml_doc.createElement(name)
         basic_node.setAttribute('id', str(id))
@@ -939,42 +940,114 @@
 
     def _server_list_to_xml(self, xml_doc, servers, detailed):
         container_node = xml_doc.createElement('servers')
+=======
+    def _create_metadata_node(self, metadata_dict):
+        metadata_elem = etree.Element('metadata', nsmap=self.NSMAP)
+        self.metadata_serializer.populate_metadata(metadata_elem,
+                                                   metadata_dict)
+        return metadata_elem
+
+    def _create_image_node(self, image_dict):
+        image_elem = etree.Element('image', nsmap=self.NSMAP)
+        image_elem.set('id', str(image_dict['id']))
+        for link in image_dict.get('links', []):
+            elem = etree.SubElement(image_elem,
+                                    '{%s}link' % xmlutil.XMLNS_ATOM)
+            elem.set('rel', link['rel'])
+            elem.set('href', link['href'])
+        return image_elem
+
+    def _create_flavor_node(self, flavor_dict):
+        flavor_elem = etree.Element('flavor', nsmap=self.NSMAP)
+        flavor_elem.set('id', str(flavor_dict['id']))
+        for link in flavor_dict.get('links', []):
+            elem = etree.SubElement(flavor_elem,
+                                    '{%s}link' % xmlutil.XMLNS_ATOM)
+            elem.set('rel', link['rel'])
+            elem.set('href', link['href'])
+        return flavor_elem
+
+    def _create_addresses_node(self, addresses_dict):
+        addresses_elem = etree.Element('addresses', nsmap=self.NSMAP)
+        self.addresses_serializer.populate_addresses_node(addresses_elem,
+                                                          addresses_dict)
+        return addresses_elem
+
+    def _populate_server(self, server_elem, server_dict, detailed=False):
+        """Populate a server xml element from a dict."""
+
+        server_elem.set('name', server_dict['name'])
+        server_elem.set('id', str(server_dict['id']))
+>>>>>>> MERGE-SOURCE
         if detailed:
-            server_to_xml = self._server_to_xml_detailed
-        else:
-            server_to_xml = self._server_to_xml
-
-        for server in servers:
-            item_node = server_to_xml(xml_doc, server)
-            container_node.appendChild(item_node)
-        return container_node
+            server_elem.set('uuid', str(server_dict['uuid']))
+            server_elem.set('userId', str(server_dict['user_id']))
+            server_elem.set('tenantId', str(server_dict['tenant_id']))
+            server_elem.set('updated', str(server_dict['updated']))
+            server_elem.set('created', str(server_dict['created']))
+            server_elem.set('hostId', str(server_dict['hostId']))
+            server_elem.set('accessIPv4', str(server_dict['accessIPv4']))
+            server_elem.set('accessIPv6', str(server_dict['accessIPv6']))
+            server_elem.set('status', str(server_dict['status']))
+            if 'progress' in server_dict:
+                server_elem.set('progress', str(server_dict['progress']))
+            image_elem = self._create_image_node(server_dict['image'])
+            server_elem.append(image_elem)
+
+            flavor_elem = self._create_flavor_node(server_dict['flavor'])
+            server_elem.append(flavor_elem)
+
+            meta_elem = self._create_metadata_node(
+                            server_dict.get('metadata', {}))
+            server_elem.append(meta_elem)
+
+            addresses_elem = self._create_addresses_node(
+                            server_dict.get('addresses', {}))
+            server_elem.append(addresses_elem)
+            groups = server_dict.get('security_groups')
+            if groups:
+                groups_elem = etree.SubElement(server_elem, 'security_groups')
+                for group in groups:
+                    group_elem = etree.SubElement(groups_elem,
+                                                  'security_group')
+                    group_elem.set('name', group['name'])
+
+        for link in server_dict.get('links', []):
+            elem = etree.SubElement(server_elem,
+                                    '{%s}link' % xmlutil.XMLNS_ATOM)
+            elem.set('rel', link['rel'])
+            elem.set('href', link['href'])
+        return server_elem
 
     def index(self, servers_dict):
-        xml_doc = minidom.Document()
-        node = self._server_list_to_xml(xml_doc,
-                                       servers_dict['servers'],
-                                       detailed=False)
-        return self.to_xml_string(node, True)
+        servers = etree.Element('servers', nsmap=self.NSMAP)
+        for server_dict in servers_dict['servers']:
+            server = etree.SubElement(servers, 'server')
+            self._populate_server(server, server_dict, False)
+        return self._to_xml(servers)
 
     def detail(self, servers_dict):
-        xml_doc = minidom.Document()
-        node = self._server_list_to_xml(xml_doc,
-                                       servers_dict['servers'],
-                                       detailed=True)
-        return self.to_xml_string(node, True)
+        servers = etree.Element('servers', nsmap=self.NSMAP)
+        for server_dict in servers_dict['servers']:
+            server = etree.SubElement(servers, 'server')
+            self._populate_server(server, server_dict, True)
+        return self._to_xml(servers)
 
     def show(self, server_dict):
-        xml_doc = minidom.Document()
-        node = self._server_to_xml_detailed(xml_doc,
-                                       server_dict['server'])
-        return self.to_xml_string(node, True)
+        server = etree.Element('server', nsmap=self.NSMAP)
+        self._populate_server(server, server_dict['server'], True)
+        return self._to_xml(server)
 
     def create(self, server_dict):
-        xml_doc = minidom.Document()
-        node = self._server_to_xml_detailed(xml_doc,
-                                       server_dict['server'])
-        node.setAttribute('adminPass', server_dict['server']['adminPass'])
-        return self.to_xml_string(node, True)
+        server = etree.Element('server', nsmap=self.NSMAP)
+        self._populate_server(server, server_dict['server'], True)
+        server.set('adminPass', server_dict['server']['adminPass'])
+        return self._to_xml(server)
+
+    def action(self, server_dict):
+        #NOTE(bcwaldon): We need a way to serialize actions individually. This
+        # assumes all actions return a server entity
+        return self.create(server_dict)
 
     def action(self, server_dict):
         #NOTE(bcwaldon): We need a way to serialize actions individually. This
@@ -982,10 +1055,9 @@
         return self.create(server_dict)
 
     def update(self, server_dict):
-        xml_doc = minidom.Document()
-        node = self._server_to_xml_detailed(xml_doc,
-                                       server_dict['server'])
-        return self.to_xml_string(node, True)
+        server = etree.Element('server', nsmap=self.NSMAP)
+        self._populate_server(server, server_dict['server'], True)
+        return self._to_xml(server)
 
     def _security_group_to_xml(self, doc, security_group):
         node = doc.createElement('security_group')

=== modified file 'nova/api/openstack/versions.py'
--- nova/api/openstack/versions.py	2011-08-03 13:54:00 +0000
+++ nova/api/openstack/versions.py	2011-09-17 02:16:44 +0000
@@ -16,12 +16,13 @@
 #    under the License.
 
 from datetime import datetime
+from lxml import etree
 import webob
 import webob.dec
-from xml.dom import minidom
 
 import nova.api.openstack.views.versions
 from nova.api.openstack import wsgi
+from nova.api.openstack import xmlutil
 
 
 VERSIONS = {
@@ -106,7 +107,9 @@
             headers_serializer=headers_serializer)
 
         supported_content_types = ('application/json',
+                                   'application/vnd.openstack.compute+json',
                                    'application/xml',
+                                   'application/vnd.openstack.compute+xml',
                                    'application/atom+xml')
         deserializer = VersionsRequestDeserializer(
             supported_content_types=supported_content_types)
@@ -159,83 +162,51 @@
 
 
 class VersionsXMLSerializer(wsgi.XMLDictSerializer):
-    #TODO(wwolf): this is temporary until we get rid of toprettyxml
-    # in the base class (XMLDictSerializer), which I plan to do in
-    # another branch
-    def to_xml_string(self, node, has_atom=False):
-        self._add_xmlns(node, has_atom)
-        return node.toxml(encoding='UTF-8')
-
-    def _versions_to_xml(self, versions, name="versions", xmlns=None):
-        root = self._xml_doc.createElement(name)
-        root.setAttribute("xmlns", wsgi.XMLNS_V11)
-        root.setAttribute("xmlns:atom", wsgi.XMLNS_ATOM)
-
-        for version in versions:
-            root.appendChild(self._create_version_node(version))
-
-        return root
-
-    def _create_media_types(self, media_types):
-        base = self._xml_doc.createElement('media-types')
-        for type in media_types:
-            node = self._xml_doc.createElement('media-type')
-            node.setAttribute('base', type['base'])
-            node.setAttribute('type', type['type'])
-            base.appendChild(node)
-
-        return base
-
-    def _create_version_node(self, version, create_ns=False):
-        version_node = self._xml_doc.createElement('version')
-        if create_ns:
-            xmlns = wsgi.XMLNS_V11
-            xmlns_atom = wsgi.XMLNS_ATOM
-            version_node.setAttribute('xmlns', xmlns)
-            version_node.setAttribute('xmlns:atom', xmlns_atom)
-
-        version_node.setAttribute('id', version['id'])
-        version_node.setAttribute('status', version['status'])
+
+    def _populate_version(self, version_node, version):
+        version_node.set('id', version['id'])
+        version_node.set('status', version['status'])
         if 'updated' in version:
-            version_node.setAttribute('updated', version['updated'])
-
+            version_node.set('updated', version['updated'])
         if 'media-types' in version:
-            media_types = self._create_media_types(version['media-types'])
-            version_node.appendChild(media_types)
-
-        link_nodes = self._create_link_nodes(self._xml_doc, version['links'])
-        for link in link_nodes:
-            version_node.appendChild(link)
-
-        return version_node
+            media_types = etree.SubElement(version_node, 'media-types')
+            for mtype in version['media-types']:
+                elem = etree.SubElement(media_types, 'media-type')
+                elem.set('base', mtype['base'])
+                elem.set('type', mtype['type'])
+        for link in version.get('links', []):
+            elem = etree.SubElement(version_node,
+                                    '{%s}link' % xmlutil.XMLNS_ATOM)
+            elem.set('rel', link['rel'])
+            elem.set('href', link['href'])
+            if 'type' in link:
+                elem.set('type', link['type'])
+
+    NSMAP = {None: xmlutil.XMLNS_V11, 'atom': xmlutil.XMLNS_ATOM}
 
     def index(self, data):
-        self._xml_doc = minidom.Document()
-        node = self._versions_to_xml(data['versions'])
-
-        return self.to_xml_string(node)
+        root = etree.Element('versions', nsmap=self.NSMAP)
+        for version in data['versions']:
+            version_elem = etree.SubElement(root, 'version')
+            self._populate_version(version_elem, version)
+        return self._to_xml(root)
 
     def show(self, data):
-        self._xml_doc = minidom.Document()
-        node = self._create_version_node(data['version'], True)
-
-        return self.to_xml_string(node)
+        root = etree.Element('version', nsmap=self.NSMAP)
+        self._populate_version(root, data['version'])
+        return self._to_xml(root)
 
     def multi(self, data):
-        self._xml_doc = minidom.Document()
-        node = self._versions_to_xml(data['choices'], 'choices',
-                         xmlns=wsgi.XMLNS_V11)
-
-        return self.to_xml_string(node)
+        root = etree.Element('choices', nsmap=self.NSMAP)
+        for version in data['choices']:
+            version_elem = etree.SubElement(root, 'version')
+            self._populate_version(version_elem, version)
+        return self._to_xml(root)
 
 
 class VersionsAtomSerializer(wsgi.XMLDictSerializer):
-    #TODO(wwolf): this is temporary until we get rid of toprettyxml
-    # in the base class (XMLDictSerializer), which I plan to do in
-    # another branch
-    def to_xml_string(self, node, has_atom=False):
-        self._add_xmlns(node, has_atom)
-        return node.toxml(encoding='UTF-8')
+
+    NSMAP = {None: xmlutil.XMLNS_ATOM}
 
     def __init__(self, metadata=None, xmlns=None):
         self.metadata = metadata or {}
@@ -244,14 +215,6 @@
         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:
@@ -269,105 +232,64 @@
         link_href = link_href.rstrip('/')
         return link_href.rsplit('/', 1)[0] + '/'
 
-    def _create_detail_meta(self, root, version):
-        title = self._create_text_elem('title', "About This Version",
-                                       type='text')
-
-        updated = self._create_text_elem('updated', version['updated'])
-
-        uri = version['links'][0]['href']
-        id = self._create_text_elem('id', uri)
-
-        link = self._xml_doc.createElement('link')
-        link.setAttribute('rel', 'self')
-        link.setAttribute('href', uri)
-
-        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_list_meta(self, root, versions):
-        title = self._create_text_elem('title', "Available API Versions",
-                                       type='text')
+    def _create_feed(self, versions, feed_title, feed_id):
+        feed = etree.Element('feed', nsmap=self.NSMAP)
+        title = etree.SubElement(feed, 'title')
+        title.set('type', 'text')
+        title.text = feed_title
+
         # 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):
+        etree.SubElement(feed, 'updated').text = recent
+
+        etree.SubElement(feed, 'id').text = feed_id
+
+        link = etree.SubElement(feed, 'link')
+        link.set('rel', 'self')
+        link.set('href', feed_id)
+
+        author = etree.SubElement(feed, 'author')
+        etree.SubElement(author, 'name').text = 'Rackspace'
+        etree.SubElement(author, 'uri').text = 'http://www.rackspace.com/'
+
         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'])
-                if 'type' in link:
-                    link_node.setAttribute('type', link['type'])
-
-                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)
+            feed.append(self._create_version_entry(version))
+
+        return feed
+
+    def _create_version_entry(self, version):
+        entry = etree.Element('entry')
+        etree.SubElement(entry, 'id').text = version['links'][0]['href']
+        title = etree.SubElement(entry, 'title')
+        title.set('type', 'text')
+        title.text = 'Version %s' % version['id']
+        etree.SubElement(entry, 'updated').text = version['updated']
+
+        for link in version['links']:
+            link_elem = etree.SubElement(entry, 'link')
+            link_elem.set('rel', link['rel'])
+            link_elem.set('href', link['href'])
+            if 'type' in link:
+                link_elem.set('type', link['type'])
+
+        content = etree.SubElement(entry, 'content')
+        content.set('type', 'text')
+        content.text = 'Version %s %s (%s)' % (version['id'],
+                                               version['status'],
+                                               version['updated'])
+        return entry
 
     def index(self, data):
-        self._xml_doc = minidom.Document()
-        node = self._xml_doc.createElementNS(self.xmlns, 'feed')
-        self._create_list_meta(node, data['versions'])
-        self._create_version_entries(node, data['versions'])
-
-        return self.to_xml_string(node)
+        versions = data['versions']
+        feed_id = self._get_base_url(versions[0]['links'][0]['href'])
+        feed = self._create_feed(versions, 'Available API Versions', feed_id)
+        return self._to_xml(feed)
 
     def show(self, data):
-        self._xml_doc = minidom.Document()
-        node = self._xml_doc.createElementNS(self.xmlns, 'feed')
-        self._create_detail_meta(node, data['version'])
-        self._create_version_entries(node, [data['version']])
-
-        return self.to_xml_string(node)
+        version = data['version']
+        feed_id = version['links'][0]['href']
+        feed = self._create_feed([version], 'About This Version', feed_id)
+        return self._to_xml(feed)
 
 
 class VersionsHeadersSerializer(wsgi.ResponseHeadersSerializer):
@@ -388,7 +310,9 @@
     serializer = wsgi.ResponseSerializer(body_serializers)
 
     supported_content_types = ('application/json',
+                               'application/vnd.openstack.compute+json',
                                'application/xml',
+                               'application/vnd.openstack.compute+xml',
                                'application/atom+xml')
     deserializer = wsgi.RequestDeserializer(
         supported_content_types=supported_content_types)

=== modified file 'nova/api/openstack/views/flavors.py'
--- nova/api/openstack/views/flavors.py	2011-08-09 23:26:35 +0000
+++ nova/api/openstack/views/flavors.py	2011-09-17 02:16:44 +0000
@@ -50,6 +50,9 @@
             "disk": flavor_obj["local_gb"],
         }
 
+        for key in ("vcpus", "swap", "rxtx_quota", "rxtx_cap"):
+            detail[key] = flavor_obj.get(key, "")
+
         detail.update(simple)
 
         return detail

=== modified file 'nova/api/openstack/views/images.py'
--- nova/api/openstack/views/images.py	2011-09-09 21:25:45 +0000
+++ nova/api/openstack/views/images.py	2011-09-17 02:16:44 +0000
@@ -71,6 +71,7 @@
         }
 
         self._build_server(image, image_obj)
+        self._build_image_id(image, image_obj)
 
         if detail:
             image.update({
@@ -96,6 +97,12 @@
         except (KeyError, ValueError):
             pass
 
+    def _build_image_id(self, image, image_obj):
+        try:
+            image['id'] = int(image_obj['id'])
+        except ValueError:
+            pass
+
 
 class ViewBuilderV11(ViewBuilder):
     """OpenStack API v1.1 Image Builder"""
@@ -119,6 +126,9 @@
         except KeyError:
             return
 
+    def _build_image_id(self, image, image_obj):
+        image['id'] = "%s" % image_obj['id']
+
     def generate_href(self, image_id):
         """Return an href string pointing to this object."""
         return os.path.join(self.base_url, self.project_id,

=== modified file 'nova/api/openstack/views/versions.py'
--- nova/api/openstack/views/versions.py	2011-08-03 13:54:00 +0000
+++ nova/api/openstack/views/versions.py	2011-09-17 02:16:44 +0000
@@ -52,7 +52,7 @@
 
     def build_versions(self, versions):
         version_objs = []
-        for version in versions:
+        for version in sorted(versions.keys()):
             version = versions[version]
             version_objs.append({
                 "id": version['id'],

=== modified file 'nova/api/openstack/wsgi.py'
--- nova/api/openstack/wsgi.py	2011-08-23 17:08:42 +0000
+++ nova/api/openstack/wsgi.py	2011-09-17 02:16:44 +0000
@@ -1,5 +1,22 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
 
 import json
+from lxml import etree
 import webob
 from xml.dom import minidom
 from xml.parsers import expat
@@ -18,6 +35,21 @@
 
 LOG = logging.getLogger('nova.api.openstack.wsgi')
 
+# The vendor content types should serialize identically to the non-vendor
+# content types. So to avoid littering the code with both options, we
+# map the vendor to the other when looking up the type
+_CONTENT_TYPE_MAP = {
+    'application/vnd.openstack.compute+json': 'application/json',
+    'application/vnd.openstack.compute+xml': 'application/xml',
+}
+
+_SUPPORTED_CONTENT_TYPES = (
+    'application/json',
+    'application/vnd.openstack.compute+json',
+    'application/xml',
+    'application/vnd.openstack.compute+xml',
+)
+
 
 class Request(webob.Request):
     """Add some Openstack API-specific logic to the base webob.Request."""
@@ -29,7 +61,7 @@
 
         """
         supported_content_types = supported_content_types or \
-            ('application/json', 'application/xml')
+            _SUPPORTED_CONTENT_TYPES
 
         parts = self.path.rsplit('.', 1)
         if len(parts) > 1:
@@ -51,7 +83,7 @@
         if not "Content-Type" in self.headers:
             return None
 
-        allowed_types = ("application/xml", "application/json")
+        allowed_types = _SUPPORTED_CONTENT_TYPES
         content_type = self.content_type
 
         if content_type not in allowed_types:
@@ -191,7 +223,7 @@
                  supported_content_types=None):
 
         self.supported_content_types = supported_content_types or \
-                ('application/json', 'application/xml')
+                _SUPPORTED_CONTENT_TYPES
 
         self.body_deserializers = {
             'application/xml': XMLDeserializer(),
@@ -249,7 +281,8 @@
 
     def get_body_deserializer(self, content_type):
         try:
-            return self.body_deserializers[content_type]
+            ctype = _CONTENT_TYPE_MAP.get(content_type, content_type)
+            return self.body_deserializers[ctype]
         except (KeyError, TypeError):
             raise exception.InvalidContentType(content_type=content_type)
 
@@ -315,7 +348,7 @@
 
     def to_xml_string(self, node, has_atom=False):
         self._add_xmlns(node, has_atom)
-        return node.toprettyxml(indent='    ', encoding='UTF-8')
+        return node.toxml('UTF-8')
 
     #NOTE (ameade): the has_atom should be removed after all of the
     # xml serializers and view builders have been updated to the current
@@ -392,6 +425,10 @@
             link_nodes.append(link_node)
         return link_nodes
 
+    def _to_xml(self, root):
+        """Convert the xml object to an xml string."""
+        return etree.tostring(root, encoding='UTF-8', xml_declaration=True)
+
 
 class ResponseHeadersSerializer(ActionDispatcher):
     """Default response headers serialization"""
@@ -439,7 +476,8 @@
 
     def get_body_serializer(self, content_type):
         try:
-            return self.body_serializers[content_type]
+            ctype = _CONTENT_TYPE_MAP.get(content_type, content_type)
+            return self.body_serializers[ctype]
         except (KeyError, TypeError):
             raise exception.InvalidContentType(content_type=content_type)
 

=== modified file 'nova/compute/api.py'
--- nova/compute/api.py	2011-09-12 20:32:09 +0000
+++ nova/compute/api.py	2011-09-17 02:16:44 +0000
@@ -1043,13 +1043,22 @@
         return recv_meta
 
     @scheduler_api.reroute_compute("reboot")
-    def reboot(self, context, instance_id):
+    def reboot(self, context, instance_id, reboot_type):
         """Reboot the given instance."""
+<<<<<<< TREE
         self.update(context,
                     instance_id,
                     vm_state=vm_states.ACTIVE,
                     task_state=task_states.REBOOTING)
         self._cast_compute_message('reboot_instance', context, instance_id)
+=======
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.ACTIVE,
+                    task_state=task_states.REBOOTING)
+        self._cast_compute_message('reboot_instance', context, instance_id,
+                params={'reboot_type': reboot_type})
+>>>>>>> MERGE-SOURCE
 
     @scheduler_api.reroute_compute("rebuild")
     def rebuild(self, context, instance_id, image_href, admin_password,

=== modified file 'nova/compute/manager.py'
--- nova/compute/manager.py	2011-09-12 15:00:09 +0000
+++ nova/compute/manager.py	2011-09-17 02:16:44 +0000
@@ -580,7 +580,7 @@
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def reboot_instance(self, context, instance_id):
+    def reboot_instance(self, context, instance_id, reboot_type="SOFT"):
         """Reboot an instance on this host."""
         LOG.audit(_("Rebooting instance %s"), instance_id, context=context)
         context = context.elevated()
@@ -602,6 +602,7 @@
                      context=context)
 
         network_info = self._get_instance_nw_info(context, instance_ref)
+<<<<<<< TREE
         self.driver.reboot(instance_ref, network_info)
 
         current_power_state = self._get_power_state(context, instance_ref)
@@ -610,6 +611,16 @@
                               power_state=current_power_state,
                               vm_state=vm_states.ACTIVE,
                               task_state=None)
+=======
+        self.driver.reboot(instance_ref, network_info, reboot_type)
+
+        current_power_state = self._get_power_state(context, instance_ref)
+        self._instance_update(context,
+                              instance_id,
+                              power_state=current_power_state,
+                              vm_state=vm_states.ACTIVE,
+                              task_state=None)
+>>>>>>> MERGE-SOURCE
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     def snapshot_instance(self, context, instance_id, image_id,

=== modified file 'nova/image/fake.py'
--- nova/image/fake.py	2011-08-05 13:37:36 +0000
+++ nova/image/fake.py	2011-09-17 02:16:44 +0000
@@ -24,7 +24,6 @@
 from nova import exception
 from nova import flags
 from nova import log as logging
-from nova.image import service
 
 
 LOG = logging.getLogger('nova.image.fake')
@@ -33,7 +32,7 @@
 FLAGS = flags.FLAGS
 
 
-class _FakeImageService(service.BaseImageService):
+class _FakeImageService(object):
     """Mock (fake) image service for unit testing."""
 
     def __init__(self):

=== modified file 'nova/image/glance.py'
--- nova/image/glance.py	2011-09-12 19:18:57 +0000
+++ nova/image/glance.py	2011-09-17 02:16:44 +0000
@@ -31,7 +31,6 @@
 from nova import flags
 from nova import log as logging
 from nova import utils
-from nova.image import service
 
 
 LOG = logging.getLogger('nova.image.glance')
@@ -87,6 +86,7 @@
     return host, port
 
 
+<<<<<<< TREE
 def get_glance_client(context, image_href):
     """Get the correct glance client and id for the given image_href.
 
@@ -115,16 +115,38 @@
 
 
 class GlanceImageService(service.BaseImageService):
+=======
+def get_glance_client(context, image_href):
+    """Get the correct glance client and id for the given image_href.
+
+    The image_href param can be an href of the form
+    http://myglanceserver:9292/images/42, or just an int such as 42. If the
+    image_href is an int, then flags are used to create the default
+    glance client.
+
+    :param image_href: image ref/id for an image
+    :returns: a tuple of the form (glance_client, image_id)
+
+    """
+    image_href = image_href or 0
+    if str(image_href).isdigit():
+        glance_host, glance_port = pick_glance_api_server()
+        glance_client = _create_glance_client(context, glance_host,
+                                              glance_port)
+        return (glance_client, int(image_href))
+
+    try:
+        (image_id, host, port) = _parse_image_ref(image_href)
+    except ValueError:
+        raise exception.InvalidImageRef(image_href=image_href)
+    glance_client = _create_glance_client(context, glance_host, glance_port)
+    return (glance_client, image_id)
+
+
+class GlanceImageService(object):
+>>>>>>> MERGE-SOURCE
     """Provides storage and retrieval of disk image objects within Glance."""
 
-    GLANCE_ONLY_ATTRS = ['size', 'location', 'disk_format',
-                         'container_format', 'checksum']
-
-    # NOTE(sirp): Overriding to use _translate_to_service provided by
-    # BaseImageService
-    SERVICE_IMAGE_ATTRS = service.BaseImageService.BASE_IMAGE_ATTRS +\
-                          GLANCE_ONLY_ATTRS
-
     def __init__(self, client=None):
         self._client = client
 
@@ -160,7 +182,7 @@
         images = []
         for image_meta in image_metas:
             if self._is_image_available(context, image_meta):
-                base_image_meta = self._translate_to_base(image_meta)
+                base_image_meta = self._translate_from_glance(image_meta)
                 images.append(base_image_meta)
         return images
 
@@ -224,7 +246,7 @@
         if not self._is_image_available(context, image_meta):
             raise exception.ImageNotFound(image_id=image_id)
 
-        base_image_meta = self._translate_to_base(image_meta)
+        base_image_meta = self._translate_from_glance(image_meta)
         return base_image_meta
 
     def show_by_name(self, context, name):
@@ -248,7 +270,7 @@
         for chunk in image_chunks:
             data.write(chunk)
 
-        base_image_meta = self._translate_to_base(image_meta)
+        base_image_meta = self._translate_from_glance(image_meta)
         return base_image_meta
 
     def create(self, context, image_meta, data=None):
@@ -260,7 +282,7 @@
         # Translate Base -> Service
         LOG.debug(_('Creating image in Glance. Metadata passed in %s'),
                   image_meta)
-        sent_service_image_meta = self._translate_to_service(image_meta)
+        sent_service_image_meta = self._translate_to_glance(image_meta)
         LOG.debug(_('Metadata after formatting for Glance %s'),
                   sent_service_image_meta)
 
@@ -268,7 +290,7 @@
             sent_service_image_meta, data)
 
         # Translate Service -> Base
-        base_image_meta = self._translate_to_base(recv_service_image_meta)
+        base_image_meta = self._translate_from_glance(recv_service_image_meta)
         LOG.debug(_('Metadata returned from Glance formatted for Base %s'),
                   base_image_meta)
         return base_image_meta
@@ -281,14 +303,14 @@
         """
         # NOTE(vish): show is to check if image is available
         self.show(context, image_id)
-        image_meta = _convert_to_string(image_meta)
+        image_meta = self._translate_to_glance(image_meta)
         try:
             client = self._get_client(context)
             image_meta = client.update_image(image_id, image_meta, data)
         except glance_exception.NotFound:
             raise exception.ImageNotFound(image_id=image_id)
 
-        base_image_meta = self._translate_to_base(image_meta)
+        base_image_meta = self._translate_from_glance(image_meta)
         return base_image_meta
 
     def delete(self, context, image_id):
@@ -310,21 +332,19 @@
         pass
 
     @classmethod
-    def _translate_to_service(cls, image_meta):
-        image_meta = super(GlanceImageService,
-                           cls)._translate_to_service(image_meta)
+    def _translate_to_glance(cls, image_meta):
         image_meta = _convert_to_string(image_meta)
+        image_meta = _remove_read_only(image_meta)
         return image_meta
 
     @classmethod
-    def _translate_to_base(cls, image_meta):
-        """Override translation to handle conversion to datetime objects."""
-        image_meta = service.BaseImageService._propertify_metadata(
-                        image_meta, cls.SERVICE_IMAGE_ATTRS)
+    def _translate_from_glance(cls, image_meta):
+        image_meta = _limit_attributes(image_meta)
         image_meta = _convert_timestamps_to_datetimes(image_meta)
         image_meta = _convert_from_string(image_meta)
         return image_meta
 
+<<<<<<< TREE
     @staticmethod
     def _is_image_available(context, image_meta):
         """Check image availability.
@@ -339,6 +359,34 @@
         return service.BaseImageService._is_image_available(context,
                                                             image_meta)
 
+=======
+    @staticmethod
+    def _is_image_available(context, image_meta):
+        """Check image availability.
+
+        Under Glance, images are always available if the context has
+        an auth_token.
+
+        """
+        if hasattr(context, 'auth_token') and context.auth_token:
+            return True
+
+        if image_meta['is_public'] or context.is_admin:
+            return True
+
+        properties = image_meta['properties']
+
+        if context.project_id and ('project_id' in properties):
+            return str(properties['project_id']) == str(context.project_id)
+
+        try:
+            user_id = properties['user_id']
+        except KeyError:
+            return False
+
+        return str(user_id) == str(context.user_id)
+
+>>>>>>> MERGE-SOURCE
 
 # utility functions
 def _convert_timestamps_to_datetimes(image_meta):
@@ -397,3 +445,27 @@
 
 def _convert_to_string(metadata):
     return _convert(_json_dumps, metadata)
+
+
+def _limit_attributes(image_meta):
+    IMAGE_ATTRIBUTES = ['size', 'location', 'disk_format',
+                        'container_format', 'checksum', 'id',
+                        'name', 'created_at', 'updated_at',
+                        'deleted_at', 'deleted', 'status',
+                        'is_public']
+    output = {}
+    for attr in IMAGE_ATTRIBUTES:
+        output[attr] = image_meta.get(attr)
+
+    output['properties'] = image_meta.get('properties', {})
+
+    return output
+
+
+def _remove_read_only(image_meta):
+    IMAGE_ATTRIBUTES = ['updated_at', 'created_at', 'deleted_at']
+    output = copy.deepcopy(image_meta)
+    for attr in IMAGE_ATTRIBUTES:
+        if attr in output:
+            del output[attr]
+    return output

=== modified file 'nova/image/s3.py'
--- nova/image/s3.py	2011-08-16 00:12:03 +0000
+++ nova/image/s3.py	2011-09-17 02:16:44 +0000
@@ -34,7 +34,6 @@
 from nova import image
 from nova import log as logging
 from nova import utils
-from nova.image import service
 from nova.api.ec2 import ec2utils
 
 
@@ -48,7 +47,7 @@
                     'secret key to use for s3 server for images')
 
 
-class S3ImageService(service.BaseImageService):
+class S3ImageService(object):
     """Wraps an existing image service to support s3 based register."""
 
     def __init__(self, service=None, *args, **kwargs):

=== removed file 'nova/image/service.py'
--- nova/image/service.py	2011-05-25 21:28:10 +0000
+++ nova/image/service.py	1970-01-01 00:00:00 +0000
@@ -1,200 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-
-from nova import utils
-
-
-class BaseImageService(object):
-    """Base class for providing image search and retrieval services.
-
-    ImageService exposes two concepts of metadata:
-
-        1. First-class attributes: This is metadata that is common to all
-           ImageService subclasses and is shared across all hypervisors. These
-           attributes are defined by IMAGE_ATTRS.
-
-        2. Properties: This is metdata that is specific to an ImageService,
-           and Image, or a particular hypervisor. Any attribute not present in
-           BASE_IMAGE_ATTRS should be considered an image property.
-
-    This means that ImageServices will return BASE_IMAGE_ATTRS as keys in the
-    metadata dict, all other attributes will be returned as keys in the nested
-    'properties' dict.
-
-    """
-
-    BASE_IMAGE_ATTRS = ['id', 'name', 'created_at', 'updated_at',
-                        'deleted_at', 'deleted', 'status', 'is_public']
-
-    # NOTE(sirp): ImageService subclasses may override this to aid translation
-    # between BaseImageService attributes and additional metadata stored by
-    # the ImageService subclass
-    SERVICE_IMAGE_ATTRS = []
-
-    def index(self, context, *args, **kwargs):
-        """List images.
-
-        :returns: a sequence of mappings with the following signature
-                  {'id': opaque id of image, 'name': name of image}
-
-        """
-        raise NotImplementedError
-
-    def detail(self, context, *args, **kwargs):
-        """Detailed information about an images.
-
-        :returns: a sequence of mappings with the following signature
-                    {'id': opaque id of image,
-                     'name': name of image,
-                     'created_at': creation datetime object,
-                     'updated_at': modification datetime object,
-                     'deleted_at': deletion datetime object or None,
-                     'deleted': boolean indicating if image has been deleted,
-                     'status': string description of image status,
-                     'is_public': boolean indicating if image is public
-                     }
-
-        If the service does not implement a method that provides a detailed
-        set of information about images, then the method should raise
-        NotImplementedError, in which case Nova will emulate this method
-        with repeated calls to show() for each image received from the
-        index() method.
-
-        """
-        raise NotImplementedError
-
-    def show(self, context, image_id):
-        """Detailed information about an image.
-
-        :returns: a mapping with the following signature:
-            {'id': opaque id of image,
-             'name': name of image,
-             'created_at': creation datetime object,
-             'updated_at': modification datetime object,
-             'deleted_at': deletion datetime object or None,
-             'deleted': boolean indicating if image has been deleted,
-             'status': string description of image status,
-             'is_public': boolean indicating if image is public
-             }, ...
-
-        :raises: NotFound if the image does not exist
-
-        """
-        raise NotImplementedError
-
-    def get(self, context, data):
-        """Get an image.
-
-        :param data: a file-like object to hold binary image data
-        :returns: a dict containing image metadata, writes image data to data.
-        :raises: NotFound if the image does not exist
-
-        """
-        raise NotImplementedError
-
-    def create(self, context, metadata, data=None):
-        """Store the image metadata and data.
-
-        :returns: the new image metadata.
-        :raises: AlreadyExists if the image already exist.
-
-        """
-        raise NotImplementedError
-
-    def update(self, context, image_id, metadata, data=None):
-        """Update the given image metadata and data and return the metadata.
-
-        :raises: NotFound if the image does not exist.
-
-        """
-        raise NotImplementedError
-
-    def delete(self, context, image_id):
-        """Delete the given image.
-
-        :raises: NotFound if the image does not exist.
-
-        """
-        raise NotImplementedError
-
-    @staticmethod
-    def _is_image_available(context, image_meta):
-        """Check image availability.
-
-        Images are always available if they are public or if the user is an
-        admin.
-
-        Otherwise, we filter by project_id (if present) and then fall-back to
-        images owned by user.
-
-        """
-        # FIXME(sirp): We should be filtering by user_id on the Glance side
-        # for security; however, we can't do that until we get authn/authz
-        # sorted out. Until then, filtering in Nova.
-        if image_meta['is_public'] or context.is_admin:
-            return True
-
-        properties = image_meta['properties']
-
-        if context.project_id and ('project_id' in properties):
-            return str(properties['project_id']) == str(context.project_id)
-
-        try:
-            user_id = properties['user_id']
-        except KeyError:
-            return False
-
-        return str(user_id) == str(context.user_id)
-
-    @classmethod
-    def _translate_to_base(cls, metadata):
-        """Return a metadata dictionary that is BaseImageService compliant.
-
-        This is used by subclasses to expose only a metadata dictionary that
-        is the same across ImageService implementations.
-
-        """
-        return cls._propertify_metadata(metadata, cls.BASE_IMAGE_ATTRS)
-
-    @classmethod
-    def _translate_to_service(cls, metadata):
-        """Return a metadata dict that is usable by the ImageService subclass.
-
-        As an example, Glance has additional attributes (like 'location'); the
-        BaseImageService considers these properties, but we need to translate
-        these back to first-class attrs for sending to Glance. This method
-        handles this by allowing you to specify the attributes an ImageService
-        considers first-class.
-
-        """
-        if not cls.SERVICE_IMAGE_ATTRS:
-            raise NotImplementedError(_('Cannot use this without specifying '
-                                        'SERVICE_IMAGE_ATTRS for subclass'))
-        return cls._propertify_metadata(metadata, cls.SERVICE_IMAGE_ATTRS)
-
-    @staticmethod
-    def _propertify_metadata(metadata, keys):
-        """Move unknown keys to a nested 'properties' dict.
-
-        :returns: a new dict with the keys moved.
-
-        """
-        flattened = utils.flatten_dict(metadata)
-        attributes, properties = utils.partition_dict(flattened, keys)
-        attributes['properties'] = properties
-        return attributes

=== modified file 'nova/scheduler/abstract_scheduler.py'
--- nova/scheduler/abstract_scheduler.py	2011-09-08 20:27:33 +0000
+++ nova/scheduler/abstract_scheduler.py	2011-09-17 02:16:44 +0000
@@ -20,8 +20,8 @@
 behavior is to simply select all hosts and weight them the same.
 """
 
+import json
 import operator
-import json
 
 import M2Crypto
 

=== modified file 'nova/scheduler/base_scheduler.py'
--- nova/scheduler/base_scheduler.py	2011-09-07 18:37:29 +0000
+++ nova/scheduler/base_scheduler.py	2011-09-17 02:16:44 +0000
@@ -27,6 +27,8 @@
 from nova.scheduler import host_filter
 
 FLAGS = flags.FLAGS
+flags.DEFINE_boolean('spread_first', False,
+                     'Use a spread-first zone scheduler strategy')
 LOG = logging.getLogger('nova.scheduler.base_scheduler')
 
 
@@ -55,17 +57,39 @@
         scheduling objectives
         """
         # NOTE(sirp): The default logic is the same as the NoopCostFunction
-        hosts = [dict(weight=1, hostname=hostname, capabilities=capabilities)
-                 for hostname, capabilities in hosts]
-
-        # NOTE(Vek): What we actually need to return is enough hosts
-        #            for all the instances!
-        num_instances = request_spec.get('num_instances', 1)
-        instances = []
-        while num_instances > len(hosts):
-            instances.extend(hosts)
-            num_instances -= len(hosts)
-        if num_instances > 0:
-            instances.extend(hosts[:num_instances])
-
-        return instances
+<<<<<<< TREE
+        hosts = [dict(weight=1, hostname=hostname, capabilities=capabilities)
+                 for hostname, capabilities in hosts]
+
+        # NOTE(Vek): What we actually need to return is enough hosts
+        #            for all the instances!
+        num_instances = request_spec.get('num_instances', 1)
+        instances = []
+        while num_instances > len(hosts):
+            instances.extend(hosts)
+            num_instances -= len(hosts)
+        if num_instances > 0:
+            instances.extend(hosts[:num_instances])
+
+        return instances
+=======
+        hosts = [dict(weight=1, hostname=hostname, capabilities=capabilities)
+                 for hostname, capabilities in hosts]
+
+        # NOTE(Vek): What we actually need to return is enough hosts
+        #            for all the instances!
+        num_instances = request_spec.get('num_instances', 1)
+        instances = []
+        while num_instances > len(hosts):
+            instances.extend(hosts)
+            num_instances -= len(hosts)
+        if num_instances > 0:
+            instances.extend(hosts[:num_instances])
+
+        # Adjust the weights for a spread-first strategy
+        if FLAGS.spread_first:
+            for i, host in enumerate(hosts):
+                host['weight'] = i + 1
+
+        return instances
+>>>>>>> MERGE-SOURCE

=== renamed directory 'nova/tests/public_key' => 'nova/tests/api/ec2/public_key'
=== renamed file 'nova/tests/test_cloud.py' => 'nova/tests/api/ec2/test_cloud.py'
=== modified file 'nova/tests/api/openstack/common.py'
--- nova/tests/api/openstack/common.py	2011-03-09 20:08:11 +0000
+++ nova/tests/api/openstack/common.py	2011-09-17 02:16:44 +0000
@@ -34,3 +34,25 @@
             req.body = json.dumps(body)
         return req
     return web_request
+
+
+def compare_links(actual, expected):
+    """Compare xml atom links."""
+
+    return compare_tree_to_dict(actual, expected, ('rel', 'href', 'type'))
+
+
+def compare_media_types(actual, expected):
+    """Compare xml media types."""
+
+    return compare_tree_to_dict(actual, expected, ('base', 'type'))
+
+
+def compare_tree_to_dict(actual, expected, keys):
+    """Compare parts of lxml.etree objects to dicts."""
+
+    for elem, data in zip(actual, expected):
+        for key in keys:
+            if elem.get(key) != data.get(key):
+                return False
+    return True

=== modified file 'nova/tests/api/openstack/contrib/test_createserverext.py'
--- nova/tests/api/openstack/contrib/test_createserverext.py	2011-09-06 19:47:09 +0000
+++ nova/tests/api/openstack/contrib/test_createserverext.py	2011-09-17 02:16:44 +0000
@@ -45,6 +45,7 @@
 
 INVALID_NETWORKS = [('invalid', 'invalid-ip-address')]
 
+<<<<<<< TREE
 INSTANCE = {
              "id": 1,
              "display_name": "test_server",
@@ -77,6 +78,44 @@
                                        security_group_id):
     pass
 
+=======
+INSTANCE = {
+             "id": 1,
+             "display_name": "test_server",
+             "uuid": FAKE_UUID,
+             "user_id": 'fake_user_id',
+             "tenant_id": 'fake_tenant_id',
+             "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
+             "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0),
+             "security_groups": [{"id": 1, "name": "test"}],
+             "image_ref": 'http://foo.com/123',
+             "instance_type": {"flavorid": '124'},
+        }
+
+
+def return_server_by_id(context, id, session=None):
+    INSTANCE['id'] = id
+    return INSTANCE
+
+
+def return_security_group_non_existing(context, project_id, group_name):
+    raise exception.SecurityGroupNotFoundForProject(project_id=project_id,
+                                                 security_group_id=group_name)
+
+
+def return_security_group_get_by_name(context, project_id, group_name):
+    return {'id': 1, 'name': group_name}
+
+
+def return_security_group_get(context, security_group_id, session):
+    return {'id': security_group_id}
+
+
+def return_instance_add_security_group(context, instance_id,
+                                       security_group_id):
+    pass
+
+>>>>>>> MERGE-SOURCE
 
 class CreateserverextTest(test.TestCase):
 

=== modified file 'nova/tests/api/openstack/fakes.py'
--- nova/tests/api/openstack/fakes.py	2011-09-12 15:00:09 +0000
+++ nova/tests/api/openstack/fakes.py	2011-09-17 02:16:44 +0000
@@ -40,8 +40,8 @@
 from nova.auth.manager import User, Project
 import nova.image.fake
 from nova.image import glance
-from nova.image import service
 from nova.tests import fake_flags
+from nova.tests.glance import stubs as glance_stubs
 
 
 class Context(object):
@@ -83,7 +83,7 @@
         if fake_auth_context is not None:
             ctxt = fake_auth_context
         else:
-            ctxt = context.RequestContext('fake', 'fake')
+            ctxt = context.RequestContext('fake', 'fake', auth_token=True)
         api10 = openstack.FaultWrapper(api_auth.InjectContext(ctxt,
               limits.RateLimitingMiddleware(inner_app10)))
         api11 = openstack.FaultWrapper(api_auth.InjectContext(ctxt,
@@ -177,6 +177,39 @@
     stubs.Set(nova.compute.API, 'backup', backup)
 
 
+def _make_image_fixtures():
+    NOW_GLANCE_FORMAT = "2010-10-11T10:30:22"
+
+    image_id = 123
+    base_attrs = {'deleted': False}
+
+    fixtures = []
+
+    def add_fixture(**kwargs):
+        kwargs.update(base_attrs)
+        fixtures.append(kwargs)
+
+    # Public image
+    add_fixture(id=image_id, name='public image', is_public=True,
+                status='active', properties={'key1': 'value1'})
+    image_id += 1
+
+    # Snapshot for User 1
+    server_ref = 'http://localhost/v1.1/servers/42'
+    snapshot_properties = {'instance_ref': server_ref, 'user_id': 'fake'}
+    for status in ('queued', 'saving', 'active', 'killed',
+                   'deleted', 'pending_delete'):
+        add_fixture(id=image_id, name='%s snapshot' % status,
+                    is_public=False, status=status,
+                    properties=snapshot_properties)
+        image_id += 1
+
+    # Image without a name
+    add_fixture(id=image_id, is_public=True, status='active', properties={})
+
+    return fixtures
+
+
 def stub_out_glance_add_image(stubs, sent_to_glance):
     """
     We return the metadata sent to glance by modifying the sent_to_glance dict
@@ -192,91 +225,11 @@
     stubs.Set(glance_client.Client, 'add_image', fake_add_image)
 
 
-def stub_out_glance(stubs, initial_fixtures=None):
-
-    class FakeGlanceClient:
-
-        def __init__(self, initial_fixtures):
-            self.fixtures = initial_fixtures or []
-
-        def _filter_images(self, filters=None, marker=None, limit=None):
-            found = True
-            if marker:
-                found = False
-            if limit == 0:
-                limit = None
-
-            fixtures = []
-            count = 0
-            for f in self.fixtures:
-                if limit and count >= limit:
-                    break
-                if found:
-                    fixtures.append(f)
-                    count = count + 1
-                if f['id'] == marker:
-                    found = True
-
-            return fixtures
-
-        def fake_get_images(self, filters=None, marker=None, limit=None):
-            fixtures = self._filter_images(filters, marker, limit)
-            return [dict(id=f['id'], name=f['name'])
-                    for f in fixtures]
-
-        def fake_get_images_detailed(self, filters=None,
-                                     marker=None, limit=None):
-            return self._filter_images(filters, marker, limit)
-
-        def fake_get_image_meta(self, image_id):
-            image = self._find_image(image_id)
-            if image:
-                return copy.deepcopy(image)
-            raise glance_exc.NotFound
-
-        def fake_add_image(self, image_meta, data=None):
-            image_meta = copy.deepcopy(image_meta)
-            image_id = ''.join(random.choice(string.letters)
-                               for _ in range(20))
-            image_meta['id'] = image_id
-            self.fixtures.append(image_meta)
-            return copy.deepcopy(image_meta)
-
-        def fake_update_image(self, image_id, image_meta, data=None):
-            for attr in ('created_at', 'updated_at', 'deleted_at', 'deleted'):
-                if attr in image_meta:
-                    del image_meta[attr]
-
-            f = self._find_image(image_id)
-            if not f:
-                raise glance_exc.NotFound
-
-            f.update(image_meta)
-            return copy.deepcopy(f)
-
-        def fake_delete_image(self, image_id):
-            f = self._find_image(image_id)
-            if not f:
-                raise glance_exc.NotFound
-
-            self.fixtures.remove(f)
-
-        def _find_image(self, image_id):
-            for f in self.fixtures:
-                if str(f['id']) == str(image_id):
-                    return f
-            return None
-
-    GlanceClient = glance_client.Client
-    fake = FakeGlanceClient(initial_fixtures)
-
-    stubs.Set(GlanceClient, 'get_images', fake.fake_get_images)
-    stubs.Set(GlanceClient, 'get_images_detailed',
-              fake.fake_get_images_detailed)
-    stubs.Set(GlanceClient, 'get_image_meta', fake.fake_get_image_meta)
-    stubs.Set(GlanceClient, 'add_image', fake.fake_add_image)
-    stubs.Set(GlanceClient, 'update_image', fake.fake_update_image)
-    stubs.Set(GlanceClient, 'delete_image', fake.fake_delete_image)
+def stub_out_glance(stubs):
+    def fake_get_image_service():
+        client = glance_stubs.StubGlanceClient(_make_image_fixtures())
+        return nova.image.glance.GlanceImageService(client)
+    stubs.Set(nova.image, 'get_default_image_service', fake_get_image_service)
 
 
 class FakeToken(object):

=== modified file 'nova/tests/api/openstack/test_api.py'
--- nova/tests/api/openstack/test_api.py	2011-06-14 14:16:51 +0000
+++ nova/tests/api/openstack/test_api.py	2011-09-17 02:16:44 +0000
@@ -20,6 +20,7 @@
 import webob.exc
 import webob.dec
 
+from lxml import etree
 from webob import Request
 
 from nova import test
@@ -52,6 +53,30 @@
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
+    def test_vendor_content_type_json(self):
+        ctype = 'application/vnd.openstack.compute+json'
+
+        req = webob.Request.blank('/')
+        req.headers['Accept'] = ctype
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res.content_type, ctype)
+
+        body = json.loads(res.body)
+
+    def test_vendor_content_type_xml(self):
+        ctype = 'application/vnd.openstack.compute+xml'
+
+        req = webob.Request.blank('/')
+        req.headers['Accept'] = ctype
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res.content_type, ctype)
+
+        body = etree.XML(res.body)
+
     def test_exceptions_are_converted_to_faults(self):
 
         @webob.dec.wsgify

=== modified file 'nova/tests/api/openstack/test_common.py'
--- nova/tests/api/openstack/test_common.py	2011-08-11 19:30:43 +0000
+++ nova/tests/api/openstack/test_common.py	2011-09-17 02:16:44 +0000
@@ -19,6 +19,7 @@
 Test suites for 'common' code used throughout the OpenStack HTTP API.
 """
 
+from lxml import etree
 import webob.exc
 import xml.dom.minidom as minidom
 
@@ -26,6 +27,11 @@
 
 from nova import test
 from nova.api.openstack import common
+from nova.api.openstack import xmlutil
+
+
+NS = "{http://docs.openstack.org/compute/api/v1.1}"
+ATOMNS = "{http://www.w3.org/2005/Atom}"
 
 
 class LimiterTest(test.TestCase):
@@ -237,21 +243,41 @@
                           common.remove_version_from_href,
                           fixture)
 
-    def test_get_id_from_href(self):
+    def test_get_id_from_href_with_int_url(self):
         fixture = 'http://www.testsite.com/dir/45'
         actual = common.get_id_from_href(fixture)
-        expected = 45
-        self.assertEqual(actual, expected)
-
-    def test_get_id_from_href_bad_request(self):
-        fixture = 'http://45'
-        self.assertRaises(ValueError,
-                          common.get_id_from_href,
-                          fixture)
-
-    def test_get_id_from_href_int(self):
-        fixture = 1
-        self.assertEqual(fixture, common.get_id_from_href(fixture))
+        expected = '45'
+        self.assertEqual(actual, expected)
+
+    def test_get_id_from_href_with_int(self):
+        fixture = '45'
+        actual = common.get_id_from_href(fixture)
+        expected = '45'
+        self.assertEqual(actual, expected)
+
+    def test_get_id_from_href_with_int_url_query(self):
+        fixture = 'http://www.testsite.com/dir/45?asdf=jkl'
+        actual = common.get_id_from_href(fixture)
+        expected = '45'
+        self.assertEqual(actual, expected)
+
+    def test_get_id_from_href_with_uuid_url(self):
+        fixture = 'http://www.testsite.com/dir/abc123'
+        actual = common.get_id_from_href(fixture)
+        expected = "abc123"
+        self.assertEqual(actual, expected)
+
+    def test_get_id_from_href_with_uuid_url_query(self):
+        fixture = 'http://www.testsite.com/dir/abc123?asdf=jkl'
+        actual = common.get_id_from_href(fixture)
+        expected = "abc123"
+        self.assertEqual(actual, expected)
+
+    def test_get_id_from_href_with_uuid(self):
+        fixture = 'abc123'
+        actual = common.get_id_from_href(fixture)
+        expected = 'abc123'
+        self.assertEqual(actual, expected)
 
     def test_get_version_from_href(self):
         fixture = 'http://www.testsite.com/v1.1/images'
@@ -314,6 +340,20 @@
 
 class MetadataXMLSerializationTest(test.TestCase):
 
+    def test_xml_declaration(self):
+        serializer = common.MetadataXMLSerializer()
+        fixture = {
+            'metadata': {
+                'one': 'two',
+                'three': 'four',
+            },
+        }
+
+        output = serializer.serialize(fixture, 'index')
+        print output
+        has_dec = output.startswith("<?xml version='1.0' encoding='UTF-8'?>")
+        self.assertTrue(has_dec)
+
     def test_index(self):
         serializer = common.MetadataXMLSerializer()
         fixture = {
@@ -323,16 +363,16 @@
             },
         }
         output = serializer.serialize(fixture, 'index')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
-                <meta key="three">four</meta>
-                <meta key="one">two</meta>
-            </metadata>
-        """.replace("  ", "").replace("\n", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'metadata')
+        metadata_dict = fixture['metadata']
+        metadata_elems = root.findall('{0}meta'.format(NS))
+        self.assertEqual(len(metadata_elems), 2)
+        for i, metadata_elem in enumerate(metadata_elems):
+            (meta_key, meta_value) = metadata_dict.items()[i]
+            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
+            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
 
     def test_index_null(self):
         serializer = common.MetadataXMLSerializer()
@@ -342,15 +382,16 @@
             },
         }
         output = serializer.serialize(fixture, 'index')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
-                <meta key="None">None</meta>
-            </metadata>
-        """.replace("  ", "").replace("\n", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'metadata')
+        metadata_dict = fixture['metadata']
+        metadata_elems = root.findall('{0}meta'.format(NS))
+        self.assertEqual(len(metadata_elems), 1)
+        for i, metadata_elem in enumerate(metadata_elems):
+            (meta_key, meta_value) = metadata_dict.items()[i]
+            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
+            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
 
     def test_index_unicode(self):
         serializer = common.MetadataXMLSerializer()
@@ -360,15 +401,16 @@
             },
         }
         output = serializer.serialize(fixture, 'index')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString(u"""
-            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
-                <meta key="three">Jos\xe9</meta>
-            </metadata>
-        """.encode("UTF-8").replace("  ", "").replace("\n", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'metadata')
+        metadata_dict = fixture['metadata']
+        metadata_elems = root.findall('{0}meta'.format(NS))
+        self.assertEqual(len(metadata_elems), 1)
+        for i, metadata_elem in enumerate(metadata_elems):
+            (meta_key, meta_value) = metadata_dict.items()[i]
+            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
+            self.assertEqual(metadata_elem.text.strip(), meta_value)
 
     def test_show(self):
         serializer = common.MetadataXMLSerializer()
@@ -378,14 +420,12 @@
             },
         }
         output = serializer.serialize(fixture, 'show')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-            <meta xmlns="http://docs.openstack.org/compute/api/v1.1"
-                 key="one">two</meta>
-        """.replace("  ", "").replace("\n", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        print output
+        root = etree.XML(output)
+        meta_dict = fixture['meta']
+        (meta_key, meta_value) = meta_dict.items()[0]
+        self.assertEqual(str(root.get('key')), str(meta_key))
+        self.assertEqual(root.text.strip(), meta_value)
 
     def test_update_all(self):
         serializer = common.MetadataXMLSerializer()
@@ -396,16 +436,16 @@
             },
         }
         output = serializer.serialize(fixture, 'update_all')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
-                <meta key="key6">value6</meta>
-                <meta key="key4">value4</meta>
-            </metadata>
-        """.replace("  ", "").replace("\n", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'metadata')
+        metadata_dict = fixture['metadata']
+        metadata_elems = root.findall('{0}meta'.format(NS))
+        self.assertEqual(len(metadata_elems), 2)
+        for i, metadata_elem in enumerate(metadata_elems):
+            (meta_key, meta_value) = metadata_dict.items()[i]
+            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
+            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
 
     def test_update_item(self):
         serializer = common.MetadataXMLSerializer()
@@ -415,14 +455,12 @@
             },
         }
         output = serializer.serialize(fixture, 'update')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-            <meta xmlns="http://docs.openstack.org/compute/api/v1.1"
-                 key="one">two</meta>
-        """.replace("  ", "").replace("\n", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        print output
+        root = etree.XML(output)
+        meta_dict = fixture['meta']
+        (meta_key, meta_value) = meta_dict.items()[0]
+        self.assertEqual(str(root.get('key')), str(meta_key))
+        self.assertEqual(root.text.strip(), meta_value)
 
     def test_create(self):
         serializer = common.MetadataXMLSerializer()
@@ -434,6 +472,16 @@
             },
         }
         output = serializer.serialize(fixture, 'create')
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'metadata')
+        metadata_dict = fixture['metadata']
+        metadata_elems = root.findall('{0}meta'.format(NS))
+        self.assertEqual(len(metadata_elems), 3)
+        for i, metadata_elem in enumerate(metadata_elems):
+            (meta_key, meta_value) = metadata_dict.items()[i]
+            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
+            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
         actual = minidom.parseString(output.replace("  ", ""))
 
         expected = minidom.parseString("""

=== modified file 'nova/tests/api/openstack/test_extensions.py'
--- nova/tests/api/openstack/test_extensions.py	2011-08-30 19:41:30 +0000
+++ nova/tests/api/openstack/test_extensions.py	2011-09-17 02:16:44 +0000
@@ -87,6 +87,7 @@
         self.ext_list = [
             "Createserverext",
             "FlavorExtraSpecs",
+            "FlavorExtraData",
             "Floating_ips",
             "Fox In Socks",
             "Hosts",

=== modified file 'nova/tests/api/openstack/test_flavors.py'
--- nova/tests/api/openstack/test_flavors.py	2011-08-11 18:40:05 +0000
+++ nova/tests/api/openstack/test_flavors.py	2011-09-17 02:16:44 +0000
@@ -17,16 +17,21 @@
 
 import json
 import webob
-import xml.dom.minidom as minidom
+from lxml import etree
 
 from nova.api.openstack import flavors
 import nova.db.api
 from nova import exception
 from nova import test
+from nova.api.openstack import xmlutil
 from nova.tests.api.openstack import fakes
 from nova import wsgi
 
 
+NS = "{http://docs.openstack.org/compute/api/v1.1}"
+ATOMNS = "{http://www.w3.org/2005/Atom}"
+
+
 def stub_flavor(flavorid, name, memory_mb="256", local_gb="10"):
     return {
         "flavorid": str(flavorid),
@@ -107,12 +112,20 @@
                 "name": "flavor 1",
                 "ram": "256",
                 "disk": "10",
+                "rxtx_cap": "",
+                "rxtx_quota": "",
+                "swap": "",
+                "vcpus": "",
             },
             {
                 "id": "2",
                 "name": "flavor 2",
                 "ram": "256",
                 "disk": "10",
+                "rxtx_cap": "",
+                "rxtx_quota": "",
+                "swap": "",
+                "vcpus": "",
             },
         ]
         self.assertEqual(flavors, expected)
@@ -127,6 +140,10 @@
             "name": "flavor 12",
             "ram": "256",
             "disk": "10",
+            "rxtx_cap": "",
+            "rxtx_quota": "",
+            "swap": "",
+            "vcpus": "",
         }
         self.assertEqual(flavor, expected)
 
@@ -149,6 +166,10 @@
                 "name": "flavor 12",
                 "ram": "256",
                 "disk": "10",
+                "rxtx_cap": "",
+                "rxtx_quota": "",
+                "swap": "",
+                "vcpus": "",
                 "links": [
                     {
                         "rel": "self",
@@ -216,6 +237,10 @@
                     "name": "flavor 1",
                     "ram": "256",
                     "disk": "10",
+                    "rxtx_cap": "",
+                    "rxtx_quota": "",
+                    "swap": "",
+                    "vcpus": "",
                     "links": [
                         {
                             "rel": "self",
@@ -232,6 +257,10 @@
                     "name": "flavor 2",
                     "ram": "256",
                     "disk": "10",
+                    "rxtx_cap": "",
+                    "rxtx_quota": "",
+                    "swap": "",
+                    "vcpus": "",
                     "links": [
                         {
                             "rel": "self",
@@ -262,15 +291,50 @@
 
 class FlavorsXMLSerializationTest(test.TestCase):
 
+    def test_xml_declaration(self):
+        serializer = flavors.FlavorXMLSerializer()
+
+        fixture = {
+            "flavor": {
+                "id": "12",
+                "name": "asdf",
+                "ram": "256",
+                "disk": "10",
+                "rxtx_cap": "",
+                "rxtx_quota": "",
+                "swap": "",
+                "vcpus": "",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/fake/flavors/12",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/fake/flavors/12",
+                    },
+                ],
+            },
+        }
+
+        output = serializer.serialize(fixture, 'show')
+        print output
+        has_dec = output.startswith("<?xml version='1.0' encoding='UTF-8'?>")
+        self.assertTrue(has_dec)
+
     def test_show(self):
         serializer = flavors.FlavorXMLSerializer()
 
-        input = {
+        fixture = {
             "flavor": {
                 "id": "12",
                 "name": "asdf",
                 "ram": "256",
                 "disk": "10",
+                "rxtx_cap": "",
+                "rxtx_quota": "",
+                "swap": "",
+                "vcpus": "",
                 "links": [
                     {
                         "rel": "self",
@@ -284,34 +348,34 @@
             },
         }
 
-        output = serializer.serialize(input, 'show')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-        <flavor xmlns="http://docs.openstack.org/compute/api/v1.1"
-                xmlns:atom="http://www.w3.org/2005/Atom"
-                id="12"
-                name="asdf"
-                ram="256"
-                disk="10">
-            <atom:link href="http://localhost/v1.1/fake/flavors/12"
-                 rel="self"/>
-            <atom:link href="http://localhost/fake/flavors/12"
-                 rel="bookmark"/>
-        </flavor>
-        """.replace("  ", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        output = serializer.serialize(fixture, 'show')
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'flavor')
+        flavor_dict = fixture['flavor']
+
+        for key in ['name', 'id', 'ram', 'disk']:
+            self.assertEqual(root.get(key), str(flavor_dict[key]))
+
+        link_nodes = root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(flavor_dict['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
 
     def test_show_handles_integers(self):
         serializer = flavors.FlavorXMLSerializer()
 
-        input = {
+        fixture = {
             "flavor": {
                 "id": 12,
                 "name": "asdf",
                 "ram": 256,
                 "disk": 10,
+                "rxtx_cap": "",
+                "rxtx_quota": "",
+                "swap": "",
+                "vcpus": "",
                 "links": [
                     {
                         "rel": "self",
@@ -325,35 +389,35 @@
             },
         }
 
-        output = serializer.serialize(input, 'show')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-        <flavor xmlns="http://docs.openstack.org/compute/api/v1.1"
-                xmlns:atom="http://www.w3.org/2005/Atom"
-                id="12"
-                name="asdf"
-                ram="256"
-                disk="10">
-            <atom:link href="http://localhost/v1.1/fake/flavors/12"
-                 rel="self"/>
-            <atom:link href="http://localhost/fake/flavors/12"
-                 rel="bookmark"/>
-        </flavor>
-        """.replace("  ", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        output = serializer.serialize(fixture, 'show')
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'flavor')
+        flavor_dict = fixture['flavor']
+
+        for key in ['name', 'id', 'ram', 'disk']:
+            self.assertEqual(root.get(key), str(flavor_dict[key]))
+
+        link_nodes = root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(flavor_dict['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
 
     def test_detail(self):
         serializer = flavors.FlavorXMLSerializer()
 
-        input = {
+        fixture = {
             "flavors": [
                 {
                     "id": "23",
                     "name": "flavor 23",
                     "ram": "512",
                     "disk": "20",
+                    "rxtx_cap": "",
+                    "rxtx_quota": "",
+                    "swap": "",
+                    "vcpus": "",
                     "links": [
                         {
                             "rel": "self",
@@ -369,6 +433,10 @@
                     "name": "flavor 13",
                     "ram": "256",
                     "disk": "10",
+                    "rxtx_cap": "",
+                    "rxtx_quota": "",
+                    "swap": "",
+                    "vcpus": "",
                     "links": [
                         {
                             "rel": "self",
@@ -383,45 +451,38 @@
             ],
         }
 
-        output = serializer.serialize(input, 'detail')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-        <flavors xmlns="http://docs.openstack.org/compute/api/v1.1"
-                 xmlns:atom="http://www.w3.org/2005/Atom">
-            <flavor id="23"
-                    name="flavor 23"
-                    ram="512"
-                    disk="20">
-                <atom:link href="http://localhost/v1.1/fake/flavors/23"
-                     rel="self"/>
-                <atom:link href="http://localhost/fake/flavors/23"
-                     rel="bookmark"/>
-            </flavor>
-            <flavor id="13"
-                    name="flavor 13"
-                    ram="256"
-                    disk="10">
-                <atom:link href="http://localhost/v1.1/fake/flavors/13"
-                     rel="self"/>
-                <atom:link href="http://localhost/fake/flavors/13"
-                     rel="bookmark"/>
-            </flavor>
-        </flavors>
-        """.replace("  ", "") % locals())
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        output = serializer.serialize(fixture, 'detail')
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'flavors')
+        flavor_elems = root.findall('{0}flavor'.format(NS))
+        self.assertEqual(len(flavor_elems), 2)
+        for i, flavor_elem in enumerate(flavor_elems):
+            flavor_dict = fixture['flavors'][i]
+
+            for key in ['name', 'id', 'ram', 'disk']:
+                self.assertEqual(flavor_elem.get(key), str(flavor_dict[key]))
+
+            link_nodes = flavor_elem.findall('{0}link'.format(ATOMNS))
+            self.assertEqual(len(link_nodes), 2)
+            for i, link in enumerate(flavor_dict['links']):
+                for key, value in link.items():
+                    self.assertEqual(link_nodes[i].get(key), value)
 
     def test_index(self):
         serializer = flavors.FlavorXMLSerializer()
 
-        input = {
+        fixture = {
             "flavors": [
                 {
                     "id": "23",
                     "name": "flavor 23",
                     "ram": "512",
                     "disk": "20",
+                    "rxtx_cap": "",
+                    "rxtx_quota": "",
+                    "swap": "",
+                    "vcpus": "",
                     "links": [
                         {
                             "rel": "self",
@@ -437,6 +498,10 @@
                     "name": "flavor 13",
                     "ram": "256",
                     "disk": "10",
+                    "rxtx_cap": "",
+                    "rxtx_quota": "",
+                    "swap": "",
+                    "vcpus": "",
                     "links": [
                         {
                             "rel": "self",
@@ -451,42 +516,34 @@
             ],
         }
 
-        output = serializer.serialize(input, 'index')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-        <flavors xmlns="http://docs.openstack.org/compute/api/v1.1"
-                 xmlns:atom="http://www.w3.org/2005/Atom">
-            <flavor id="23" name="flavor 23">
-                <atom:link href="http://localhost/v1.1/fake/flavors/23"
-                     rel="self"/>
-                <atom:link href="http://localhost/fake/flavors/23"
-                     rel="bookmark"/>
-            </flavor>
-            <flavor id="13" name="flavor 13">
-                <atom:link href="http://localhost/v1.1/fake/flavors/13"
-                     rel="self"/>
-                <atom:link href="http://localhost/fake/flavors/13"
-                     rel="bookmark"/>
-            </flavor>
-        </flavors>
-        """.replace("  ", "") % locals())
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        output = serializer.serialize(fixture, 'index')
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'flavors_index')
+        flavor_elems = root.findall('{0}flavor'.format(NS))
+        self.assertEqual(len(flavor_elems), 2)
+        for i, flavor_elem in enumerate(flavor_elems):
+            flavor_dict = fixture['flavors'][i]
+
+            for key in ['name', 'id']:
+                self.assertEqual(flavor_elem.get(key), str(flavor_dict[key]))
+
+            link_nodes = flavor_elem.findall('{0}link'.format(ATOMNS))
+            self.assertEqual(len(link_nodes), 2)
+            for i, link in enumerate(flavor_dict['links']):
+                for key, value in link.items():
+                    self.assertEqual(link_nodes[i].get(key), value)
 
     def test_index_empty(self):
         serializer = flavors.FlavorXMLSerializer()
 
-        input = {
+        fixture = {
             "flavors": [],
         }
 
-        output = serializer.serialize(input, 'index')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-        <flavors xmlns="http://docs.openstack.org/compute/api/v1.1"
-                 xmlns:atom="http://www.w3.org/2005/Atom" />
-        """.replace("  ", "") % locals())
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        output = serializer.serialize(fixture, 'index')
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'flavors_index')
+        flavor_elems = root.findall('{0}flavor'.format(NS))
+        self.assertEqual(len(flavor_elems), 0)

=== modified file 'nova/tests/api/openstack/test_image_metadata.py'
--- nova/tests/api/openstack/test_image_metadata.py	2011-08-19 02:24:31 +0000
+++ nova/tests/api/openstack/test_image_metadata.py	2011-09-17 02:16:44 +0000
@@ -23,7 +23,6 @@
 from nova.api import openstack
 from nova import test
 from nova.tests.api.openstack import fakes
-import nova.wsgi
 
 
 FLAGS = flags.FLAGS
@@ -31,76 +30,20 @@
 
 class ImageMetaDataTest(test.TestCase):
 
-    IMAGE_FIXTURES = [
-        {'status': 'active',
-        'name': 'image1',
-        'deleted': False,
-        'container_format': None,
-        'checksum': None,
-        'created_at': '2011-03-22T17:40:15',
-        'disk_format': None,
-        'updated_at': '2011-03-22T17:40:15',
-        'id': '1',
-        'location': 'file:///var/lib/glance/images/1',
-        'is_public': True,
-        'deleted_at': None,
-        'properties': {
-            'key1': 'value1',
-            'key2': 'value2'},
-        'size': 5882349},
-        {'status': 'active',
-        'name': 'image2',
-        'deleted': False,
-        'container_format': None,
-        'checksum': None,
-        'created_at': '2011-03-22T17:40:15',
-        'disk_format': None,
-        'updated_at': '2011-03-22T17:40:15',
-        'id': '2',
-        'location': 'file:///var/lib/glance/images/2',
-        'is_public': True,
-        'deleted_at': None,
-        'properties': {
-            'key1': 'value1',
-            'key2': 'value2'},
-        'size': 5882349},
-        {'status': 'active',
-        'name': 'image3',
-        'deleted': False,
-        'container_format': None,
-        'checksum': None,
-        'created_at': '2011-03-22T17:40:15',
-        'disk_format': None,
-        'updated_at': '2011-03-22T17:40:15',
-        'id': '3',
-        'location': 'file:///var/lib/glance/images/2',
-        'is_public': True,
-        'deleted_at': None,
-        'properties': {},
-        'size': 5882349},
-        ]
-
     def setUp(self):
         super(ImageMetaDataTest, self).setUp()
-        self.flags(image_service='nova.image.glance.GlanceImageService')
-        # NOTE(dprince) max out properties/metadata in image 3 for testing
-        img3 = self.IMAGE_FIXTURES[2]
-        for num in range(FLAGS.quota_metadata_items):
-            img3['properties']['key%i' % num] = "blah"
-        fakes.stub_out_glance(self.stubs, self.IMAGE_FIXTURES)
+        fakes.stub_out_glance(self.stubs)
 
     def test_index(self):
-        req = webob.Request.blank('/v1.1/123/images/1/metadata')
+        req = webob.Request.blank('/v1.1/123/images/123/metadata')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(200, res.status_int)
-        expected = self.IMAGE_FIXTURES[0]['properties']
-        self.assertEqual(len(expected), len(res_dict['metadata']))
-        for (key, value) in res_dict['metadata'].items():
-            self.assertEqual(value, res_dict['metadata'][key])
+        expected = {'metadata': {'key1': 'value1'}}
+        self.assertEqual(res_dict, expected)
 
     def test_show(self):
-        req = webob.Request.blank('/v1.1/fake/images/1/metadata/key1')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata/key1')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(200, res.status_int)
@@ -109,32 +52,38 @@
         self.assertEqual('value1', res_dict['meta']['key1'])
 
     def test_show_not_found(self):
-        req = webob.Request.blank('/v1.1/fake/images/1/metadata/key9')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata/key9')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
+
+    def test_show_image_not_found(self):
+        req = webob.Request.blank('/v1.1/fake/images/100/metadata/key1')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(404, res.status_int)
 
     def test_create(self):
-        req = webob.Request.blank('/v1.1/fake/images/2/metadata')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata')
         req.method = 'POST'
-        req.body = '{"metadata": {"key9": "value9"}}'
+        req.body = '{"metadata": {"key7": "value7"}}'
         req.headers["content-type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
 
         self.assertEqual(200, res.status_int)
         actual_output = json.loads(res.body)
-
-        expected_output = {
-            'metadata': {
-                'key1': 'value1',
-                'key2': 'value2',
-                'key9': 'value9',
-            },
-        }
-
+        expected_output = {'metadata': {'key1': 'value1', 'key7': 'value7'}}
         self.assertEqual(expected_output, actual_output)
 
+    def test_create_image_not_found(self):
+        req = webob.Request.blank('/v1.1/fake/images/100/metadata')
+        req.method = 'POST'
+        req.body = '{"metadata": {"key7": "value7"}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+
+        self.assertEqual(404, res.status_int)
+
     def test_update_all(self):
-        req = webob.Request.blank('/v1.1/fake/images/1/metadata')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata')
         req.method = 'PUT'
         req.body = '{"metadata": {"key9": "value9"}}'
         req.headers["content-type"] = "application/json"
@@ -142,17 +91,20 @@
 
         self.assertEqual(200, res.status_int)
         actual_output = json.loads(res.body)
-
-        expected_output = {
-            'metadata': {
-                'key9': 'value9',
-            },
-        }
-
+        expected_output = {'metadata': {'key9': 'value9'}}
         self.assertEqual(expected_output, actual_output)
 
+    def test_update_all_image_not_found(self):
+        req = webob.Request.blank('/v1.1/fake/images/100/metadata')
+        req.method = 'PUT'
+        req.body = '{"metadata": {"key9": "value9"}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+
+        self.assertEqual(404, res.status_int)
+
     def test_update_item(self):
-        req = webob.Request.blank('/v1.1/fake/images/1/metadata/key1')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata/key1')
         req.method = 'PUT'
         req.body = '{"meta": {"key1": "zz"}}'
         req.headers["content-type"] = "application/json"
@@ -160,15 +112,20 @@
 
         self.assertEqual(200, res.status_int)
         actual_output = json.loads(res.body)
-        expected_output = {
-            'meta': {
-                'key1': 'zz',
-            },
-        }
+        expected_output = {'meta': {'key1': 'zz'}}
         self.assertEqual(actual_output, expected_output)
 
+    def test_update_item_image_not_found(self):
+        req = webob.Request.blank('/v1.1/fake/images/100/metadata/key1')
+        req.method = 'PUT'
+        req.body = '{"meta": {"key1": "zz"}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+
+        self.assertEqual(404, res.status_int)
+
     def test_update_item_bad_body(self):
-        req = webob.Request.blank('/v1.1/fake/images/1/metadata/key1')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata/key1')
         req.method = 'PUT'
         req.body = '{"key1": "zz"}'
         req.headers["content-type"] = "application/json"
@@ -176,15 +133,18 @@
         self.assertEqual(400, res.status_int)
 
     def test_update_item_too_many_keys(self):
-        req = webob.Request.blank('/v1.1/fake/images/1/metadata/key1')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata/key1')
         req.method = 'PUT'
-        req.body = '{"meta": {"key1": "value1", "key2": "value2"}}'
+        overload = {}
+        for num in range(FLAGS.quota_metadata_items + 1):
+            overload['key%s' % num] = 'value%s' % num
+        req.body = json.dumps({'meta': overload})
         req.headers["content-type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(400, res.status_int)
 
     def test_update_item_body_uri_mismatch(self):
-        req = webob.Request.blank('/v1.1/fake/images/1/metadata/bad')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata/bad')
         req.method = 'PUT'
         req.body = '{"meta": {"key1": "value1"}}'
         req.headers["content-type"] = "application/json"
@@ -192,7 +152,7 @@
         self.assertEqual(400, res.status_int)
 
     def test_update_item_xml(self):
-        req = webob.Request.blank('/v1.1/fake/images/1/metadata/key1')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata/key1')
         req.method = 'PUT'
         req.body = '<meta key="key1">five</meta>'
         req.headers["content-type"] = "application/xml"
@@ -200,22 +160,24 @@
 
         self.assertEqual(200, res.status_int)
         actual_output = json.loads(res.body)
-        expected_output = {
-            'meta': {
-                'key1': 'five',
-            },
-        }
+        expected_output = {'meta': {'key1': 'five'}}
         self.assertEqual(actual_output, expected_output)
 
     def test_delete(self):
-        req = webob.Request.blank('/v1.1/fake/images/2/metadata/key1')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata/key1')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(204, res.status_int)
         self.assertEqual('', res.body)
 
     def test_delete_not_found(self):
-        req = webob.Request.blank('/v1.1/fake/images/2/metadata/blah')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata/blah')
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
+
+    def test_delete_image_not_found(self):
+        req = webob.Request.blank('/v1.1/fake/images/100/metadata/key1')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(404, res.status_int)
@@ -225,7 +187,7 @@
         for num in range(FLAGS.quota_metadata_items + 1):
             data['metadata']['key%i' % num] = "blah"
         json_string = str(data).replace("\'", "\"")
-        req = webob.Request.blank('/v1.1/fake/images/2/metadata')
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata')
         req.method = 'POST'
         req.body = json_string
         req.headers["content-type"] = "application/json"
@@ -233,7 +195,8 @@
         self.assertEqual(413, res.status_int)
 
     def test_too_many_metadata_items_on_put(self):
-        req = webob.Request.blank('/v1.1/fake/images/3/metadata/blah')
+        FLAGS.quota_metadata_items = 1
+        req = webob.Request.blank('/v1.1/fake/images/123/metadata/blah')
         req.method = 'PUT'
         req.body = '{"meta": {"blah": "blah"}}'
         req.headers["content-type"] = "application/json"

=== modified file 'nova/tests/api/openstack/test_images.py'
--- nova/tests/api/openstack/test_images.py	2011-09-16 13:12:51 +0000
+++ nova/tests/api/openstack/test_images.py	2011-09-17 02:16:44 +0000
@@ -22,340 +22,57 @@
 
 import copy
 import json
-import os
-import shutil
-import tempfile
 import xml.dom.minidom as minidom
 
+from lxml import etree
 import mox
 import stubout
 import webob
 
-from glance import client as glance_client
 from nova import context
-from nova import exception
-from nova import test
-from nova import utils
 import nova.api.openstack
 from nova.api.openstack import images
+from nova.api.openstack import xmlutil
+from nova import test
 from nova.tests.api.openstack import fakes
 
 
-class _BaseImageServiceTests(test.TestCase):
-    """Tasks to test for all image services"""
-
-    def __init__(self, *args, **kwargs):
-        super(_BaseImageServiceTests, self).__init__(*args, **kwargs)
-        self.service = None
-        self.context = None
-
-    def test_create(self):
-        fixture = self._make_fixture('test image')
-        num_images = len(self.service.index(self.context))
-
-        image_id = self.service.create(self.context, fixture)['id']
-
-        self.assertNotEquals(None, image_id)
-        self.assertEquals(num_images + 1,
-                          len(self.service.index(self.context)))
-
-    def test_create_and_show_non_existing_image(self):
-        fixture = self._make_fixture('test image')
-        num_images = len(self.service.index(self.context))
-
-        image_id = self.service.create(self.context, fixture)['id']
-
-        self.assertNotEquals(None, image_id)
-        self.assertRaises(exception.NotFound,
-                          self.service.show,
-                          self.context,
-                          'bad image id')
-
-    def test_create_and_show_non_existing_image_by_name(self):
-        fixture = self._make_fixture('test image')
-        num_images = len(self.service.index(self.context))
-
-        image_id = self.service.create(self.context, fixture)['id']
-
-        self.assertNotEquals(None, image_id)
-        self.assertRaises(exception.ImageNotFound,
-                          self.service.show_by_name,
-                          self.context,
-                          'bad image id')
-
-    def test_update(self):
-        fixture = self._make_fixture('test image')
-        image_id = self.service.create(self.context, fixture)['id']
-        fixture['status'] = 'in progress'
-
-        self.service.update(self.context, image_id, fixture)
-
-        new_image_data = self.service.show(self.context, image_id)
-        self.assertEquals('in progress', new_image_data['status'])
-
-    def test_delete(self):
-        fixture1 = self._make_fixture('test image 1')
-        fixture2 = self._make_fixture('test image 2')
-        fixtures = [fixture1, fixture2]
-
-        num_images = len(self.service.index(self.context))
-        self.assertEquals(0, num_images, str(self.service.index(self.context)))
-
-        ids = []
-        for fixture in fixtures:
-            new_id = self.service.create(self.context, fixture)['id']
-            ids.append(new_id)
-
-        num_images = len(self.service.index(self.context))
-        self.assertEquals(2, num_images, str(self.service.index(self.context)))
-
-        self.service.delete(self.context, ids[0])
-
-        num_images = len(self.service.index(self.context))
-        self.assertEquals(1, num_images)
-
-    def test_index(self):
-        fixture = self._make_fixture('test image')
-        image_id = self.service.create(self.context, fixture)['id']
-        image_metas = self.service.index(self.context)
-        expected = [{'id': 'DONTCARE', 'name': 'test image'}]
-        self.assertDictListMatch(image_metas, expected)
-
-    @staticmethod
-    def _make_fixture(name):
-        fixture = {'name': name,
-                   'updated': None,
-                   'created': None,
-                   'status': None,
-                   'is_public': True}
-        return fixture
-
-
-class GlanceImageServiceTest(_BaseImageServiceTests):
-
-    """Tests the Glance image service, in particular that metadata translation
-    works properly.
-
-    At a high level, the translations involved are:
-
-        1. Glance -> ImageService - This is needed so we can support
-           multple ImageServices (Glance, Local, etc)
-
-        2. ImageService -> API - This is needed so we can support multple
-           APIs (OpenStack, EC2)
-    """
-    def setUp(self):
-        super(GlanceImageServiceTest, self).setUp()
-        self.stubs = stubout.StubOutForTesting()
-        fakes.stub_out_glance(self.stubs)
-        fakes.stub_out_compute_api_snapshot(self.stubs)
-        service_class = 'nova.image.glance.GlanceImageService'
-        self.service = utils.import_object(service_class)
-        self.context = context.RequestContext('fake', 'fake')
-        self.service.delete_all()
-        self.sent_to_glance = {}
-        fakes.stub_out_glance_add_image(self.stubs, self.sent_to_glance)
-
-    def tearDown(self):
-        self.stubs.UnsetAll()
-        super(GlanceImageServiceTest, self).tearDown()
-
-    def test_create_with_instance_id(self):
-        """Ensure instance_id is persisted as an image-property"""
-        fixture = {'name': 'test image',
-                   'is_public': False,
-                   'properties': {'instance_id': '42', 'user_id': 'fake'}}
-
-        image_id = self.service.create(self.context, fixture)['id']
-        expected = fixture
-        self.assertDictMatch(self.sent_to_glance['metadata'], expected)
-
-        image_meta = self.service.show(self.context, image_id)
-        expected = {'id': image_id,
-                    'name': 'test image',
-                    'is_public': False,
-                    'properties': {'instance_id': '42', 'user_id': 'fake'}}
-        self.assertDictMatch(image_meta, expected)
-
-        image_metas = self.service.detail(self.context)
-        self.assertDictMatch(image_metas[0], expected)
-
-    def test_create_without_instance_id(self):
-        """
-        Ensure we can create an image without having to specify an
-        instance_id. Public images are an example of an image not tied to an
-        instance.
-        """
-        fixture = {'name': 'test image'}
-        image_id = self.service.create(self.context, fixture)['id']
-
-        expected = {'name': 'test image', 'properties': {}}
-        self.assertDictMatch(self.sent_to_glance['metadata'], expected)
-
-    def test_index_default_limit(self):
-        fixtures = []
-        ids = []
-        for i in range(10):
-            fixture = self._make_fixture('TestImage %d' % (i))
-            fixtures.append(fixture)
-            ids.append(self.service.create(self.context, fixture)['id'])
-
-        image_metas = self.service.index(self.context)
-        i = 0
-        for meta in image_metas:
-            expected = {'id': 'DONTCARE',
-                        'name': 'TestImage %d' % (i)}
-            self.assertDictMatch(meta, expected)
-            i = i + 1
-
-    def test_index_marker(self):
-        fixtures = []
-        ids = []
-        for i in range(10):
-            fixture = self._make_fixture('TestImage %d' % (i))
-            fixtures.append(fixture)
-            ids.append(self.service.create(self.context, fixture)['id'])
-
-        image_metas = self.service.index(self.context, marker=ids[1])
-        self.assertEquals(len(image_metas), 8)
-        i = 2
-        for meta in image_metas:
-            expected = {'id': 'DONTCARE',
-                        'name': 'TestImage %d' % (i)}
-            self.assertDictMatch(meta, expected)
-            i = i + 1
-
-    def test_index_limit(self):
-        fixtures = []
-        ids = []
-        for i in range(10):
-            fixture = self._make_fixture('TestImage %d' % (i))
-            fixtures.append(fixture)
-            ids.append(self.service.create(self.context, fixture)['id'])
-
-        image_metas = self.service.index(self.context, limit=3)
-        self.assertEquals(len(image_metas), 3)
-
-    def test_index_marker_and_limit(self):
-        fixtures = []
-        ids = []
-        for i in range(10):
-            fixture = self._make_fixture('TestImage %d' % (i))
-            fixtures.append(fixture)
-            ids.append(self.service.create(self.context, fixture)['id'])
-
-        image_metas = self.service.index(self.context, marker=ids[3], limit=1)
-        self.assertEquals(len(image_metas), 1)
-        i = 4
-        for meta in image_metas:
-            expected = {'id': 'DONTCARE',
-                        'name': 'TestImage %d' % (i)}
-            self.assertDictMatch(meta, expected)
-            i = i + 1
-
-    def test_detail_marker(self):
-        fixtures = []
-        ids = []
-        for i in range(10):
-            fixture = self._make_fixture('TestImage %d' % (i))
-            fixtures.append(fixture)
-            ids.append(self.service.create(self.context, fixture)['id'])
-
-        image_metas = self.service.detail(self.context, marker=ids[1])
-        self.assertEquals(len(image_metas), 8)
-        i = 2
-        for meta in image_metas:
-            expected = {
-                'id': 'DONTCARE',
-                'status': None,
-                'is_public': True,
-                'name': 'TestImage %d' % (i),
-                'properties': {
-                    'updated': None,
-                    'created': None,
-                },
-            }
-
-            self.assertDictMatch(meta, expected)
-            i = i + 1
-
-    def test_detail_limit(self):
-        fixtures = []
-        ids = []
-        for i in range(10):
-            fixture = self._make_fixture('TestImage %d' % (i))
-            fixtures.append(fixture)
-            ids.append(self.service.create(self.context, fixture)['id'])
-
-        image_metas = self.service.detail(self.context, limit=3)
-        self.assertEquals(len(image_metas), 3)
-
-    def test_detail_marker_and_limit(self):
-        fixtures = []
-        ids = []
-        for i in range(10):
-            fixture = self._make_fixture('TestImage %d' % (i))
-            fixtures.append(fixture)
-            ids.append(self.service.create(self.context, fixture)['id'])
-
-        image_metas = self.service.detail(self.context, marker=ids[3], limit=3)
-        self.assertEquals(len(image_metas), 3)
-        i = 4
-        for meta in image_metas:
-            expected = {
-                'id': 'DONTCARE',
-                'status': None,
-                'is_public': True,
-                'name': 'TestImage %d' % (i),
-                'properties': {
-                    'updated': None, 'created': None},
-            }
-            self.assertDictMatch(meta, expected)
-            i = i + 1
-
-
-class ImageControllerWithGlanceServiceTest(test.TestCase):
+NS = "{http://docs.openstack.org/compute/api/v1.1}"
+ATOMNS = "{http://www.w3.org/2005/Atom}"
+NOW_API_FORMAT = "2010-10-11T10:30:22Z"
+
+
+class ImagesTest(test.TestCase):
     """
     Test of the OpenStack API /images application controller w/Glance.
     """
-    NOW_GLANCE_FORMAT = "2010-10-11T10:30:22"
-    NOW_API_FORMAT = "2010-10-11T10:30:22Z"
 
     def setUp(self):
         """Run before each test."""
-        super(ImageControllerWithGlanceServiceTest, self).setUp()
-        self.flags(image_service='nova.image.glance.GlanceImageService')
+        super(ImagesTest, self).setUp()
         self.stubs = stubout.StubOutForTesting()
         fakes.stub_out_networking(self.stubs)
         fakes.stub_out_rate_limiting(self.stubs)
         fakes.stub_out_key_pair_funcs(self.stubs)
-        self.fixtures = self._make_image_fixtures()
-        fakes.stub_out_glance(self.stubs, initial_fixtures=self.fixtures)
         fakes.stub_out_compute_api_snapshot(self.stubs)
         fakes.stub_out_compute_api_backup(self.stubs)
+        fakes.stub_out_glance(self.stubs)
 
     def tearDown(self):
         """Run after each test."""
         self.stubs.UnsetAll()
-        super(ImageControllerWithGlanceServiceTest, self).tearDown()
+        super(ImagesTest, self).tearDown()
 
     def _get_fake_context(self):
         class Context(object):
             project_id = 'fake'
+            auth_token = True
         return Context()
 
-    def _applicable_fixture(self, fixture, user_id):
-        """Determine if this fixture is applicable for given user id."""
-        is_public = fixture["is_public"]
-        try:
-            uid = fixture["properties"]["user_id"]
-        except KeyError:
-            uid = None
-        return uid == user_id or is_public
-
     def test_get_image_index(self):
         request = webob.Request.blank('/v1.0/images')
-        response = request.get_response(fakes.wsgi_app())
+        app = fakes.wsgi_app(fake_auth_context=self._get_fake_context())
+        response = request.get_response(app)
 
         response_dict = json.loads(response.body)
         response_list = response_dict["images"]
@@ -365,15 +82,22 @@
                     {'id': 125, 'name': 'saving snapshot'},
                     {'id': 126, 'name': 'active snapshot'},
                     {'id': 127, 'name': 'killed snapshot'},
+<<<<<<< TREE
                     {'id': 128, 'name': 'deleted snapshot'},
                     {'id': 129, 'name': 'pending_delete snapshot'},
                     {'id': 131, 'name': None}]
+=======
+                    {'id': 128, 'name': 'deleted snapshot'},
+                    {'id': 129, 'name': 'pending_delete snapshot'},
+                    {'id': 130, 'name': None}]
+>>>>>>> MERGE-SOURCE
 
         self.assertDictListMatch(response_list, expected)
 
     def test_get_image(self):
         request = webob.Request.blank('/v1.0/images/123')
-        response = request.get_response(fakes.wsgi_app())
+        app = fakes.wsgi_app(fake_auth_context=self._get_fake_context())
+        response = request.get_response(app)
 
         self.assertEqual(200, response.status_int)
 
@@ -383,18 +107,19 @@
             "image": {
                 "id": 123,
                 "name": "public image",
-                "updated": self.NOW_API_FORMAT,
-                "created": self.NOW_API_FORMAT,
+                "updated": NOW_API_FORMAT,
+                "created": NOW_API_FORMAT,
                 "status": "ACTIVE",
                 "progress": 100,
             },
         }
 
-        self.assertEqual(expected_image, actual_image)
+        self.assertDictMatch(expected_image, actual_image)
 
     def test_get_image_v1_1(self):
         request = webob.Request.blank('/v1.1/fake/images/124')
-        response = request.get_response(fakes.wsgi_app())
+        app = fakes.wsgi_app(fake_auth_context=self._get_fake_context())
+        response = request.get_response(app)
 
         actual_image = json.loads(response.body)
 
@@ -405,14 +130,20 @@
 
         expected_image = {
             "image": {
-                "id": 124,
+                "id": "124",
                 "name": "queued snapshot",
+<<<<<<< TREE
                 "updated": self.NOW_API_FORMAT,
                 "created": self.NOW_API_FORMAT,
                 "status": "SAVING",
+=======
+                "updated": NOW_API_FORMAT,
+                "created": NOW_API_FORMAT,
+                "status": "SAVING",
+>>>>>>> MERGE-SOURCE
                 "progress": 0,
                 'server': {
-                    'id': 42,
+                    'id': '42',
                     "links": [{
                         "rel": "self",
                         "href": server_href,
@@ -442,11 +173,12 @@
     def test_get_image_xml(self):
         request = webob.Request.blank('/v1.0/images/123')
         request.accept = "application/xml"
-        response = request.get_response(fakes.wsgi_app())
+        app = fakes.wsgi_app(fake_auth_context=self._get_fake_context())
+        response = request.get_response(app)
 
         actual_image = minidom.parseString(response.body.replace("  ", ""))
 
-        expected_now = self.NOW_API_FORMAT
+        expected_now = NOW_API_FORMAT
         expected_image = minidom.parseString("""
             <image id="123"
                     name="public image"
@@ -460,15 +192,24 @@
         self.assertEqual(expected_image.toxml(), actual_image.toxml())
 
     def test_get_image_xml_no_name(self):
+<<<<<<< TREE
         request = webob.Request.blank('/v1.0/images/131')
+=======
+        request = webob.Request.blank('/v1.0/images/130')
+>>>>>>> MERGE-SOURCE
         request.accept = "application/xml"
-        response = request.get_response(fakes.wsgi_app())
+        app = fakes.wsgi_app(fake_auth_context=self._get_fake_context())
+        response = request.get_response(app)
 
         actual_image = minidom.parseString(response.body.replace("  ", ""))
 
-        expected_now = self.NOW_API_FORMAT
+        expected_now = NOW_API_FORMAT
         expected_image = minidom.parseString("""
+<<<<<<< TREE
             <image id="131"
+=======
+            <image id="130"
+>>>>>>> MERGE-SOURCE
                     name="None"
                     updated="%(expected_now)s"
                     created="%(expected_now)s"
@@ -503,12 +244,10 @@
 
         expected = minidom.parseString("""
             <itemNotFound code="404"
-                    xmlns="http://docs.rackspacecloud.com/servers/api/v1.0">
-                <message>
-                    Image not found.
-                </message>
+                 xmlns="http://docs.rackspacecloud.com/servers/api/v1.0">
+                <message>Image not found.</message>
             </itemNotFound>
-        """.replace("  ", ""))
+        """.replace("  ", "").replace("\n", ""))
 
         actual = minidom.parseString(response.body.replace("  ", ""))
 
@@ -540,12 +279,10 @@
         # because the element hasn't changed definition
         expected = minidom.parseString("""
             <itemNotFound code="404"
-                    xmlns="http://docs.openstack.org/compute/api/v1.1">
-                <message>
-                    Image not found.
-                </message>
+                 xmlns="http://docs.openstack.org/compute/api/v1.1">
+                <message>Image not found.</message>
             </itemNotFound>
-        """.replace("  ", ""))
+        """.replace("  ", "").replace("\n", ""))
 
         actual = minidom.parseString(response.body.replace("  ", ""))
 
@@ -553,41 +290,133 @@
 
     def test_get_image_index_v1_1(self):
         request = webob.Request.blank('/v1.1/fake/images')
-        response = request.get_response(fakes.wsgi_app())
+        app = fakes.wsgi_app(fake_auth_context=self._get_fake_context())
+        response = request.get_response(app)
 
         response_dict = json.loads(response.body)
         response_list = response_dict["images"]
 
-        fixtures = copy.copy(self.fixtures)
-
-        for image in fixtures:
-            if not self._applicable_fixture(image, "fake"):
-                fixtures.remove(image)
-                continue
-
-            href = "http://localhost/v1.1/fake/images/%s" % image["id"]
-            bookmark = "http://localhost/fake/images/%s" % image["id"]
-            test_image = {
-                "id": image["id"],
-                "name": image["name"],
-                "links": [
-                    {
-                        "rel": "self",
-                        "href": href,
-                    },
-                    {
-                        "rel": "bookmark",
-                        "href": bookmark,
-                    },
-                ],
-            }
-            self.assertTrue(test_image in response_list)
-
-        self.assertEqual(len(response_list), len(fixtures))
+        expected = [
+            {
+                "id": "123",
+                "name": "public image",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/fake/images/123",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/fake/images/123",
+                    },
+                ],
+            },
+            {
+                "id": "124",
+                "name": "queued snapshot",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/fake/images/124",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/fake/images/124",
+                    },
+                ],
+            },
+            {
+                "id": "125",
+                "name": "saving snapshot",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/fake/images/125",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/fake/images/125",
+                    },
+                ],
+            },
+            {
+                "id": "126",
+                "name": "active snapshot",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/fake/images/126",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/fake/images/126",
+                    },
+                ],
+            },
+            {
+                "id": "127",
+                "name": "killed snapshot",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/fake/images/127",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/fake/images/127",
+                    },
+                ],
+            },
+            {
+                "id": "128",
+                "name": "deleted snapshot",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/fake/images/128",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/fake/images/128",
+                    },
+                ],
+            },
+            {
+                "id": "129",
+                "name": "pending_delete snapshot",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/fake/images/129",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/fake/images/129",
+                    },
+                ],
+            },
+            {
+                "id": "130",
+                "name": None,
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/fake/images/130",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/fake/images/130",
+                    },
+                ],
+            },
+        ]
+
+        self.assertDictListMatch(response_list, expected)
 
     def test_get_image_details(self):
         request = webob.Request.blank('/v1.0/images/detail')
-        response = request.get_response(fakes.wsgi_app())
+        app = fakes.wsgi_app(fake_auth_context=self._get_fake_context())
+        response = request.get_response(app)
 
         response_dict = json.loads(response.body)
         response_list = response_dict["images"]
@@ -595,53 +424,74 @@
         expected = [{
             'id': 123,
             'name': 'public image',
-            'updated': self.NOW_API_FORMAT,
-            'created': self.NOW_API_FORMAT,
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
             'status': 'ACTIVE',
             'progress': 100,
         },
         {
             'id': 124,
             'name': 'queued snapshot',
+<<<<<<< TREE
             'updated': self.NOW_API_FORMAT,
             'created': self.NOW_API_FORMAT,
             'status': 'SAVING',
+=======
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
+            'status': 'SAVING',
+>>>>>>> MERGE-SOURCE
             'progress': 0,
         },
         {
             'id': 125,
             'name': 'saving snapshot',
-            'updated': self.NOW_API_FORMAT,
-            'created': self.NOW_API_FORMAT,
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
             'status': 'SAVING',
             'progress': 0,
         },
         {
             'id': 126,
             'name': 'active snapshot',
-            'updated': self.NOW_API_FORMAT,
-            'created': self.NOW_API_FORMAT,
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
             'status': 'ACTIVE',
             'progress': 100,
         },
         {
             'id': 127,
             'name': 'killed snapshot',
-            'updated': self.NOW_API_FORMAT,
-            'created': self.NOW_API_FORMAT,
-            'status': 'ERROR',
-            'progress': 0,
-        },
-        {
-            'id': 128,
-            'name': 'deleted snapshot',
-            'updated': self.NOW_API_FORMAT,
-            'created': self.NOW_API_FORMAT,
-            'status': 'DELETED',
+<<<<<<< TREE
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'ERROR',
+            'progress': 0,
+        },
+        {
+            'id': 128,
+            'name': 'deleted snapshot',
+            'updated': self.NOW_API_FORMAT,
+            'created': self.NOW_API_FORMAT,
+            'status': 'DELETED',
+=======
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
+            'status': 'ERROR',
+            'progress': 0,
+        },
+        {
+            'id': 128,
+            'name': 'deleted snapshot',
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
+            'status': 'DELETED',
+>>>>>>> MERGE-SOURCE
             'progress': 0,
         },
         {
             'id': 129,
+<<<<<<< TREE
             'name': 'pending_delete snapshot',
             'updated': self.NOW_API_FORMAT,
             'created': self.NOW_API_FORMAT,
@@ -650,9 +500,19 @@
         },
         {
             'id': 131,
+=======
+            'name': 'pending_delete snapshot',
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
+            'status': 'DELETED',
+            'progress': 0,
+        },
+        {
+            'id': 130,
+>>>>>>> MERGE-SOURCE
             'name': None,
-            'updated': self.NOW_API_FORMAT,
-            'created': self.NOW_API_FORMAT,
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
             'status': 'ACTIVE',
             'progress': 100,
         }]
@@ -661,7 +521,8 @@
 
     def test_get_image_details_v1_1(self):
         request = webob.Request.blank('/v1.1/fake/images/detail')
-        response = request.get_response(fakes.wsgi_app())
+        app = fakes.wsgi_app(fake_auth_context=self._get_fake_context())
+        response = request.get_response(app)
 
         response_dict = json.loads(response.body)
         response_list = response_dict["images"]
@@ -669,11 +530,11 @@
         server_bookmark = "http://localhost/servers/42"
 
         expected = [{
-            'id': 123,
+            'id': '123',
             'name': 'public image',
-            'metadata': {},
-            'updated': self.NOW_API_FORMAT,
-            'created': self.NOW_API_FORMAT,
+            'metadata': {'key1': 'value1'},
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
             'status': 'ACTIVE',
             'progress': 100,
             "links": [{
@@ -686,18 +547,24 @@
             }],
         },
         {
-            'id': 124,
+            'id': '124',
             'name': 'queued snapshot',
             'metadata': {
                 u'instance_ref': u'http://localhost/v1.1/servers/42',
                 u'user_id': u'fake',
             },
+<<<<<<< TREE
             'updated': self.NOW_API_FORMAT,
             'created': self.NOW_API_FORMAT,
             'status': 'SAVING',
+=======
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
+            'status': 'SAVING',
+>>>>>>> MERGE-SOURCE
             'progress': 0,
             'server': {
-                'id': 42,
+                'id': '42',
                 "links": [{
                     "rel": "self",
                     "href": server_href,
@@ -717,18 +584,18 @@
             }],
         },
         {
-            'id': 125,
+            'id': '125',
             'name': 'saving snapshot',
             'metadata': {
                 u'instance_ref': u'http://localhost/v1.1/servers/42',
                 u'user_id': u'fake',
             },
-            'updated': self.NOW_API_FORMAT,
-            'created': self.NOW_API_FORMAT,
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
             'status': 'SAVING',
             'progress': 0,
             'server': {
-                'id': 42,
+                'id': '42',
                 "links": [{
                     "rel": "self",
                     "href": server_href,
@@ -748,18 +615,18 @@
             }],
         },
         {
-            'id': 126,
+            'id': '126',
             'name': 'active snapshot',
             'metadata': {
                 u'instance_ref': u'http://localhost/v1.1/servers/42',
                 u'user_id': u'fake',
             },
-            'updated': self.NOW_API_FORMAT,
-            'created': self.NOW_API_FORMAT,
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
             'status': 'ACTIVE',
             'progress': 100,
             'server': {
-                'id': 42,
+                'id': '42',
                 "links": [{
                     "rel": "self",
                     "href": server_href,
@@ -779,18 +646,24 @@
             }],
         },
         {
-            'id': 127,
+            'id': '127',
             'name': 'killed snapshot',
             'metadata': {
                 u'instance_ref': u'http://localhost/v1.1/servers/42',
                 u'user_id': u'fake',
             },
+<<<<<<< TREE
             'updated': self.NOW_API_FORMAT,
             'created': self.NOW_API_FORMAT,
             'status': 'ERROR',
+=======
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
+            'status': 'ERROR',
+>>>>>>> MERGE-SOURCE
             'progress': 0,
             'server': {
-                'id': 42,
+                'id': '42',
                 "links": [{
                     "rel": "self",
                     "href": server_href,
@@ -810,6 +683,7 @@
             }],
         },
         {
+<<<<<<< TREE
             'id': 128,
             'name': 'deleted snapshot',
             'metadata': {
@@ -862,6 +736,60 @@
                     "href": server_bookmark,
                 }],
             },
+=======
+            'id': '128',
+            'name': 'deleted snapshot',
+            'metadata': {
+                u'instance_ref': u'http://localhost/v1.1/servers/42',
+                u'user_id': u'fake',
+            },
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
+            'status': 'DELETED',
+            'progress': 0,
+            'server': {
+                'id': '42',
+                "links": [{
+                    "rel": "self",
+                    "href": server_href,
+                },
+                {
+                    "rel": "bookmark",
+                    "href": server_bookmark,
+                }],
+            },
+            "links": [{
+                "rel": "self",
+                "href": "http://localhost/v1.1/fake/images/128",
+            },
+            {
+                "rel": "bookmark",
+                "href": "http://localhost/fake/images/128",
+            }],
+        },
+        {
+            'id': '129',
+            'name': 'pending_delete snapshot',
+            'metadata': {
+                u'instance_ref': u'http://localhost/v1.1/servers/42',
+                u'user_id': u'fake',
+            },
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
+            'status': 'DELETED',
+            'progress': 0,
+            'server': {
+                'id': '42',
+                "links": [{
+                    "rel": "self",
+                    "href": server_href,
+                },
+                {
+                    "rel": "bookmark",
+                    "href": server_bookmark,
+                }],
+            },
+>>>>>>> MERGE-SOURCE
             "links": [{
                 "rel": "self",
                 "href": "http://localhost/v1.1/fake/images/129",
@@ -871,6 +799,7 @@
                 "href": "http://localhost/fake/images/129",
             }],
         },
+<<<<<<< TREE
         {
             'id': 131,
             'name': None,
@@ -888,6 +817,25 @@
                 "href": "http://localhost/fake/images/131",
             }],
         },
+=======
+        {
+            'id': '130',
+            'name': None,
+            'metadata': {},
+            'updated': NOW_API_FORMAT,
+            'created': NOW_API_FORMAT,
+            'status': 'ACTIVE',
+            'progress': 100,
+            "links": [{
+                "rel": "self",
+                "href": "http://localhost/v1.1/fake/images/130",
+            },
+            {
+                "rel": "bookmark",
+                "href": "http://localhost/fake/images/130",
+            }],
+        },
+>>>>>>> MERGE-SOURCE
         ]
 
         self.assertDictListMatch(expected, response_list)
@@ -1097,11 +1045,12 @@
 
     def test_get_image_found(self):
         req = webob.Request.blank('/v1.0/images/123')
-        res = req.get_response(fakes.wsgi_app())
+        app = fakes.wsgi_app(fake_auth_context=self._get_fake_context())
+        res = req.get_response(app)
         image_meta = json.loads(res.body)['image']
         expected = {'id': 123, 'name': 'public image',
-                    'updated': self.NOW_API_FORMAT,
-                    'created': self.NOW_API_FORMAT, 'status': 'ACTIVE',
+                    'updated': NOW_API_FORMAT,
+                    'created': NOW_API_FORMAT, 'status': 'ACTIVE',
                     'progress': 100}
         self.assertDictMatch(image_meta, expected)
 
@@ -1110,6 +1059,7 @@
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 404)
 
+<<<<<<< TREE
     def test_get_image_not_owned(self):
         """We should return a 404 if we request an image that doesn't belong
         to us
@@ -1118,6 +1068,8 @@
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 404)
 
+=======
+>>>>>>> MERGE-SOURCE
     def test_create_image(self):
         body = dict(image=dict(serverId='123', name='Snapshot 1'))
         req = webob.Request.blank('/v1.0/images')
@@ -1160,6 +1112,7 @@
         response = req.get_response(fakes.wsgi_app())
         self.assertEqual(400, response.status_int)
 
+<<<<<<< TREE
     @classmethod
     def _make_image_fixtures(cls):
         image_id = 123
@@ -1205,6 +1158,8 @@
 
         return fixtures
 
+=======
+>>>>>>> MERGE-SOURCE
 
 class ImageXMLSerializationTest(test.TestCase):
 
@@ -1214,6 +1169,51 @@
     IMAGE_HREF = 'http://localhost/v1.1/fake/images/%s'
     IMAGE_BOOKMARK = 'http://localhost/fake/images/%s'
 
+    def test_xml_declaration(self):
+        serializer = images.ImageXMLSerializer()
+
+        fixture = {
+            'image': {
+                'id': 1,
+                'name': 'Image1',
+                'created': self.TIMESTAMP,
+                'updated': self.TIMESTAMP,
+                'status': 'ACTIVE',
+                'progress': 80,
+                'server': {
+                    'id': '1',
+                    'links': [
+                        {
+                            'href': self.SERVER_HREF,
+                            'rel': 'self',
+                        },
+                        {
+                            'href': self.SERVER_BOOKMARK,
+                            'rel': 'bookmark',
+                        },
+                    ],
+                },
+                'metadata': {
+                    'key1': 'value1',
+                },
+                'links': [
+                    {
+                        'href': self.IMAGE_HREF % 1,
+                        'rel': 'self',
+                    },
+                    {
+                        'href': self.IMAGE_BOOKMARK % 1,
+                        'rel': 'bookmark',
+                    },
+                ],
+            },
+        }
+
+        output = serializer.serialize(fixture, 'show')
+        print output
+        has_dec = output.startswith("<?xml version='1.0' encoding='UTF-8'?>")
+        self.assertTrue(has_dec)
+
     def test_show(self):
         serializer = images.ImageXMLSerializer()
 
@@ -1226,7 +1226,7 @@
                 'status': 'ACTIVE',
                 'progress': 80,
                 'server': {
-                    'id': 1,
+                    'id': '1',
                     'links': [
                         {
                             'href': self.SERVER_HREF,
@@ -1255,37 +1255,35 @@
         }
 
         output = serializer.serialize(fixture, 'show')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected_server_href = self.SERVER_HREF
-        expected_server_bookmark = self.SERVER_BOOKMARK
-        expected_href = self.IMAGE_HREF % 1
-        expected_bookmark = self.IMAGE_BOOKMARK % 1
-        expected_now = self.TIMESTAMP
-        expected = minidom.parseString("""
-        <image id="1"
-                xmlns="http://docs.openstack.org/compute/api/v1.1"
-                xmlns:atom="http://www.w3.org/2005/Atom"
-                name="Image1"
-                updated="%(expected_now)s"
-                created="%(expected_now)s"
-                status="ACTIVE"
-                progress="80">
-            <server id="1">
-                <atom:link rel="self" href="%(expected_server_href)s"/>
-                <atom:link rel="bookmark" href="%(expected_server_bookmark)s"/>
-            </server>
-            <metadata>
-                <meta key="key1">
-                    value1
-                </meta>
-            </metadata>
-            <atom:link href="%(expected_href)s" rel="self"/>
-            <atom:link href="%(expected_bookmark)s" rel="bookmark"/>
-        </image>
-        """.replace("  ", "") % (locals()))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'image')
+        image_dict = fixture['image']
+
+        for key in ['name', 'id', 'updated', 'created', 'status', 'progress']:
+            self.assertEqual(root.get(key), str(image_dict[key]))
+
+        link_nodes = root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(image_dict['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        metadata_root = root.find('{0}metadata'.format(NS))
+        metadata_elems = metadata_root.findall('{0}meta'.format(NS))
+        self.assertEqual(len(metadata_elems), 1)
+        for i, metadata_elem in enumerate(metadata_elems):
+            (meta_key, meta_value) = image_dict['metadata'].items()[i]
+            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
+            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
+
+        server_root = root.find('{0}server'.format(NS))
+        self.assertEqual(server_root.get('id'), image_dict['server']['id'])
+        link_nodes = server_root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(image_dict['server']['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
 
     def test_show_zero_metadata(self):
         serializer = images.ImageXMLSerializer()
@@ -1298,7 +1296,7 @@
                 'updated': self.TIMESTAMP,
                 'status': 'ACTIVE',
                 'server': {
-                    'id': 1,
+                    'id': '1',
                     'links': [
                         {
                             'href': self.SERVER_HREF,
@@ -1325,31 +1323,31 @@
         }
 
         output = serializer.serialize(fixture, 'show')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected_server_href = self.SERVER_HREF
-        expected_server_bookmark = self.SERVER_BOOKMARK
-        expected_href = self.IMAGE_HREF % 1
-        expected_bookmark = self.IMAGE_BOOKMARK % 1
-        expected_now = self.TIMESTAMP
-        expected = minidom.parseString("""
-        <image id="1"
-                xmlns="http://docs.openstack.org/compute/api/v1.1"
-                xmlns:atom="http://www.w3.org/2005/Atom"
-                name="Image1"
-                updated="%(expected_now)s"
-                created="%(expected_now)s"
-                status="ACTIVE">
-            <server id="1">
-                <atom:link rel="self" href="%(expected_server_href)s"/>
-                <atom:link rel="bookmark" href="%(expected_server_bookmark)s"/>
-            </server>
-            <atom:link href="%(expected_href)s" rel="self"/>
-            <atom:link href="%(expected_bookmark)s" rel="bookmark"/>
-        </image>
-        """.replace("  ", "") % (locals()))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'image')
+        image_dict = fixture['image']
+
+        for key in ['name', 'id', 'updated', 'created', 'status']:
+            self.assertEqual(root.get(key), str(image_dict[key]))
+
+        link_nodes = root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(image_dict['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        metadata_root = root.find('{0}metadata'.format(NS))
+        meta_nodes = root.findall('{0}meta'.format(ATOMNS))
+        self.assertEqual(len(meta_nodes), 0)
+
+        server_root = root.find('{0}server'.format(NS))
+        self.assertEqual(server_root.get('id'), image_dict['server']['id'])
+        link_nodes = server_root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(image_dict['server']['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
 
     def test_show_image_no_metadata_key(self):
         serializer = images.ImageXMLSerializer()
@@ -1362,7 +1360,7 @@
                 'updated': self.TIMESTAMP,
                 'status': 'ACTIVE',
                 'server': {
-                    'id': 1,
+                    'id': '1',
                     'links': [
                         {
                             'href': self.SERVER_HREF,
@@ -1388,31 +1386,31 @@
         }
 
         output = serializer.serialize(fixture, 'show')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected_server_href = self.SERVER_HREF
-        expected_server_bookmark = self.SERVER_BOOKMARK
-        expected_href = self.IMAGE_HREF % 1
-        expected_bookmark = self.IMAGE_BOOKMARK % 1
-        expected_now = self.TIMESTAMP
-        expected = minidom.parseString("""
-        <image id="1"
-                xmlns="http://docs.openstack.org/compute/api/v1.1"
-                xmlns:atom="http://www.w3.org/2005/Atom"
-                name="Image1"
-                updated="%(expected_now)s"
-                created="%(expected_now)s"
-                status="ACTIVE">
-            <server id="1">
-                <atom:link rel="self" href="%(expected_server_href)s"/>
-                <atom:link rel="bookmark" href="%(expected_server_bookmark)s"/>
-            </server>
-            <atom:link href="%(expected_href)s" rel="self"/>
-            <atom:link href="%(expected_bookmark)s" rel="bookmark"/>
-        </image>
-        """.replace("  ", "") % (locals()))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'image')
+        image_dict = fixture['image']
+
+        for key in ['name', 'id', 'updated', 'created', 'status']:
+            self.assertEqual(root.get(key), str(image_dict[key]))
+
+        link_nodes = root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(image_dict['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        metadata_root = root.find('{0}metadata'.format(NS))
+        meta_nodes = root.findall('{0}meta'.format(ATOMNS))
+        self.assertEqual(len(meta_nodes), 0)
+
+        server_root = root.find('{0}server'.format(NS))
+        self.assertEqual(server_root.get('id'), image_dict['server']['id'])
+        link_nodes = server_root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(image_dict['server']['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
 
     def test_show_no_server(self):
         serializer = images.ImageXMLSerializer()
@@ -1441,30 +1439,30 @@
         }
 
         output = serializer.serialize(fixture, 'show')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected_href = self.IMAGE_HREF % 1
-        expected_bookmark = self.IMAGE_BOOKMARK % 1
-        expected_now = self.TIMESTAMP
-        expected = minidom.parseString("""
-        <image id="1"
-                xmlns="http://docs.openstack.org/compute/api/v1.1"
-                xmlns:atom="http://www.w3.org/2005/Atom"
-                name="Image1"
-                updated="%(expected_now)s"
-                created="%(expected_now)s"
-                status="ACTIVE">
-            <metadata>
-                <meta key="key1">
-                    value1
-                </meta>
-            </metadata>
-            <atom:link href="%(expected_href)s" rel="self"/>
-            <atom:link href="%(expected_bookmark)s" rel="bookmark"/>
-        </image>
-        """.replace("  ", "") % (locals()))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'image')
+        image_dict = fixture['image']
+
+        for key in ['name', 'id', 'updated', 'created', 'status']:
+            self.assertEqual(root.get(key), str(image_dict[key]))
+
+        link_nodes = root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(image_dict['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        metadata_root = root.find('{0}metadata'.format(NS))
+        metadata_elems = metadata_root.findall('{0}meta'.format(NS))
+        self.assertEqual(len(metadata_elems), 1)
+        for i, metadata_elem in enumerate(metadata_elems):
+            (meta_key, meta_value) = image_dict['metadata'].items()[i]
+            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
+            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
+
+        server_root = root.find('{0}server'.format(NS))
+        self.assertEqual(server_root, None)
 
     def test_index(self):
         serializer = images.ImageXMLSerializer()
@@ -1479,6 +1477,10 @@
                             'href': self.IMAGE_HREF % 1,
                             'rel': 'self',
                         },
+                        {
+                            'href': self.IMAGE_BOOKMARK % 1,
+                            'rel': 'bookmark',
+                        },
                     ],
                 },
                 {
@@ -1489,35 +1491,32 @@
                             'href': self.IMAGE_HREF % 2,
                             'rel': 'self',
                         },
+                        {
+                            'href': self.IMAGE_BOOKMARK % 2,