Merged trunk and fixed conflicts to make tests pass.

33 files changed, 1346 insertions, 314 deletions

diff --git a/bin/nova-manage b/bin/nova-manage
index 75d74903c..807753a2e 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -662,8 +662,9 @@ class NetworkCommands(object):
         # check for certain required inputs
         if not label:
             raise exception.NetworkNotCreated(req='--label')
-        if not fixed_range_v4:
-            raise exception.NetworkNotCreated(req='--fixed_range_v4')
+        if not (fixed_range_v4 or fixed_range_v6):
+            req = '--fixed_range_v4 or --fixed_range_v6'
+            raise exception.NetworkNotCreated(req=req)
 
         bridge = bridge or FLAGS.flat_network_bridge
         if not bridge:
@@ -689,16 +690,6 @@ class NetworkCommands(object):
             if FLAGS.network_manager in interface_required:
                 raise exception.NetworkNotCreated(req='--bridge_interface')
 
-        if FLAGS.use_ipv6:
-            fixed_range_v6 = fixed_range_v6 or FLAGS.fixed_range_v6
-            if not fixed_range_v6:
-                raise exception.NetworkNotCreated(req='with use_ipv6, '
-                                                      '--fixed_range_v6')
-            gateway_v6 = gateway_v6 or FLAGS.gateway_v6
-            if not gateway_v6:
-                raise exception.NetworkNotCreated(req='with use_ipv6, '
-                                                      '--gateway_v6')
-
         # sanitize other input using FLAGS if necessary
         if not num_networks:
             num_networks = FLAGS.num_networks
@@ -735,8 +726,8 @@ class NetworkCommands(object):
     def list(self):
         """List all created networks"""
         print "%-18s\t%-15s\t%-15s\t%-15s\t%-15s\t%-15s\t%-15s" % (
-                                                  _('network'),
-                                                  _('netmask'),
+                                                  _('IPv4'),
+                                                  _('IPv6'),
                                                   _('start address'),
                                                   _('DNS1'),
                                                   _('DNS2'),
@@ -745,7 +736,7 @@ class NetworkCommands(object):
         for network in db.network_get_all(context.get_admin_context()):
             print "%-18s\t%-15s\t%-15s\t%-15s\t%-15s\t%-15s\t%-15s" % (
                                         network.cidr,
-                                        network.netmask,
+                                        network.cidr_v6,
                                         network.dhcp_start,
                                         network.dns1,
                                         network.dns2,
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 868b98a31..9ab8aeb58 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -40,6 +40,7 @@ from nova.api.openstack import servers
 from nova.api.openstack import server_metadata
 from nova.api.openstack import shared_ip_groups
 from nova.api.openstack import users
+from nova.api.openstack import versions
 from nova.api.openstack import wsgi
 from nova.api.openstack import zones
 
@@ -96,6 +97,7 @@ class APIRouter(base_wsgi.Router):
             server_members['suspend'] = 'POST'
             server_members['resume'] = 'POST'
             server_members['rescue'] = 'POST'
+            server_members['migrate'] = 'POST'
             server_members['unrescue'] = 'POST'
             server_members['reset_network'] = 'POST'
             server_members['inject_network_info'] = 'POST'
@@ -115,6 +117,10 @@ class APIRouter(base_wsgi.Router):
                                     'select': 'POST',
                                     'boot': 'POST'})
 
+        mapper.connect("versions", "/",
+                    controller=versions.create_resource(version),
+                    action='show')
+
         mapper.resource("console", "consoles",
                     controller=consoles.create_resource(),
                     parent_resource=dict(member_name='server',
diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 53e814cd5..a2d18d37e 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -90,6 +90,11 @@ class CreateInstanceHelper(object):
             key_data = key_pair['public_key']
 
         image_href = self.controller._image_ref_from_req_data(body)
+        # If the image href was generated by nova api, strip image_href
+        # down to an id and use the default glance connection params
+        
+        if str(image_href).startswith(req.application_url):
+            image_href = image_href.split('/').pop()
         try:
             image_service, image_id = nova.image.get_image_service(image_href)
             kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image(
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 7b757143d..002b47edb 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -164,7 +164,6 @@ class Controller(object):
             'confirmResize': self._action_confirm_resize,
             'revertResize': self._action_revert_resize,
             'rebuild': self._action_rebuild,
-            'migrate': self._action_migrate,
             'createImage': self._action_create_image,
         }
 
@@ -281,14 +280,6 @@ class Controller(object):
             raise exc.HTTPUnprocessableEntity()
         return webob.Response(status_int=202)
 
-    def _action_migrate(self, input_dict, req, id):
-        try:
-            self.compute_api.resize(req.environ['nova.context'], id)
-        except Exception, e:
-            LOG.exception(_("Error in migrate %s"), e)
-            raise exc.HTTPBadRequest()
-        return webob.Response(status_int=202)
-
     @scheduler_api.redirect_handler
     def lock(self, req, id):
         """
@@ -415,6 +406,15 @@ class Controller(object):
         return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
+    def migrate(self, req, id):
+        try:
+            self.compute_api.resize(req.environ['nova.context'], id)
+        except Exception, e:
+            LOG.exception(_("Error in migrate %s"), e)
+            raise exc.HTTPBadRequest()
+        return webob.Response(status_int=202)
+
+    @scheduler_api.redirect_handler
     def rescue(self, req, id):
         """Permit users to rescue the server."""
         context = req.environ["nova.context"]
diff --git a/nova/api/openstack/versions.py b/nova/api/openstack/versions.py
index df7a94b7e..3ef72b7f6 100644
--- a/nova/api/openstack/versions.py
+++ b/nova/api/openstack/versions.py
@@ -24,7 +24,66 @@ import nova.api.openstack.views.versions
 from nova.api.openstack import wsgi
 
 
-ATOM_XMLNS = "http://www.w3.org/2005/Atom"
+VERSIONS = {
+    "v1.0": {
+        "id": "v1.0",
+        "status": "DEPRECATED",
+        "updated": "2011-01-21T11:33:21Z",
+        "links": [
+            {
+                "rel": "describedby",
+                "type": "application/pdf",
+                "href": "http://docs.rackspacecloud.com/"
+                        "servers/api/v1.0/cs-devguide-20110125.pdf"
+            },
+            {
+                "rel": "describedby",
+                "type": "application/vnd.sun.wadl+xml",
+                "href": "http://docs.rackspacecloud.com/"
+                        "servers/api/v1.0/application.wadl"
+            },
+        ],
+        "media-types": [
+            {
+                "base": "application/xml",
+                "type": "application/vnd.openstack.compute-v1.0+xml"
+            },
+            {
+                "base": "application/json",
+                "type": "application/vnd.openstack.compute-v1.0+json"
+            }
+        ],
+    },
+    "v1.1": {
+        "id": "v1.1",
+        "status": "CURRENT",
+        "updated": "2011-01-21T11:33:21Z",
+        "links": [
+            {
+                "rel": "describedby",
+                "type": "application/pdf",
+                "href": "http://docs.rackspacecloud.com/"
+                        "servers/api/v1.1/cs-devguide-20110125.pdf"
+            },
+            {
+                "rel": "describedby",
+                "type": "application/vnd.sun.wadl+xml",
+                "href": "http://docs.rackspacecloud.com/"
+                        "servers/api/v1.1/application.wadl"
+            },
+        ],
+        "media-types": [
+            {
+                "base": "application/xml",
+                "type": "application/vnd.openstack.compute-v1.1+xml"
+            },
+            {
+                "base": "application/json",
+                "type": "application/vnd.openstack.compute-v1.1+json"
+            }
+        ],
+    },
+}
 
 
 class Versions(wsgi.Resource):
@@ -36,16 +95,20 @@ class Versions(wsgi.Resource):
             }
         }
 
+        headers_serializer = VersionsHeadersSerializer()
+
         body_serializers = {
             'application/atom+xml': VersionsAtomSerializer(metadata=metadata),
             'application/xml': VersionsXMLSerializer(metadata=metadata),
         }
-        serializer = wsgi.ResponseSerializer(body_serializers)
+        serializer = wsgi.ResponseSerializer(
+            body_serializers=body_serializers,
+            headers_serializer=headers_serializer)
 
         supported_content_types = ('application/json',
                                    'application/xml',
                                    'application/atom+xml')
-        deserializer = wsgi.RequestDeserializer(
+        deserializer = VersionsRequestDeserializer(
             supported_content_types=supported_content_types)
 
         wsgi.Resource.__init__(self, None, serializer=serializer,
@@ -53,60 +116,131 @@ class Versions(wsgi.Resource):
 
     def dispatch(self, request, *args):
         """Respond to a request for all OpenStack API versions."""
-        version_objs = [
-            {
-                "id": "v1.1",
-                "status": "CURRENT",
-                #TODO(wwolf) get correct value for these
-                "updated": "2011-07-18T11:30:00Z",
-            },
-            {
-                "id": "v1.0",
-                "status": "DEPRECATED",
-                #TODO(wwolf) get correct value for these
-                "updated": "2010-10-09T11:30:00Z",
-            },
-        ]
-
         builder = nova.api.openstack.views.versions.get_view_builder(request)
-        versions = [builder.build(version) for version in version_objs]
-        return dict(versions=versions)
+        if request.path == '/':
+            # List Versions
+            return builder.build_versions(VERSIONS)
+        else:
+            # Versions Multiple Choice
+            return builder.build_choices(VERSIONS, request)
+
+
+class VersionV10(object):
+    def show(self, req):
+        builder = nova.api.openstack.views.versions.get_view_builder(req)
+        return builder.build_version(VERSIONS['v1.0'])
+
+
+class VersionV11(object):
+    def show(self, req):
+        builder = nova.api.openstack.views.versions.get_view_builder(req)
+        return builder.build_version(VERSIONS['v1.1'])
+
+
+class VersionsRequestDeserializer(wsgi.RequestDeserializer):
+    def get_expected_content_type(self, request):
+        supported_content_types = list(self.supported_content_types)
+        if request.path != '/':
+            # Remove atom+xml accept type for 300 responses
+            if 'application/atom+xml' in supported_content_types:
+                supported_content_types.remove('application/atom+xml')
+
+        return request.best_match_content_type(supported_content_types)
+
+    def get_action_args(self, request_environment):
+        """Parse dictionary created by routes library."""
+        args = {}
+        if request_environment['PATH_INFO'] == '/':
+            args['action'] = 'index'
+        else:
+            args['action'] = 'multi'
+
+        return args
 
 
 class VersionsXMLSerializer(wsgi.XMLDictSerializer):
-    def _versions_to_xml(self, versions):
-        root = self._xml_doc.createElement('versions')
+    #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_version_node(self, version):
+    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'])
-        version_node.setAttribute('updated', version['updated'])
+        if 'updated' in version:
+            version_node.setAttribute('updated', version['updated'])
+
+        if 'media-types' in version:
+            media_types = self._create_media_types(version['media-types'])
+            version_node.appendChild(media_types)
 
-        for link in version['links']:
-            link_node = self._xml_doc.createElement('atom:link')
-            link_node.setAttribute('rel', link['rel'])
-            link_node.setAttribute('href', link['href'])
-            version_node.appendChild(link_node)
+        link_nodes = self._create_link_nodes(self._xml_doc, version['links'])
+        for link in link_nodes:
+            version_node.appendChild(link)
 
         return version_node
 
-    def default(self, data):
+    def index(self, data):
         self._xml_doc = minidom.Document()
         node = self._versions_to_xml(data['versions'])
 
         return self.to_xml_string(node)
 
+    def show(self, data):
+        self._xml_doc = minidom.Document()
+        node = self._create_version_node(data['version'], True)
+
+        return self.to_xml_string(node)
+
+    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)
+
 
 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')
+
     def __init__(self, metadata=None, xmlns=None):
+        self.metadata = metadata or {}
         if not xmlns:
-            self.xmlns = ATOM_XMLNS
+            self.xmlns = wsgi.XMLNS_ATOM
         else:
             self.xmlns = xmlns
 
@@ -135,8 +269,33 @@ class VersionsAtomSerializer(wsgi.XMLDictSerializer):
         link_href = link_href.rstrip('/')
         return link_href.rsplit('/', 1)[0] + '/'
 
-    def _create_meta(self, root, versions):
-        title = self._create_text_elem('title', 'Available API Versions',
+    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')
         # Set this updated to the most recently updated version
         recent = self._get_most_recent_update(versions)
@@ -144,6 +303,7 @@ class VersionsAtomSerializer(wsgi.XMLDictSerializer):
 
         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)
@@ -178,7 +338,10 @@ class VersionsAtomSerializer(wsgi.XMLDictSerializer):
                 link_node = self._xml_doc.createElement('link')
                 link_node.setAttribute('rel', link['rel'])
                 link_node.setAttribute('href', link['href'])
-            entry.appendChild(link_node)
+                if 'type' in link:
+                    link_node.setAttribute('type', link['type'])
+
+                entry.appendChild(link_node)
 
             content = self._create_text_elem('content',
                 'Version %s %s (%s)' %
@@ -190,10 +353,45 @@ class VersionsAtomSerializer(wsgi.XMLDictSerializer):
             entry.appendChild(content)
             root.appendChild(entry)
 
-    def default(self, data):
+    def index(self, data):
         self._xml_doc = minidom.Document()
         node = self._xml_doc.createElementNS(self.xmlns, 'feed')
-        self._create_meta(node, data['versions'])
+        self._create_list_meta(node, data['versions'])
         self._create_version_entries(node, data['versions'])
 
         return self.to_xml_string(node)
+
+    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)
+
+
+class VersionsHeadersSerializer(wsgi.ResponseHeadersSerializer):
+    def multi(self, response, data):
+        response.status_int = 300
+
+
+def create_resource(version='1.0'):
+    controller = {
+        '1.0': VersionV10,
+        '1.1': VersionV11,
+    }[version]()
+
+    body_serializers = {
+        'application/xml': VersionsXMLSerializer(),
+        'application/atom+xml': VersionsAtomSerializer(),
+    }
+    serializer = wsgi.ResponseSerializer(body_serializers)
+
+    supported_content_types = ('application/json',
+                               'application/xml',
+                               'application/atom+xml')
+    deserializer = wsgi.RequestDeserializer(
+        supported_content_types=supported_content_types)
+
+    return wsgi.Resource(controller, serializer=serializer,
+                         deserializer=deserializer)
diff --git a/nova/api/openstack/views/versions.py b/nova/api/openstack/views/versions.py
index 9fa8f49dc..547289034 100644
--- a/nova/api/openstack/views/versions.py
+++ b/nova/api/openstack/views/versions.py
@@ -15,6 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import copy
 import os
 
 
@@ -31,16 +32,44 @@ class ViewBuilder(object):
         """
         self.base_url = base_url
 
-    def build(self, version_data):
-        """Generic method used to generate a version entity."""
-        version = {
-            "id": version_data["id"],
-            "status": version_data["status"],
-            "updated": version_data["updated"],
-            "links": self._build_links(version_data),
-        }
+    def build_choices(self, VERSIONS, req):
+        version_objs = []
+        for version in VERSIONS:
+            version = VERSIONS[version]
+            version_objs.append({
+                "id": version['id'],
+                "status": version['status'],
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": self.generate_href(version['id'], req.path)
+                    }
+                ],
+                "media-types": version['media-types']
+            })
 
-        return version
+        return dict(choices=version_objs)
+
+    def build_versions(self, versions):
+        version_objs = []
+        for version in versions:
+            version = versions[version]
+            version_objs.append({
+                "id": version['id'],
+                "status": version['status'],
+                "updated": version['updated'],
+                "links": self._build_links(version),
+            })
+
+        return dict(versions=version_objs)
+
+    def build_version(self, version):
+        reval = copy.deepcopy(version)
+        reval['links'].insert(0, {
+            "rel": "self",
+            "href": self.base_url.rstrip('/') + '/',
+        })
+        return dict(version=reval)
 
     def _build_links(self, version_data):
         """Generate a container of links that refer to the provided version."""
@@ -55,6 +84,11 @@ class ViewBuilder(object):
 
         return links
 
-    def generate_href(self, version_number):
+    def generate_href(self, version_number, path=None):
         """Create an url that refers to a specific version_number."""
-        return os.path.join(self.base_url, version_number) + '/'
+        version_number = version_number.strip('/')
+        if path:
+            path = path.strip('/')
+            return os.path.join(self.base_url, version_number, path)
+        else:
+            return os.path.join(self.base_url, version_number) + '/'
diff --git a/nova/api/openstack/wsgi.py b/nova/api/openstack/wsgi.py
index 53dab22e8..0eb47044e 100644
--- a/nova/api/openstack/wsgi.py
+++ b/nova/api/openstack/wsgi.py
@@ -13,6 +13,7 @@ from nova import wsgi
 
 XMLNS_V10 = 'http://docs.rackspacecloud.com/servers/api/v1.0'
 XMLNS_V11 = 'http://docs.openstack.org/compute/api/v1.1'
+
 XMLNS_ATOM = 'http://www.w3.org/2005/Atom'
 
 LOG = logging.getLogger('nova.api.openstack.wsgi')
@@ -386,6 +387,8 @@ class XMLDictSerializer(DictSerializer):
             link_node = xml_doc.createElement('atom:link')
             link_node.setAttribute('rel', link['rel'])
             link_node.setAttribute('href', link['href'])
+            if 'type' in link:
+                link_node.setAttribute('type', link['type'])
             link_nodes.append(link_node)
         return link_nodes
 
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index a2d84cd76..cf4ee229d 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -326,7 +326,7 @@ class ComputeManager(manager.SchedulerDependentManager):
             self._update_state(context, instance_id, power_state.BUILDING)
 
             try:
-                self.driver.spawn(instance, network_info, bd_mapping)
+                self.driver.spawn(context, instance, network_info, bd_mapping)
             except Exception as ex:  # pylint: disable=W0702
                 msg = _("Instance '%(instance_id)s' failed to spawn. Is "
                         "virtualization enabled in the BIOS? Details: "
@@ -433,7 +433,7 @@ class ComputeManager(manager.SchedulerDependentManager):
         network_info = self.network_api.get_instance_nw_info(context,
                                                               instance_ref)
         bd_mapping = self._setup_block_device_mapping(context, instance_id)
-        self.driver.spawn(instance_ref, network_info, bd_mapping)
+        self.driver.spawn(context, instance_ref, network_info, bd_mapping)
 
         self._update_image_ref(context, instance_id, image_ref)
         self._update_launched_at(context, instance_id)
@@ -501,7 +501,7 @@ class ComputeManager(manager.SchedulerDependentManager):
                        'instance: %(instance_id)s (state: %(state)s '
                        'expected: %(running)s)') % locals())
 
-        self.driver.snapshot(instance_ref, image_id)
+        self.driver.snapshot(context, instance_ref, image_id)
 
         if image_type == 'snapshot':
             if rotation:
@@ -660,7 +660,7 @@ class ComputeManager(manager.SchedulerDependentManager):
         _update_state = lambda result: self._update_state_callback(
                 self, context, instance_id, result)
         network_info = self._get_instance_nw_info(context, instance_ref)
-        self.driver.rescue(instance_ref, _update_state, network_info)
+        self.driver.rescue(context, instance_ref, _update_state, network_info)
         self._update_state(context, instance_id)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
@@ -863,8 +863,8 @@ class ComputeManager(manager.SchedulerDependentManager):
                                             instance_ref.uuid)
 
         network_info = self._get_instance_nw_info(context, instance_ref)
-        self.driver.finish_migration(instance_ref, disk_info, network_info,
-                                  resize_instance)
+        self.driver.finish_migration(context, instance_ref, disk_info,
+                                     network_info, resize_instance)
 
         self.db.migration_update(context, migration_id,
                 {'status': 'finished', })
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 36614df1f..4f1445217 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1680,7 +1680,8 @@ def network_get_by_bridge(context, bridge):
 def network_get_by_cidr(context, cidr):
     session = get_session()
     result = session.query(models.Network).\
-                filter_by(cidr=cidr).first()
+                filter(or_(models.Network.cidr == cidr,
+                           models.Network.cidr_v6 == cidr)).first()
 
     if not result:
         raise exception.NetworkNotFoundForCidr(cidr=cidr)
diff --git a/nova/image/glance.py b/nova/image/glance.py
index 5c2dc957b..44a3c6f83 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -83,11 +83,16 @@ class GlanceImageService(service.BaseImageService):
 
     client = property(_get_client, _set_client)
 
+    def _set_client_context(self, context):
+        """Sets the client's auth token."""
+        self.client.set_auth_token(context.auth_token)
+
     def index(self, context, filters=None, marker=None, limit=None):
         """Calls out to Glance for a list of images available."""
         # NOTE(sirp): We need to use `get_images_detailed` and not
         # `get_images` here because we need `is_public` and `properties`
         # included so we can filter by user
+        self._set_client_context(context)
         filtered = []
         filters = filters or {}
         if 'is_public' not in filters:
@@ -104,6 +109,7 @@ class GlanceImageService(service.BaseImageService):
 
     def detail(self, context, filters=None, marker=None, limit=None):
         """Calls out to Glance for a list of detailed image information."""
+        self._set_client_context(context)
         filtered = []
         filters = filters or {}
         if 'is_public' not in filters:
@@ -120,6 +126,7 @@ class GlanceImageService(service.BaseImageService):
 
     def show(self, context, image_id):
         """Returns a dict with image data for the given opaque image id."""
+        self._set_client_context(context)
         try:
             image_meta = self.client.get_image_meta(image_id)
         except glance_exception.NotFound:
@@ -143,6 +150,7 @@ class GlanceImageService(service.BaseImageService):
 
     def get(self, context, image_id, data):
         """Calls out to Glance for metadata and data and writes data."""
+        self._set_client_context(context)
         try:
             image_meta, image_chunks = self.client.get_image(image_id)
         except glance_exception.NotFound:
@@ -160,6 +168,7 @@ class GlanceImageService(service.BaseImageService):
         :raises: AlreadyExists if the image already exist.
 
         """
+        self._set_client_context(context)
         # Translate Base -> Service
         LOG.debug(_('Creating image in Glance. Metadata passed in %s'),
                   image_meta)
@@ -182,6 +191,7 @@ class GlanceImageService(service.BaseImageService):
         :raises: ImageNotFound if the image does not exist.
 
         """
+        self._set_client_context(context)
         # NOTE(vish): show is to check if image is available
         self.show(context, image_id)
         try:
@@ -198,6 +208,7 @@ class GlanceImageService(service.BaseImageService):
         :raises: ImageNotFound if the image does not exist.
 
         """
+        self._set_client_context(context)
         # NOTE(vish): show is to check if image is available
         self.show(context, image_id)
         try:
diff --git a/nova/network/manager.py b/nova/network/manager.py
index 4a3791d8a..8fc6a295f 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -410,8 +410,11 @@ class NetworkManager(manager.SchedulerDependentManager):
         kwargs can contain fixed_ips to circumvent another db lookup
         """
         instance_id = kwargs.pop('instance_id')
-        fixed_ips = kwargs.get('fixed_ips') or \
+        try:
+            fixed_ips = kwargs.get('fixed_ips') or \
                   self.db.fixed_ip_get_by_instance(context, instance_id)
+        except exceptions.FixedIpNotFoundForInstance:
+            fixed_ips = []
         LOG.debug(_("network deallocation for instance |%s|"), instance_id,
                                                                context=context)
         # deallocate fixed ips
@@ -551,15 +554,17 @@ class NetworkManager(manager.SchedulerDependentManager):
         #             with a network, or a cluster of computes with a network
         #             and use that network here with a method like
         #             network_get_by_compute_host
-        address = self.db.fixed_ip_associate_pool(context.elevated(),
-                                                  network['id'],
-                                                  instance_id)
-        vif = self.db.virtual_interface_get_by_instance_and_network(context,
-                                                                instance_id,
-                                                                network['id'])
-        values = {'allocated': True,
-                  'virtual_interface_id': vif['id']}
-        self.db.fixed_ip_update(context, address, values)
+        address = None
+        if network['cidr']:
+            address = self.db.fixed_ip_associate_pool(context.elevated(),
+                                                      network['id'],
+                                                      instance_id)
+            get_vif = self.db.virtual_interface_get_by_instance_and_network
+            vif = get_vif(context, instance_id, network['id'])
+            values = {'allocated': True,
+                      'virtual_interface_id': vif['id']}
+            self.db.fixed_ip_update(context, address, values)
+
         self._setup_network(context, network)
         return address
 
@@ -613,34 +618,39 @@ class NetworkManager(manager.SchedulerDependentManager):
                         network_size, cidr_v6, gateway_v6, bridge,
                         bridge_interface, dns1=None, dns2=None, **kwargs):
         """Create networks based on parameters."""
-        fixed_net = netaddr.IPNetwork(cidr)
-        if FLAGS.use_ipv6:
+        if cidr_v6:
             fixed_net_v6 = netaddr.IPNetwork(cidr_v6)
             significant_bits_v6 = 64
             network_size_v6 = 1 << 64
 
-        for index in range(num_networks):
-            start = index * network_size
+        if cidr:
+            fixed_net = netaddr.IPNetwork(cidr)
             significant_bits = 32 - int(math.log(network_size, 2))
-            cidr = '%s/%s' % (fixed_net[start], significant_bits)
-            project_net = netaddr.IPNetwork(cidr)
+
+        for index in range(num_networks):
             net = {}
             net['bridge'] = bridge
             net['bridge_interface'] = bridge_interface
             net['dns1'] = dns1
             net['dns2'] = dns2
-            net['cidr'] = cidr
-            net['multi_host'] = multi_host
-            net['netmask'] = str(project_net.netmask)
-            net['gateway'] = str(project_net[1])
-            net['broadcast'] = str(project_net.broadcast)
-            net['dhcp_start'] = str(project_net[2])
+
+            if cidr:
+                start = index * network_size
+                project_net = netaddr.IPNetwork('%s/%s' % (fixed_net[start],
+                                                           significant_bits))
+                net['cidr'] = str(project_net)
+                net['multi_host'] = multi_host
+                net['netmask'] = str(project_net.netmask)
+                net['gateway'] = str(project_net[1])
+                net['broadcast'] = str(project_net.broadcast)
+                net['dhcp_start'] = str(project_net[2])
+
             if num_networks > 1:
                 net['label'] = '%s_%d' % (label, index)
             else:
                 net['label'] = label
 
-            if FLAGS.use_ipv6:
+            if cidr_v6:
                 start_v6 = index * network_size_v6
                 cidr_v6 = '%s/%s' % (fixed_net_v6[start_v6],
                                      significant_bits_v6)
@@ -673,11 +683,11 @@ class NetworkManager(manager.SchedulerDependentManager):
             # None if network with cidr or cidr_v6 already exists
             network = self.db.network_create_safe(context, net)
 
-            if network:
+            if not network:
+                raise ValueError(_('Network already exists!'))
+
+            if network and cidr:
                 self._create_fixed_ips(context, network['id'])
-            else:
-                raise ValueError(_('Network with cidr %s already exists') %
-                                   cidr)
 
     @property
     def _bottom_reserved_ips(self):  # pylint: disable=R0201
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 28969d5f8..a67a28a4e 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -113,8 +113,7 @@ def stub_out_key_pair_funcs(stubs, have_key_pair=True):
 
 def stub_out_image_service(stubs):
     def fake_get_image_service(image_href):
-        image_id = int(str(image_href).split('/')[-1])
-        return (nova.image.fake.FakeImageService(), image_id)
+        return (nova.image.fake.FakeImageService(), image_href)
     stubs.Set(nova.image, 'get_image_service', fake_get_image_service)
     stubs.Set(nova.image, 'get_default_image_service',
         lambda: nova.image.fake.FakeImageService())
diff --git a/nova/tests/api/openstack/test_server_actions.py b/nova/tests/api/openstack/test_server_actions.py
index a4a126a71..fc08a2d53 100644
--- a/nova/tests/api/openstack/test_server_actions.py
+++ b/nova/tests/api/openstack/test_server_actions.py
@@ -109,8 +109,6 @@ class ServerActionsTest(test.TestCase):
         self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
         self.stubs.Set(nova.db.api, 'instance_update', instance_update)
 
-        self.allow_admin = FLAGS.allow_admin_api
-
         self.webreq = common.webob_factory('/v1.0/servers')
 
     def tearDown(self):
@@ -304,7 +302,7 @@ class ServerActionsTest(test.TestCase):
         """This is basically the same as resize, only we provide the `migrate`
         attribute in the body's dict.
         """
-        req = self.webreq('/1/action', 'POST', dict(migrate=None))
+        req = self.webreq('/1/migrate', 'POST')
 
         self.resize_called = False
 
@@ -319,7 +317,7 @@ class ServerActionsTest(test.TestCase):
 
     def test_create_backup(self):
         """The happy path for creating backups"""
-        FLAGS.allow_admin_api = True
+        self.flags(allow_admin_api=True)
 
         body = {
             'createBackup': {
@@ -339,7 +337,7 @@ class ServerActionsTest(test.TestCase):
 
     def test_create_backup_admin_api_off(self):
         """The happy path for creating backups"""
-        FLAGS.allow_admin_api = False
+        self.flags(allow_admin_api=False)
 
         body = {
             'createBackup': {
@@ -357,7 +355,7 @@ class ServerActionsTest(test.TestCase):
         self.assertEqual(501, response.status_int)
 
     def test_create_backup_with_metadata(self):
-        FLAGS.allow_admin_api = True
+        self.flags(allow_admin_api=True)
 
         body = {
             'createBackup': {
@@ -378,7 +376,7 @@ class ServerActionsTest(test.TestCase):
 
     def test_create_backup_no_name(self):
         """Name is required for backups"""
-        FLAGS.allow_admin_api = True
+        self.flags(allow_admin_api=True)
 
         body = {
             'createBackup': {
@@ -396,7 +394,7 @@ class ServerActionsTest(test.TestCase):
 
     def test_create_backup_no_rotation(self):
         """Rotation is required for backup requests"""
-        FLAGS.allow_admin_api = True
+        self.flags(allow_admin_api=True)
 
         body = {
             'createBackup': {
@@ -415,7 +413,7 @@ class ServerActionsTest(test.TestCase):
 
     def test_create_backup_no_backup_type(self):
         """Backup Type (daily or weekly) is required for backup requests"""
-        FLAGS.allow_admin_api = True
+        self.flags(allow_admin_api=True)
 
         body = {
             'createBackup': {
@@ -432,7 +430,7 @@ class ServerActionsTest(test.TestCase):
         self.assertEqual(400, response.status_int)
 
     def test_create_backup_bad_entity(self):
-        FLAGS.allow_admin_api = True
+        self.flags(allow_admin_api=True)
 
         body = {'createBackup': 'go'}
         req = webob.Request.blank('/v1.0/images')
@@ -717,7 +715,7 @@ class ServerActionsTestV11(test.TestCase):
 
     def test_create_backup(self):
         """The happy path for creating backups"""
-        FLAGS.allow_admin_api = True
+        self.flags(allow_admin_api=True)
 
         body = {
             'createBackup': {
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index f66b213a8..02fc36a58 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -260,14 +260,8 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.compute.API, "get_diagnostics", fake_compute_api)
         self.stubs.Set(nova.compute.API, "get_actions", fake_compute_api)
 
-        self.allow_admin = FLAGS.allow_admin_api
         self.webreq = common.webob_factory('/v1.0/servers')
 
-    def tearDown(self):
-        self.stubs.UnsetAll()
-        FLAGS.allow_admin_api = self.allow_admin
-        super(ServersTest, self).tearDown()
-
     def test_get_server_by_id(self):
         req = webob.Request.blank('/v1.0/servers/1')
         res = req.get_response(fakes.wsgi_app())
@@ -762,7 +756,7 @@ class ServersTest(test.TestCase):
         self.assertEquals(ip.getAttribute('addr'), private)
 
     def test_get_server_by_id_with_addresses_v1_1(self):
-        FLAGS.use_ipv6 = True
+        self.flags(use_ipv6=True)
         interfaces = [
             {
                 'network': {'label': 'network_1'},
@@ -806,7 +800,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(addresses, expected)
 
     def test_get_server_by_id_with_addresses_v1_1_ipv6_disabled(self):
-        FLAGS.use_ipv6 = False
+        self.flags(use_ipv6=False)
         interfaces = [
             {
                 'network': {'label': 'network_1'},
@@ -849,7 +843,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(addresses, expected)
 
     def test_get_server_addresses_v1_1(self):
-        FLAGS.use_ipv6 = True
+        self.flags(use_ipv6=True)
         interfaces = [
             {
                 'network': {'label': 'network_1'},
@@ -900,7 +894,7 @@ class ServersTest(test.TestCase):
         self.assertEqual(res_dict, expected)
 
     def test_get_server_addresses_single_network_v1_1(self):
-        FLAGS.use_ipv6 = True
+        self.flags(use_ipv6=True)
         interfaces = [
             {
                 'network': {'label': 'network_1'},
@@ -1320,7 +1314,8 @@ class ServersTest(test.TestCase):
     def test_create_instance_v1_1(self):
         self._setup_for_create_instance()
 
-        image_href = 'http://localhost/images/2'
+        # proper local hrefs must start with 'http://localhost/v1.1/'
+        image_href = 'http://localhost/v1.1/images/2'
         flavor_ref = 'http://localhost/flavors/3'
         expected_flavor = {
             "id": "3",
@@ -1822,12 +1817,14 @@ class ServersTest(test.TestCase):
         self.assertEqual(res.status_int, 202)
 
     def test_server_diagnostics(self):
+        self.flags(allow_admin_api=False)
         req = webob.Request.blank("/v1.0/servers/1/diagnostics")
         req.method = "GET"
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 404)
 
     def test_server_actions(self):
+        self.flags(allow_admin_api=False)
         req = webob.Request.blank("/v1.0/servers/1/actions")
         req.method = "GET"
         res = req.get_response(fakes.wsgi_app())
diff --git a/nova/tests/api/openstack/test_versions.py b/nova/tests/api/openstack/test_versions.py
index da964ee1f..e68455778 100644
--- a/nova/tests/api/openstack/test_versions.py
+++ b/nova/tests/api/openstack/test_versions.py
@@ -16,21 +16,92 @@
 #    under the License.
 
 import json
+import stubout
 import webob
+import xml.etree.ElementTree
+
 
 from nova import context
 from nova import test
 from nova.tests.api.openstack import fakes
 from nova.api.openstack import versions
 from nova.api.openstack import views
+from nova.api.openstack import wsgi
+
+VERSIONS = {
+    "v1.0": {
+        "id": "v1.0",
+        "status": "DEPRECATED",
+        "updated": "2011-01-21T11:33:21Z",
+        "links": [
+            {
+                "rel": "describedby",
+                "type": "application/pdf",
+                "href": "http://docs.rackspacecloud.com/"
+                        "servers/api/v1.0/cs-devguide-20110125.pdf"
+            },
+            {
+                "rel": "describedby",
+                "type": "application/vnd.sun.wadl+xml",
+                "href": "http://docs.rackspacecloud.com/"
+                        "servers/api/v1.0/application.wadl"
+            },
+        ],
+        "media-types": [
+            {
+                "base": "application/xml",
+                "type": "application/vnd.openstack.compute-v1.0+xml"
+            },
+            {
+                "base": "application/json",
+                "type": "application/vnd.openstack.compute-v1.0+json"
+            }
+        ],
+    },
+    "v1.1": {
+        "id": "v1.1",
+        "status": "CURRENT",
+        "updated": "2011-01-21T11:33:21Z",
+        "links": [
+            {
+                "rel": "describedby",
+                "type": "application/pdf",
+                "href": "http://docs.rackspacecloud.com/"
+                        "servers/api/v1.1/cs-devguide-20110125.pdf"
+            },
+            {
+                "rel": "describedby",
+                "type": "application/vnd.sun.wadl+xml",
+                "href": "http://docs.rackspacecloud.com/"
+                        "servers/api/v1.1/application.wadl"
+            },
+        ],
+        "media-types": [
+            {
+                "base": "application/xml",
+                "type": "application/vnd.openstack.compute-v1.1+xml"
+            },
+            {
+                "base": "application/json",
+                "type": "application/vnd.openstack.compute-v1.1+json"
+            }
+        ],
+    },
+}
 
 
 class VersionsTest(test.TestCase):
     def setUp(self):
         super(VersionsTest, self).setUp()
         self.context = context.get_admin_context()
+        self.stubs = stubout.StubOutForTesting()
+        fakes.stub_out_auth(self.stubs)
+        #Stub out VERSIONS
+        self.old_versions = versions.VERSIONS
+        versions.VERSIONS = VERSIONS
 
     def tearDown(self):
+        versions.VERSIONS = self.old_versions
         super(VersionsTest, self).tearDown()
 
     def test_get_version_list(self):
@@ -44,7 +115,7 @@ class VersionsTest(test.TestCase):
             {
                 "id": "v1.1",
                 "status": "CURRENT",
-                "updated": "2011-07-18T11:30:00Z",
+                "updated": "2011-01-21T11:33:21Z",
                 "links": [
                     {
                         "rel": "self",
@@ -54,7 +125,7 @@ class VersionsTest(test.TestCase):
             {
                 "id": "v1.0",
                 "status": "DEPRECATED",
-                "updated": "2010-10-09T11:30:00Z",
+                "updated": "2011-01-21T11:33:21Z",
                 "links": [
                     {
                         "rel": "self",
@@ -64,6 +135,183 @@ class VersionsTest(test.TestCase):
         ]
         self.assertEqual(versions, expected)
 
+    def test_get_version_1_0_detail(self):
+        req = webob.Request.blank('/v1.0/')
+        req.accept = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res.content_type, "application/json")
+        version = json.loads(res.body)
+        expected = {
+            "version": {
+                "id": "v1.0",
+                "status": "DEPRECATED",
+                "updated": "2011-01-21T11:33:21Z",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.0/"
+                    },
+                    {
+                        "rel": "describedby",
+                        "type": "application/pdf",
+                        "href": "http://docs.rackspacecloud.com/"
+                                "servers/api/v1.0/cs-devguide-20110125.pdf"
+                    },
+                    {
+                        "rel": "describedby",
+                        "type": "application/vnd.sun.wadl+xml",
+                        "href": "http://docs.rackspacecloud.com/"
+                                "servers/api/v1.0/application.wadl"
+                    }
+                ],
+                "media-types": [
+                    {
+                        "base": "application/xml",
+                        "type": "application/"
+                                "vnd.openstack.compute-v1.0+xml"
+                    },
+                    {
+                        "base": "application/json",
+                        "type": "application/"
+                                "vnd.openstack.compute-v1.0+json"
+                    }
+                ]
+            }
+        }
+        self.assertEqual(expected, version)
+
+    def test_get_version_1_1_detail(self):
+        req = webob.Request.blank('/v1.1/')
+        req.accept = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res.content_type, "application/json")
+        version = json.loads(res.body)
+        expected = {
+            "version": {
+                "id": "v1.1",
+                "status": "CURRENT",
+                "updated": "2011-01-21T11:33:21Z",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/"
+                    },
+                    {
+                        "rel": "describedby",
+                        "type": "application/pdf",
+                        "href": "http://docs.rackspacecloud.com/"
+                                "servers/api/v1.1/cs-devguide-20110125.pdf"
+                    },
+                    {
+                        "rel": "describedby",
+                        "type": "application/vnd.sun.wadl+xml",
+                        "href": "http://docs.rackspacecloud.com/"
+                                "servers/api/v1.1/application.wadl"
+                    }
+                ],
+                "media-types": [
+                    {
+                        "base": "application/xml",
+                        "type": "application/"
+                                "vnd.openstack.compute-v1.1+xml"
+                    },
+                    {
+                        "base": "application/json",
+                        "type": "application/"
+                                "vnd.openstack.compute-v1.1+json"
+                    }
+                ]
+            }
+        }
+        self.assertEqual(expected, version)
+
+    def test_get_version_1_0_detail_xml(self):
+        req = webob.Request.blank('/v1.0/')
+        req.accept = "application/xml"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res.content_type, "application/xml")
+        root = xml.etree.ElementTree.XML(res.body)
+        self.assertEqual(root.tag.split('}')[1], "version")
+        self.assertEqual(root.tag.split('}')[0].strip('{'), wsgi.XMLNS_V11)
+
+        children = list(root)
+        media_types = children[0]
+        media_type_nodes = list(media_types)
+        links = (children[1], children[2], children[3])
+
+        self.assertEqual(media_types.tag.split('}')[1], 'media-types')
+        for media_node in media_type_nodes:
+            self.assertEqual(media_node.tag.split('}')[1], 'media-type')
+
+        expected = """
+        <version id="v1.0" status="DEPRECATED"
+             updated="2011-01-21T11:33:21Z"
+             xmlns="%s"
+             xmlns:atom="http://www.w3.org/2005/Atom">
+
+            <media-types>
+                <media-type base="application/xml"
+                     type="application/vnd.openstack.compute-v1.0+xml"/>
+                <media-type base="application/json"
+                     type="application/vnd.openstack.compute-v1.0+json"/>
+            </media-types>
+
+            <atom:link href="http://localhost/v1.0/"
+                 rel="self"/>
+
+            <atom:link href="http://docs.rackspacecloud.com/servers/
+                api/v1.0/cs-devguide-20110125.pdf"
+                 rel="describedby"
+                 type="application/pdf"/>
+
+            <atom:link href="http://docs.rackspacecloud.com/servers/
+                api/v1.0/application.wadl"
+                 rel="describedby"
+                 type="application/vnd.sun.wadl+xml"/>
+        </version>""".replace("  ", "").replace("\n", "") % wsgi.XMLNS_V11
+
+        actual = res.body.replace("  ", "").replace("\n", "")
+        self.assertEqual(expected, actual)
+
+    def test_get_version_1_1_detail_xml(self):
+        req = webob.Request.blank('/v1.1/')
+        req.accept = "application/xml"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res.content_type, "application/xml")
+        expected = """
+        <version id="v1.1" status="CURRENT"
+             updated="2011-01-21T11:33:21Z"
+             xmlns="%s"
+             xmlns:atom="http://www.w3.org/2005/Atom">
+
+            <media-types>
+                <media-type base="application/xml"
+                     type="application/vnd.openstack.compute-v1.1+xml"/>
+                <media-type base="application/json"
+                     type="application/vnd.openstack.compute-v1.1+json"/>
+            </media-types>
+
+            <atom:link href="http://localhost/v1.1/"
+                 rel="self"/>
+
+            <atom:link href="http://docs.rackspacecloud.com/servers/
+                api/v1.1/cs-devguide-20110125.pdf"
+                 rel="describedby"
+                 type="application/pdf"/>
+
+            <atom:link href="http://docs.rackspacecloud.com/servers/
+                api/v1.1/application.wadl"
+                 rel="describedby"
+                 type="application/vnd.sun.wadl+xml"/>
+        </version>""".replace("  ", "").replace("\n", "") % wsgi.XMLNS_V11
+
+        actual = res.body.replace("  ", "").replace("\n", "")
+        self.assertEqual(expected, actual)
+
     def test_get_version_list_xml(self):
         req = webob.Request.blank('/')
         req.accept = "application/xml"
@@ -71,18 +319,94 @@ class VersionsTest(test.TestCase):
         self.assertEqual(res.status_int, 200)
         self.assertEqual(res.content_type, "application/xml")
 
-        expected = """<versions>
-            <version id="v1.1" status="CURRENT" updated="2011-07-18T11:30:00Z">
+        expected = """
+        <versions xmlns="%s" xmlns:atom="%s">
+            <version id="v1.1" status="CURRENT" updated="2011-01-21T11:33:21Z">
                 <atom:link href="http://localhost/v1.1/" rel="self"/>
             </version>
             <version id="v1.0" status="DEPRECATED"
-                 updated="2010-10-09T11:30:00Z">
+                 updated="2011-01-21T11:33:21Z">
                 <atom:link href="http://localhost/v1.0/" rel="self"/>
             </version>
-        </versions>""".replace("  ", "").replace("\n", "")
+        </versions>""".replace("  ", "").replace("\n", "") % (wsgi.XMLNS_V11,
+                                                              wsgi.XMLNS_ATOM)
+
+        actual = res.body.replace("  ", "").replace("\n", "")
+
+        self.assertEqual(expected, actual)
+
+    def test_get_version_1_0_detail_atom(self):
+        req = webob.Request.blank('/v1.0/')
+        req.accept = "application/atom+xml"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual("application/atom+xml", res.content_type)
+        expected = """
+        <feed xmlns="http://www.w3.org/2005/Atom">
+            <title type="text">About This Version</title>
+            <updated>2011-01-21T11:33:21Z</updated>
+            <id>http://localhost/v1.0/</id>
+            <author>
+                <name>Rackspace</name>
+                <uri>http://www.rackspace.com/</uri>
+            </author>
+            <link href="http://localhost/v1.0/" rel="self"/>
+            <entry>
+                <id>http://localhost/v1.0/</id>
+                <title type="text">Version v1.0</title>
+                <updated>2011-01-21T11:33:21Z</updated>
+                <link href="http://localhost/v1.0/"
+                     rel="self"/>
+                <link href="http://docs.rackspacecloud.com/servers/
+                    api/v1.0/cs-devguide-20110125.pdf"
+                     rel="describedby" type="application/pdf"/>
+                <link href="http://docs.rackspacecloud.com/servers/
+                    api/v1.0/application.wadl"
+                     rel="describedby" type="application/vnd.sun.wadl+xml"/>
+                <content type="text">
+                    Version v1.0 DEPRECATED (2011-01-21T11:33:21Z)
+                </content>
+            </entry>
+        </feed>""".replace("  ", "").replace("\n", "")
 
         actual = res.body.replace("  ", "").replace("\n", "")
+        self.assertEqual(expected, actual)
+
+    def test_get_version_1_1_detail_atom(self):
+        req = webob.Request.blank('/v1.1/')
+        req.accept = "application/atom+xml"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual("application/atom+xml", res.content_type)
+        expected = """
+        <feed xmlns="http://www.w3.org/2005/Atom">
+            <title type="text">About This Version</title>
+            <updated>2011-01-21T11:33:21Z</updated>
+            <id>http://localhost/v1.1/</id>
+            <author>
+                <name>Rackspace</name>
+                <uri>http://www.rackspace.com/</uri>
+            </author>
+            <link href="http://localhost/v1.1/" rel="self"/>
+            <entry>
+                <id>http://localhost/v1.1/</id>
+                <title type="text">Version v1.1</title>
+                <updated>2011-01-21T11:33:21Z</updated>
+                <link href="http://localhost/v1.1/"
+                     rel="self"/>
+                <link href="http://docs.rackspacecloud.com/servers/
+                    api/v1.1/cs-devguide-20110125.pdf"
+                     rel="describedby" type="application/pdf"/>
+                <link href="http://docs.rackspacecloud.com/servers/
+                    api/v1.1/application.wadl"
+                     rel="describedby" type="application/vnd.sun.wadl+xml"/>
+                <content type="text">
+                    Version v1.1 CURRENT (2011-01-21T11:33:21Z)
+                </content>
+            </entry>
+        </feed>""".replace("  ", "").replace("\n", "")
 
+        actual = res.body.replace("  ", "").replace("\n", "")
         self.assertEqual(expected, actual)
 
     def test_get_version_list_atom(self):
@@ -95,7 +419,7 @@ class VersionsTest(test.TestCase):
         expected = """
         <feed xmlns="http://www.w3.org/2005/Atom">
             <title type="text">Available API Versions</title>
-            <updated>2011-07-18T11:30:00Z</updated>
+            <updated>2011-01-21T11:33:21Z</updated>
             <id>http://localhost/</id>
             <author>
                 <name>Rackspace</name>
@@ -105,19 +429,19 @@ class VersionsTest(test.TestCase):
             <entry>
                 <id>http://localhost/v1.1/</id>
                 <title type="text">Version v1.1</title>
-                <updated>2011-07-18T11:30:00Z</updated>
+                <updated>2011-01-21T11:33:21Z</updated>
                 <link href="http://localhost/v1.1/" rel="self"/>
                 <content type="text">
-                    Version v1.1 CURRENT (2011-07-18T11:30:00Z)
+                    Version v1.1 CURRENT (2011-01-21T11:33:21Z)
                 </content>
             </entry>
             <entry>
                 <id>http://localhost/v1.0/</id>
                 <title type="text">Version v1.0</title>
-                <updated>2010-10-09T11:30:00Z</updated>
+                <updated>2011-01-21T11:33:21Z</updated>
                 <link href="http://localhost/v1.0/" rel="self"/>
                 <content type="text">
-                    Version v1.0 DEPRECATED (2010-10-09T11:30:00Z)
+                    Version v1.0 DEPRECATED (2011-01-21T11:33:21Z)
                 </content>
             </entry>
         </feed>
@@ -127,28 +451,184 @@ class VersionsTest(test.TestCase):
 
         self.assertEqual(expected, actual)
 
+    def test_multi_choice_image(self):
+        req = webob.Request.blank('/images/1')
+        req.accept = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 300)
+        self.assertEqual(res.content_type, "application/json")
+
+        expected = {
+        "choices": [
+            {
+                "id": "v1.1",
+                "status": "CURRENT",
+                "links": [
+                    {
+                        "href": "http://localhost/v1.1/images/1",
+                        "rel": "self",
+                    },
+                ],
+                "media-types": [
+                    {
+                        "base": "application/xml",
+                        "type": "application/vnd.openstack.compute-v1.1+xml"
+                    },
+                    {
+                        "base": "application/json",
+                        "type": "application/vnd.openstack.compute-v1.1+json"
+                    },
+                ],
+            },
+            {
+                "id": "v1.0",
+                "status": "DEPRECATED",
+                "links": [
+                    {
+                        "href": "http://localhost/v1.0/images/1",
+                        "rel": "self",
+                    },
+                ],
+                "media-types": [
+                    {
+                        "base": "application/xml",
+                        "type": "application/vnd.openstack.compute-v1.0+xml"
+                    },
+                    {
+                        "base": "application/json",
+                        "type": "application/vnd.openstack.compute-v1.0+json"
+                    },
+                ],
+            },
+        ], }
+
+        self.assertDictMatch(expected, json.loads(res.body))
+
+    def test_multi_choice_image_xml(self):
+        req = webob.Request.blank('/images/1')
+        req.accept = "application/xml"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 300)
+        self.assertEqual(res.content_type, "application/xml")
+
+        expected = """
+        <choices xmlns="%s" xmlns:atom="%s">
+          <version id="v1.1" status="CURRENT">
+            <media-types>
+              <media-type base="application/xml"
+                 type="application/vnd.openstack.compute-v1.1+xml"/>
+              <media-type base="application/json"
+                 type="application/vnd.openstack.compute-v1.1+json"/>
+            </media-types>
+            <atom:link href="http://localhost/v1.1/images/1" rel="self"/>
+          </version>
+          <version id="v1.0" status="DEPRECATED">
+            <media-types>
+              <media-type base="application/xml"
+                 type="application/vnd.openstack.compute-v1.0+xml"/>
+              <media-type base="application/json"
+                 type="application/vnd.openstack.compute-v1.0+json"/>
+            </media-types>
+            <atom:link href="http://localhost/v1.0/images/1" rel="self"/>
+          </version>
+        </choices>""".replace("  ", "").replace("\n", "") % (wsgi.XMLNS_V11,
+                                                            wsgi.XMLNS_ATOM)
+
+    def test_multi_choice_server_atom(self):
+        """
+        Make sure multi choice responses do not have content-type
+        application/atom+xml (should use default of json)
+        """
+        req = webob.Request.blank('/servers/2')
+        req.accept = "application/atom+xml"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 300)
+        self.assertEqual(res.content_type, "application/json")
+
+    def test_multi_choice_server(self):
+        req = webob.Request.blank('/servers/2')
+        req.accept = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 300)
+        self.assertEqual(res.content_type, "application/json")
+
+        expected = {
+        "choices": [
+            {
+                "id": "v1.1",
+                "status": "CURRENT",
+                "links": [
+                    {
+                        "href": "http://localhost/v1.1/servers/2",
+                        "rel": "self",
+                    },
+                ],
+                "media-types": [
+                    {
+                        "base": "application/xml",
+                        "type": "application/vnd.openstack.compute-v1.1+xml"
+                    },
+                    {
+                        "base": "application/json",
+                        "type": "application/vnd.openstack.compute-v1.1+json"
+                    },
+                ],
+            },
+            {
+                "id": "v1.0",
+                "status": "DEPRECATED",
+                "links": [
+                    {
+                        "href": "http://localhost/v1.0/servers/2",
+                        "rel": "self",
+                    },
+                ],
+                "media-types": [
+                    {
+                        "base": "application/xml",
+                        "type": "application/vnd.openstack.compute-v1.0+xml"
+                    },
+                    {
+                        "base": "application/json",
+                        "type": "application/vnd.openstack.compute-v1.0+json"
+                    },
+                ],
+            },
+        ], }
+
+        self.assertDictMatch(expected, json.loads(res.body))
+
+
+class VersionsViewBuilderTests(test.TestCase):
     def test_view_builder(self):
         base_url = "http://example.org/"
 
         version_data = {
-            "id": "3.2.1",
-            "status": "CURRENT",
-            "updated": "2011-07-18T11:30:00Z"}
+            "v3.2.1": {
+                "id": "3.2.1",
+                "status": "CURRENT",
+                "updated": "2011-07-18T11:30:00Z",
+            }
+        }
 
         expected = {
-            "id": "3.2.1",
-            "status": "CURRENT",
-            "updated": "2011-07-18T11:30:00Z",
-            "links": [
+            "versions": [
                 {
-                    "rel": "self",
-                    "href": "http://example.org/3.2.1/",
-                },
-            ],
+                    "id": "3.2.1",
+                    "status": "CURRENT",
+                    "updated": "2011-07-18T11:30:00Z",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://example.org/3.2.1/",
+                        },
+                    ],
+                }
+            ]
         }
 
         builder = views.versions.ViewBuilder(base_url)
-        output = builder.build(version_data)
+        output = builder.build_versions(version_data)
 
         self.assertEqual(output, expected)
 
@@ -163,7 +643,9 @@ class VersionsTest(test.TestCase):
 
         self.assertEqual(actual, expected)
 
-    def test_xml_serializer(self):
+
+class VersionsSerializerTests(test.TestCase):
+    def test_versions_list_xml_serializer(self):
         versions_data = {
             'versions': [
                 {
@@ -180,20 +662,137 @@ class VersionsTest(test.TestCase):
             ]
         }
 
-        expected = """
-            <versions>
-                <version id="2.7.1" status="DEPRECATED"
-                 updated="2011-07-18T11:30:00Z">
-                    <atom:link href="http://test/2.7.1" rel="self"/>
-                </version>
-            </versions>""".replace("  ", "").replace("\n", "")
+        serializer = versions.VersionsXMLSerializer()
+        response = serializer.index(versions_data)
+
+        root = xml.etree.ElementTree.XML(response)
+        self.assertEqual(root.tag.split('}')[1], "versions")
+        self.assertEqual(root.tag.split('}')[0].strip('{'), wsgi.XMLNS_V11)
+        version = list(root)[0]
+        self.assertEqual(version.tag.split('}')[1], "version")
+        self.assertEqual(version.get('id'),
+                         versions_data['versions'][0]['id'])
+        self.assertEqual(version.get('status'),
+                         versions_data['versions'][0]['status'])
+
+        link = list(version)[0]
+
+        self.assertEqual(link.tag.split('}')[1], "link")
+        self.assertEqual(link.tag.split('}')[0].strip('{'), wsgi.XMLNS_ATOM)
+        for key, val in versions_data['versions'][0]['links'][0].items():
+            self.assertEqual(link.get(key), val)
+
+    def test_versions_multi_xml_serializer(self):
+        versions_data = {
+            'choices': [
+                {
+                    "id": "2.7.1",
+                    "updated": "2011-07-18T11:30:00Z",
+                    "status": "DEPRECATED",
+                    "media-types": VERSIONS['v1.1']['media-types'],
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://test/2.7.1/images",
+                        },
+                    ],
+                },
+            ]
+        }
 
         serializer = versions.VersionsXMLSerializer()
-        response = serializer.default(versions_data)
-        response = response.replace("  ", "").replace("\n", "")
-        self.assertEqual(expected, response)
+        response = serializer.multi(versions_data)
+
+        root = xml.etree.ElementTree.XML(response)
+        self.assertEqual(root.tag.split('}')[1], "choices")
+        self.assertEqual(root.tag.split('}')[0].strip('{'), wsgi.XMLNS_V11)
+        version = list(root)[0]
+        self.assertEqual(version.tag.split('}')[1], "version")
+        self.assertEqual(version.get('id'), versions_data['choices'][0]['id'])
+        self.assertEqual(version.get('status'),
+                         versions_data['choices'][0]['status'])
+
+        media_types = list(version)[0]
+        media_type_nodes = list(media_types)
+        self.assertEqual(media_types.tag.split('}')[1], "media-types")
+
+        set_types = versions_data['choices'][0]['media-types']
+        for i, type in enumerate(set_types):
+            node = media_type_nodes[i]
+            self.assertEqual(node.tag.split('}')[1], "media-type")
+            for key, val in set_types[i].items():
+                self.assertEqual(node.get(key), val)
+
+        link = list(version)[1]
+
+        self.assertEqual(link.tag.split('}')[1], "link")
+        self.assertEqual(link.tag.split('}')[0].strip('{'), wsgi.XMLNS_ATOM)
+        for key, val in versions_data['choices'][0]['links'][0].items():
+            self.assertEqual(link.get(key), val)
+
+    def test_version_detail_xml_serializer(self):
+        version_data = {
+            "version": {
+                "id": "v1.0",
+                "status": "CURRENT",
+                "updated": "2011-01-21T11:33:21Z",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.0/"
+                    },
+                    {
+                        "rel": "describedby",
+                        "type": "application/pdf",
+                        "href": "http://docs.rackspacecloud.com/"
+                                "servers/api/v1.0/cs-devguide-20110125.pdf"
+                    },
+                    {
+                        "rel": "describedby",
+                        "type": "application/vnd.sun.wadl+xml",
+                        "href": "http://docs.rackspacecloud.com/"
+                                "servers/api/v1.0/application.wadl"
+                    },
+                ],
+                "media-types": [
+                    {
+                        "base": "application/xml",
+                        "type": "application/vnd.openstack.compute-v1.0+xml"
+                    },
+                    {
+                        "base": "application/json",
+                        "type": "application/vnd.openstack.compute-v1.0+json"
+                    }
+                ],
+            },
+        }
+
+        serializer = versions.VersionsXMLSerializer()
+        response = serializer.show(version_data)
+
+        root = xml.etree.ElementTree.XML(response)
+        self.assertEqual(root.tag.split('}')[1], "version")
+        self.assertEqual(root.tag.split('}')[0].strip('{'), wsgi.XMLNS_V11)
 
-    def test_atom_serializer(self):
+        children = list(root)
+        media_types = children[0]
+        media_type_nodes = list(media_types)
+        links = (children[1], children[2], children[3])
+
+        self.assertEqual(media_types.tag.split('}')[1], 'media-types')
+        for i, media_node in enumerate(media_type_nodes):
+            self.assertEqual(media_node.tag.split('}')[1], 'media-type')
+            for key, val in version_data['version']['media-types'][i].items():
+                self.assertEqual(val, media_node.get(key))
+
+        for i, link in enumerate(links):
+            self.assertEqual(link.tag.split('}')[0].strip('{'),
+                             'http://www.w3.org/2005/Atom')
+            self.assertEqual(link.tag.split('}')[1], 'link')
+            for key, val in version_data['version']['links'][i].items():
+                self.assertEqual(val, link.get(key))
+
+    def test_versions_list_atom_serializer(self):
         versions_data = {
             'versions': [
                 {
@@ -210,45 +809,158 @@ class VersionsTest(test.TestCase):
             ]
         }
 
-        expected = """
-            <feed xmlns="http://www.w3.org/2005/Atom">
-                <title type="text">
-                    Available API Versions
-                </title>
-                <updated>
-                    2011-07-20T11:40:00Z
-                </updated>
-                <id>
-                    http://test/
-                </id>
-                <author>
-                    <name>
-                        Rackspace
-                    </name>
-                    <uri>
-                        http://www.rackspace.com/
-                    </uri>
-                </author>
-                <link href="http://test/" rel="self"/>
-                <entry>
-                    <id>
-                        http://test/2.9.8
-                    </id>
-                    <title type="text">
-                        Version 2.9.8
-                    </title>
-                    <updated>
-                        2011-07-20T11:40:00Z
-                    </updated>
-                    <link href="http://test/2.9.8" rel="self"/>
-                    <content type="text">
-                        Version 2.9.8 CURRENT (2011-07-20T11:40:00Z)
-                    </content>
-                </entry>
-            </feed>""".replace("  ", "").replace("\n", "")
+        serializer = versions.VersionsAtomSerializer()
+        response = serializer.index(versions_data)
+
+        root = xml.etree.ElementTree.XML(response)
+        self.assertEqual(root.tag.split('}')[1], "feed")
+        self.assertEqual(root.tag.split('}')[0].strip('{'),
+                         "http://www.w3.org/2005/Atom")
+
+        children = list(root)
+        title = children[0]
+        updated = children[1]
+        id = children[2]
+        author = children[3]
+        link = children[4]
+        entry = children[5]
+
+        self.assertEqual(title.tag.split('}')[1], 'title')
+        self.assertEqual(title.text, 'Available API Versions')
+        self.assertEqual(updated.tag.split('}')[1], 'updated')
+        self.assertEqual(updated.text, '2011-07-20T11:40:00Z')
+        self.assertEqual(id.tag.split('}')[1], 'id')
+        self.assertEqual(id.text, 'http://test/')
+
+        self.assertEqual(author.tag.split('}')[1], 'author')
+        author_name = list(author)[0]
+        author_uri = list(author)[1]
+        self.assertEqual(author_name.tag.split('}')[1], 'name')
+        self.assertEqual(author_name.text, 'Rackspace')
+        self.assertEqual(author_uri.tag.split('}')[1], 'uri')
+        self.assertEqual(author_uri.text, 'http://www.rackspace.com/')
+
+        self.assertEqual(link.get('href'), 'http://test/')
+        self.assertEqual(link.get('rel'), 'self')
+
+        self.assertEqual(entry.tag.split('}')[1], 'entry')
+        entry_children = list(entry)
+        entry_id = entry_children[0]
+        entry_title = entry_children[1]
+        entry_updated = entry_children[2]
+        entry_link = entry_children[3]
+        entry_content = entry_children[4]
+        self.assertEqual(entry_id.tag.split('}')[1], "id")
+        self.assertEqual(entry_id.text, "http://test/2.9.8")
+        self.assertEqual(entry_title.tag.split('}')[1], "title")
+        self.assertEqual(entry_title.get('type'), "text")
+        self.assertEqual(entry_title.text, "Version 2.9.8")
+        self.assertEqual(entry_updated.tag.split('}')[1], "updated")
+        self.assertEqual(entry_updated.text, "2011-07-20T11:40:00Z")
+        self.assertEqual(entry_link.tag.split('}')[1], "link")
+        self.assertEqual(entry_link.get('href'), "http://test/2.9.8")
+        self.assertEqual(entry_link.get('rel'), "self")
+        self.assertEqual(entry_content.tag.split('}')[1], "content")
+        self.assertEqual(entry_content.get('type'), "text")
+        self.assertEqual(entry_content.text,
+                         "Version 2.9.8 CURRENT (2011-07-20T11:40:00Z)")
+
+    def test_version_detail_atom_serializer(self):
+        versions_data = {
+            "version": {
+                "id": "v1.1",
+                "status": "CURRENT",
+                "updated": "2011-01-21T11:33:21Z",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/"
+                    },
+                    {
+                        "rel": "describedby",
+                        "type": "application/pdf",
+                        "href": "http://docs.rackspacecloud.com/"
+                                "servers/api/v1.1/cs-devguide-20110125.pdf"
+                    },
+                    {
+                        "rel": "describedby",
+                        "type": "application/vnd.sun.wadl+xml",
+                        "href": "http://docs.rackspacecloud.com/"
+                                "servers/api/v1.1/application.wadl"
+                    },
+                ],
+                "media-types": [
+                    {
+                        "base": "application/xml",
+                        "type": "application/vnd.openstack.compute-v1.1+xml"
+                    },
+                    {
+                        "base": "application/json",
+                        "type": "application/vnd.openstack.compute-v1.1+json"
+                    }
+                ],
+            },
+        }
 
         serializer = versions.VersionsAtomSerializer()
-        response = serializer.default(versions_data)
-        print response
-        response = response.replace("  ", "").replace("\n", "")
-        self.assertEqual(expected, response)
+        response = serializer.show(versions_data)
+
+        root = xml.etree.ElementTree.XML(response)
+        self.assertEqual(root.tag.split('}')[1], "feed")
+        self.assertEqual(root.tag.split('}')[0].strip('{'),
+                         "http://www.w3.org/2005/Atom")
+
+        children = list(root)
+        title = children[0]
+        updated = children[1]
+        id = children[2]
+        author = children[3]
+        link = children[4]
+        entry = children[5]
+
+        self.assertEqual(root.tag.split('}')[1], 'feed')
+        self.assertEqual(title.tag.split('}')[1], 'title')
+        self.assertEqual(title.text, 'About This Version')
+        self.assertEqual(updated.tag.split('}')[1], 'updated')
+        self.assertEqual(updated.text, '2011-01-21T11:33:21Z')
+        self.assertEqual(id.tag.split('}')[1], 'id')
+        self.assertEqual(id.text, 'http://localhost/v1.1/')
+
+        self.assertEqual(author.tag.split('}')[1], 'author')
+        author_name = list(author)[0]
+        author_uri = list(author)[1]
+        self.assertEqual(author_name.tag.split('}')[1], 'name')
+        self.assertEqual(author_name.text, 'Rackspace')
+        self.assertEqual(author_uri.tag.split('}')[1], 'uri')
+        self.assertEqual(author_uri.text, 'http://www.rackspace.com/')
+
+        self.assertEqual(link.get('href'),
+                         'http://localhost/v1.1/')
+        self.assertEqual(link.get('rel'), 'self')
+
+        self.assertEqual(entry.tag.split('}')[1], 'entry')
+        entry_children = list(entry)
+        entry_id = entry_children[0]
+        entry_title = entry_children[1]
+        entry_updated = entry_children[2]
+        entry_links = (entry_children[3], entry_children[4], entry_children[5])
+        entry_content = entry_children[6]
+
+        self.assertEqual(entry_id.tag.split('}')[1], "id")
+        self.assertEqual(entry_id.text,
+                         "http://localhost/v1.1/")
+        self.assertEqual(entry_title.tag.split('}')[1], "title")
+        self.assertEqual(entry_title.get('type'), "text")
+        self.assertEqual(entry_title.text, "Version v1.1")
+        self.assertEqual(entry_updated.tag.split('}')[1], "updated")
+        self.assertEqual(entry_updated.text, "2011-01-21T11:33:21Z")
+
+        for i, link in enumerate(versions_data["version"]["links"]):
+            self.assertEqual(entry_links[i].tag.split('}')[1], "link")
+            for key, val in versions_data["version"]["links"][i].items():
+                self.assertEqual(entry_links[i].get(key), val)
+
+        self.assertEqual(entry_content.tag.split('}')[1], "content")
+        self.assertEqual(entry_content.get('type'), "text")
+        self.assertEqual(entry_content.text,
+                         "Version v1.1 CURRENT (2011-01-21T11:33:21Z)")
diff --git a/nova/tests/glance/stubs.py b/nova/tests/glance/stubs.py
index aac3ff330..d51b19ccd 100644
--- a/nova/tests/glance/stubs.py
+++ b/nova/tests/glance/stubs.py
@@ -60,7 +60,10 @@ class FakeGlance(object):
                            'container_format': 'ovf'},
             'image_data': StringIO.StringIO('')}}
 
-    def __init__(self, host, port=None, use_ssl=False):
+    def __init__(self, host, port=None, use_ssl=False, auth_tok=None):
+        pass
+
+    def set_auth_token(self, auth_tok):
         pass
 
     def get_image_meta(self, image_id):
diff --git a/nova/tests/image/test_glance.py b/nova/tests/image/test_glance.py
index 223e7ae57..5a40f578f 100644
--- a/nova/tests/image/test_glance.py
+++ b/nova/tests/image/test_glance.py
@@ -31,6 +31,9 @@ class StubGlanceClient(object):
         self.add_response = add_response
         self.update_response = update_response
 
+    def set_auth_token(self, auth_tok):
+        pass
+
     def get_image_meta(self, image_id):
         return self.images[image_id]
 
diff --git a/nova/tests/test_db_api.py b/nova/tests/test_db_api.py
index 54448f9d6..0c07cbb7c 100644
--- a/nova/tests/test_db_api.py
+++ b/nova/tests/test_db_api.py
@@ -57,7 +57,7 @@ class DbApiTestCase(test.TestCase):
     def test_instance_get_project_vpn(self):
         values = {'instance_type_id': FLAGS.default_instance_type,
                   'image_ref': FLAGS.vpn_image_id,
-                  'project_id': self.project_id
+                  'project_id': self.project_id,
                  }
         instance = db.instance_create(self.context, values)
         result = db.instance_get_project_vpn(self.context.elevated(),
@@ -67,7 +67,7 @@ class DbApiTestCase(test.TestCase):
     def test_instance_get_project_vpn_joins(self):
         values = {'instance_type_id': FLAGS.default_instance_type,
                   'image_ref': FLAGS.vpn_image_id,
-                  'project_id': self.project_id
+                  'project_id': self.project_id,
                  }
         instance = db.instance_create(self.context, values)
         _setup_networking(instance['id'])
diff --git a/nova/tests/test_libvirt.py b/nova/tests/test_libvirt.py
index c5c3151dc..cf25ce215 100644
--- a/nova/tests/test_libvirt.py
+++ b/nova/tests/test_libvirt.py
@@ -346,7 +346,7 @@ class LibvirtConnTestCase(test.TestCase):
         self.mox.ReplayAll()
 
         conn = connection.LibvirtConnection(False)
-        conn.snapshot(instance_ref, recv_meta['id'])
+        conn.snapshot(self.context, instance_ref, recv_meta['id'])
 
         snapshot = image_service.show(context, recv_meta['id'])
         self.assertEquals(snapshot['properties']['image_state'], 'available')
@@ -386,7 +386,7 @@ class LibvirtConnTestCase(test.TestCase):
         self.mox.ReplayAll()
 
         conn = connection.LibvirtConnection(False)
-        conn.snapshot(instance_ref, recv_meta['id'])
+        conn.snapshot(self.context, instance_ref, recv_meta['id'])
 
         snapshot = image_service.show(context, recv_meta['id'])
         self.assertEquals(snapshot['properties']['image_state'], 'available')
@@ -736,7 +736,7 @@ class LibvirtConnTestCase(test.TestCase):
         network_info = _create_network_info()
 
         try:
-            conn.spawn(instance, network_info)
+            conn.spawn(self.context, instance, network_info)
         except Exception, e:
             count = (0 <= str(e.message).find('Unexpected method call'))
 
diff --git a/nova/tests/test_vmwareapi.py b/nova/tests/test_vmwareapi.py
index 3d87d67ad..06daf46e8 100644
--- a/nova/tests/test_vmwareapi.py
+++ b/nova/tests/test_vmwareapi.py
@@ -40,6 +40,7 @@ class VMWareAPIVMTestCase(test.TestCase):
 
     def setUp(self):
         super(VMWareAPIVMTestCase, self).setUp()
+        self.context = context.RequestContext('fake', 'fake', False)
         self.flags(vmwareapi_host_ip='test_url',
                    vmwareapi_host_username='test_username',
                    vmwareapi_host_password='test_pass')
@@ -94,7 +95,7 @@ class VMWareAPIVMTestCase(test.TestCase):
         """Create and spawn the VM."""
         self._create_instance_in_the_db()
         self.type_data = db.instance_type_get_by_name(None, 'm1.large')
-        self.conn.spawn(self.instance, self.network_info)
+        self.conn.spawn(self.context, self.instance, self.network_info)
         self._check_vm_record()
 
     def _check_vm_record(self):
@@ -156,14 +157,14 @@ class VMWareAPIVMTestCase(test.TestCase):
         self._create_vm()
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
-        self.conn.snapshot(self.instance, "Test-Snapshot")
+        self.conn.snapshot(self.context, self.instance, "Test-Snapshot")
         info = self.conn.get_info(1)
         self._check_vm_info(info, power_state.RUNNING)
 
     def test_snapshot_non_existent(self):
         self._create_instance_in_the_db()
-        self.assertRaises(Exception, self.conn.snapshot, self.instance,
-                          "Test-Snapshot")
+        self.assertRaises(Exception, self.conn.snapshot, self.context,
+                          self.instance, "Test-Snapshot")
 
     def test_reboot(self):
         self._create_vm()
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 6b7d5df76..a795b3c74 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -226,7 +226,7 @@ class XenAPIVMTestCase(test.TestCase):
                                'mac': 'DE:AD:BE:EF:00:00',
                                'rxtx_cap': 3})]
             instance = db.instance_create(self.context, values)
-            self.conn.spawn(instance, network_info)
+            self.conn.spawn(self.context, instance, network_info)
 
         gt1 = eventlet.spawn(_do_build, 1, self.project_id, self.user_id)
         gt2 = eventlet.spawn(_do_build, 2, self.project_id, self.user_id)
@@ -256,14 +256,15 @@ class XenAPIVMTestCase(test.TestCase):
         instance = self._create_instance()
 
         name = "MySnapshot"
-        self.assertRaises(exception.Error, self.conn.snapshot, instance, name)
+        self.assertRaises(exception.Error, self.conn.snapshot,
+                          self.context, instance, name)
 
     def test_instance_snapshot(self):
         stubs.stubout_instance_snapshot(self.stubs)
         instance = self._create_instance()
 
         name = "MySnapshot"
-        template_vm_ref = self.conn.snapshot(instance, name)
+        template_vm_ref = self.conn.snapshot(self.context, instance, name)
 
         def ensure_vm_was_torn_down():
             vm_labels = []
@@ -425,7 +426,7 @@ class XenAPIVMTestCase(test.TestCase):
                            'label': 'fake',
                            'mac': 'DE:AD:BE:EF:00:00',
                            'rxtx_cap': 3})]
-        self.conn.spawn(instance, network_info)
+        self.conn.spawn(self.context, instance, network_info)
         self.create_vm_record(self.conn, os_type, instance_id)
         self.check_vm_record(self.conn, check_injection)
         self.assertTrue(instance.os_type)
@@ -629,7 +630,7 @@ class XenAPIVMTestCase(test.TestCase):
         self.flags(flat_injected=False)
         instance = self._create_instance()
         conn = xenapi_conn.get_connection(False)
-        conn.rescue(instance, None, [])
+        conn.rescue(self.context, instance, None, [])
 
     def test_unrescue(self):
         instance = self._create_instance()
@@ -666,7 +667,7 @@ class XenAPIVMTestCase(test.TestCase):
                            'mac': 'DE:AD:BE:EF:00:00',
                            'rxtx_cap': 3})]
         if spawn:
-            self.conn.spawn(instance, network_info)
+            self.conn.spawn(self.context, instance, network_info)
         return instance
 
 
@@ -776,8 +777,9 @@ class XenAPIMigrateInstance(test.TestCase):
                            'label': 'fake',
                            'mac': 'DE:AD:BE:EF:00:00',
                            'rxtx_cap': 3})]
-        conn.finish_migration(instance, dict(base_copy='hurr', cow='durr'),
-                           network_info, resize_instance=True)
+        conn.finish_migration(self.context, instance,
+                              dict(base_copy='hurr', cow='durr'),
+                              network_info, resize_instance=True)
         self.assertEqual(self.called, True)
 
     def test_finish_migrate_no_local_storage(self):
@@ -808,8 +810,9 @@ class XenAPIMigrateInstance(test.TestCase):
                            'label': 'fake',
                            'mac': 'DE:AD:BE:EF:00:00',
                            'rxtx_cap': 3})]
-        conn.finish_migration(instance, dict(base_copy='hurr', cow='durr'),
-                           network_info, resize_instance=True)
+        conn.finish_migration(self.context, instance,
+                              dict(base_copy='hurr', cow='durr'),
+                              network_info, resize_instance=True)
 
     def test_finish_migrate_no_resize_vdi(self):
         instance = db.instance_create(self.context, self.values)
@@ -838,8 +841,9 @@ class XenAPIMigrateInstance(test.TestCase):
                            'rxtx_cap': 3})]
 
         # Resize instance would be determined by the compute call
-        conn.finish_migration(instance, dict(base_copy='hurr', cow='durr'),
-                           network_info, resize_instance=False)
+        conn.finish_migration(self.context, instance,
+                              dict(base_copy='hurr', cow='durr'),
+                              network_info, resize_instance=False)
 
 
 class XenAPIImageTypeTestCase(test.TestCase):
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 66c79d465..0d0f84e32 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -28,8 +28,8 @@ from nova import utils
 
 def stubout_instance_snapshot(stubs):
     @classmethod
-    def fake_fetch_image(cls, session, instance_id, image, user, project,
-                         type):
+    def fake_fetch_image(cls, context, session, instance_id, image, user,
+                         project, type):
         from nova.virt.xenapi.fake import create_vdi
         name_label = "instance-%s" % instance_id
         #TODO: create fake SR record
@@ -227,7 +227,7 @@ def stub_out_vm_methods(stubs):
     def fake_release_bootlock(self, vm):
         pass
 
-    def fake_spawn_rescue(self, inst):
+    def fake_spawn_rescue(self, context, inst, network_info):
         inst._rescue = False
 
     stubs.Set(vmops.VMOps, "_shutdown", fake_shutdown)
diff --git a/nova/virt/driver.py b/nova/virt/driver.py
index b219fb2cb..4f3cfefad 100644
--- a/nova/virt/driver.py
+++ b/nova/virt/driver.py
@@ -40,6 +40,7 @@ class ComputeDriver(object):
 
     def init_host(self, host):
         """Adopt existing VM's running here"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def get_info(self, instance_name):
@@ -52,16 +53,20 @@ class ComputeDriver(object):
         :num_cpu:         (int) the number of virtual CPUs for the domain
         :cpu_time:        (int) the CPU time used in nanoseconds
         """
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def list_instances(self):
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def list_instances_detail(self):
         """Return a list of InstanceInfo for all registered VMs"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
-    def spawn(self, instance, network_info, block_device_mapping=None):
+    def spawn(self, context, instance, network_info,
+              block_device_mapping=None):
         """Launch a VM for the specified instance"""
         raise NotImplementedError()
 
@@ -79,29 +84,36 @@ class ComputeDriver(object):
         warning in that case.
 
         """
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def reboot(self, instance, network_info):
         """Reboot specified VM"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def snapshot_instance(self, context, instance_id, image_id):
         raise NotImplementedError()
 
     def get_console_pool_info(self, console_type):
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def get_console_output(self, instance):
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def get_ajax_console(self, instance):
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def get_diagnostics(self, instance):
         """Return data about VM diagnostics"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def get_host_ip_addr(self):
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def attach_volume(self, context, instance_id, volume_id, mountpoint):
@@ -116,43 +128,50 @@ class ComputeDriver(object):
     def migrate_disk_and_power_off(self, instance, dest):
         """Transfers the VHD of a running instance to another host, then shuts
         off the instance copies over the COW disk"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
-    def snapshot(self, instance, image_id):
+    def snapshot(self, context, instance, image_id):
         """Create snapshot from a running VM instance."""
         raise NotImplementedError()
 
-    def finish_migration(self, instance, disk_info, network_info,
+    def finish_migration(self, context, instance, disk_info, network_info,
                          resize_instance):
         """Completes a resize, turning on the migrated instance"""
         raise NotImplementedError()
 
     def revert_migration(self, instance):
         """Reverts a resize, powering back on the instance"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def pause(self, instance, callback):
         """Pause VM instance"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def unpause(self, instance, callback):
         """Unpause paused VM instance"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def suspend(self, instance, callback):
         """suspend the specified instance"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def resume(self, instance, callback):
         """resume the specified instance"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
-    def rescue(self, instance, callback, network_info):
+    def rescue(self, context, instance, callback, network_info):
         """Rescue the specified instance"""
         raise NotImplementedError()
 
     def unrescue(self, instance, callback, network_info):
         """Unrescue the specified instance"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def update_available_resource(self, ctxt, host):
@@ -165,6 +184,7 @@ class ComputeDriver(object):
         :param host: hostname that compute manager is currently running
 
         """
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def live_migration(self, ctxt, instance_ref, dest,
@@ -184,20 +204,25 @@ class ComputeDriver(object):
             expected nova.compute.manager.recover_live_migration.
 
         """
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def refresh_security_group_rules(self, security_group_id):
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def refresh_security_group_members(self, security_group_id):
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def refresh_provider_fw_rules(self, security_group_id):
         """See: nova/virt/fake.py for docs."""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def reset_network(self, instance):
         """reset networking for specified instance"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         pass
 
     def ensure_filtering_rules_for_instance(self, instance_ref):
@@ -223,10 +248,12 @@ class ComputeDriver(object):
         :params instance_ref: nova.db.sqlalchemy.models.Instance object
 
         """
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def unfilter_instance(self, instance, network_info):
         """Stop filtering instance"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def set_admin_password(self, context, instance_id, new_pass=None):
@@ -237,24 +264,30 @@ class ComputeDriver(object):
         """Create a file on the VM instance. The file path and contents
         should be base64-encoded.
         """
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def agent_update(self, instance, url, md5hash):
         """Update agent on the VM instance."""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def inject_network_info(self, instance, nw_info):
         """inject network info for specified instance"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         pass
 
     def poll_rescued_instances(self, timeout):
         """Poll for rescued instances"""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def set_host_enabled(self, host, enabled):
         """Sets the specified host's ability to accept new instances."""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
     def plug_vifs(self, instance, network_info):
         """Plugs in VIFs to networks."""
+        # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
diff --git a/nova/virt/fake.py b/nova/virt/fake.py
index 2898f23a4..80abcc644 100644
--- a/nova/virt/fake.py
+++ b/nova/virt/fake.py
@@ -129,7 +129,8 @@ class FakeConnection(driver.ComputeDriver):
             info_list.append(self._map_to_instance_info(instance))
         return info_list
 
-    def spawn(self, instance, network_info, block_device_mapping=None):
+    def spawn(self, context, instance, network_info,
+              block_device_mapping=None):
         """
         Create a new instance/VM/domain on the virtualization platform.
 
@@ -153,7 +154,7 @@ class FakeConnection(driver.ComputeDriver):
         fake_instance = FakeInstance(name, state)
         self.instances[name] = fake_instance
 
-    def snapshot(self, instance, name):
+    def snapshot(self, context, instance, name):
         """
         Snapshots the specified instance.
 
@@ -240,7 +241,7 @@ class FakeConnection(driver.ComputeDriver):
         """
         pass
 
-    def rescue(self, instance, callback, network_info):
+    def rescue(self, context, instance, callback, network_info):
         """
         Rescue the specified instance.
         """
diff --git a/nova/virt/hyperv.py b/nova/virt/hyperv.py
index c26fe108b..3428a7fc1 100644
--- a/nova/virt/hyperv.py
+++ b/nova/virt/hyperv.py
@@ -138,7 +138,8 @@ class HyperVConnection(driver.ComputeDriver):
 
         return instance_infos
 
-    def spawn(self, instance, network_info, block_device_mapping=None):
+    def spawn(self, context, instance, network_info,
+              block_device_mapping=None):
         """ Create a new VM and start it."""
         vm = self._lookup(instance.name)
         if vm is not None:
diff --git a/nova/virt/images.py b/nova/virt/images.py
index 2e9fca3d6..54c691a40 100644
--- a/nova/virt/images.py
+++ b/nova/virt/images.py
@@ -21,7 +21,6 @@
 Handling of VM disk images.
 """
 
-from nova import context
 from nova import flags
 from nova.image import glance as glance_image_service
 import nova.image
@@ -33,13 +32,12 @@ FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.virt.images')
 
 
-def fetch(image_href, path, _user_id, _project_id):
+def fetch(context, image_href, path, _user_id, _project_id):
     # TODO(vish): Improve context handling and add owner and auth data
     #             when it is added to glance.  Right now there is no
     #             auth checking in glance, so we assume that access was
     #             checked before we got here.
     (image_service, image_id) = nova.image.get_image_service(image_href)
     with open(path, "wb") as image_file:
-        elevated = context.get_admin_context()
-        metadata = image_service.get(elevated, image_id, image_file)
+        metadata = image_service.get(context, image_id, image_file)
     return metadata
diff --git a/nova/virt/libvirt/connection.py b/nova/virt/libvirt/connection.py
index b9b247aab..0acf25d28 100644
--- a/nova/virt/libvirt/connection.py
+++ b/nova/virt/libvirt/connection.py
@@ -54,7 +54,7 @@ from xml.etree import ElementTree
 from eventlet import greenthread
 from eventlet import tpool
 
-from nova import context
+from nova import context as nova_context
 from nova import db
 from nova import exception
 from nova import flags
@@ -174,7 +174,7 @@ class LibvirtConnection(driver.ComputeDriver):
 
     def init_host(self, host):
         # Adopt existing VM's running here
-        ctxt = context.get_admin_context()
+        ctxt = nova_context.get_admin_context()
         for instance in db.instance_get_all_by_host(ctxt, host):
             try:
                 LOG.debug(_('Checking state of %s'), instance['name'])
@@ -396,7 +396,7 @@ class LibvirtConnection(driver.ComputeDriver):
         virt_dom.detachDevice(xml)
 
     @exception.wrap_exception()
-    def snapshot(self, instance, image_href):
+    def snapshot(self, context, instance, image_href):
         """Create snapshot from a running VM instance.
 
         This command only works with qemu 0.14+, the qemu_img flag is
@@ -405,14 +405,13 @@ class LibvirtConnection(driver.ComputeDriver):
 
         """
         virt_dom = self._lookup_by_name(instance['name'])
-        elevated = context.get_admin_context()
 
         (image_service, image_id) = nova.image.get_image_service(
             instance['image_ref'])
-        base = image_service.show(elevated, image_id)
+        base = image_service.show(context, image_id)
         (snapshot_image_service, snapshot_image_id) = \
             nova.image.get_image_service(image_href)
-        snapshot = snapshot_image_service.show(elevated, snapshot_image_id)
+        snapshot = snapshot_image_service.show(context, snapshot_image_id)
 
         metadata = {'disk_format': base['disk_format'],
                     'container_format': base['container_format'],
@@ -463,7 +462,7 @@ class LibvirtConnection(driver.ComputeDriver):
 
         # Upload that image to the image service
         with open(out_path) as image_file:
-            image_service.update(elevated,
+            image_service.update(context,
                                  image_href,
                                  metadata,
                                  image_file)
@@ -538,7 +537,7 @@ class LibvirtConnection(driver.ComputeDriver):
         dom.create()
 
     @exception.wrap_exception()
-    def rescue(self, instance, callback, network_info):
+    def rescue(self, context, instance, callback, network_info):
         """Loads a VM using rescue images.
 
         A rescue is normally performed when something goes wrong with the
@@ -553,7 +552,7 @@ class LibvirtConnection(driver.ComputeDriver):
         rescue_images = {'image_id': FLAGS.rescue_image_id,
                          'kernel_id': FLAGS.rescue_kernel_id,
                          'ramdisk_id': FLAGS.rescue_ramdisk_id}
-        self._create_image(instance, xml, '.rescue', rescue_images)
+        self._create_image(context, instance, xml, '.rescue', rescue_images)
         self._create_new_domain(xml)
 
         def _wait_for_rescue():
@@ -592,13 +591,14 @@ class LibvirtConnection(driver.ComputeDriver):
     # NOTE(ilyaalekseyev): Implementation like in multinics
     # for xenapi(tr3buchet)
     @exception.wrap_exception()
-    def spawn(self, instance, network_info, block_device_mapping=None):
+    def spawn(self, context, instance, network_info,
+              block_device_mapping=None):
         xml = self.to_xml(instance, False, network_info=network_info,
                           block_device_mapping=block_device_mapping)
         block_device_mapping = block_device_mapping or []
         self.firewall_driver.setup_basic_filtering(instance, network_info)
         self.firewall_driver.prepare_instance_filter(instance, network_info)
-        self._create_image(instance, xml, network_info=network_info,
+        self._create_image(context, instance, xml, network_info=network_info,
                            block_device_mapping=block_device_mapping)
         domain = self._create_new_domain(xml)
         LOG.debug(_("instance %s: is running"), instance['name'])
@@ -769,9 +769,10 @@ class LibvirtConnection(driver.ComputeDriver):
             else:
                 utils.execute('cp', base, target)
 
-    def _fetch_image(self, target, image_id, user_id, project_id, size=None):
+    def _fetch_image(self, context, target, image_id, user_id, project_id,
+                     size=None):
         """Grab image and optionally attempt to resize it"""
-        images.fetch(image_id, target, user_id, project_id)
+        images.fetch(context, image_id, target, user_id, project_id)
         if size:
             disk.extend(target, size)
 
@@ -780,8 +781,9 @@ class LibvirtConnection(driver.ComputeDriver):
         utils.execute('truncate', target, '-s', "%dG" % local_gb)
         # TODO(vish): should we format disk by default?
 
-    def _create_image(self, inst, libvirt_xml, suffix='', disk_images=None,
-                        network_info=None, block_device_mapping=None):
+    def _create_image(self, context, inst, libvirt_xml, suffix='',
+                      disk_images=None, network_info=None,
+                      block_device_mapping=None):
         block_device_mapping = block_device_mapping or []
 
         if not suffix:
@@ -817,6 +819,7 @@ class LibvirtConnection(driver.ComputeDriver):
         if disk_images['kernel_id']:
             fname = '%08x' % int(disk_images['kernel_id'])
             self._cache_image(fn=self._fetch_image,
+                              context=context,
                               target=basepath('kernel'),
                               fname=fname,
                               image_id=disk_images['kernel_id'],
@@ -825,6 +828,7 @@ class LibvirtConnection(driver.ComputeDriver):
             if disk_images['ramdisk_id']:
                 fname = '%08x' % int(disk_images['ramdisk_id'])
                 self._cache_image(fn=self._fetch_image,
+                                  context=context,
                                   target=basepath('ramdisk'),
                                   fname=fname,
                                   image_id=disk_images['ramdisk_id'],
@@ -843,6 +847,7 @@ class LibvirtConnection(driver.ComputeDriver):
         if not self._volume_in_mapping(self.root_mount_device,
                                        block_device_mapping):
             self._cache_image(fn=self._fetch_image,
+                              context=context,
                               target=basepath('disk'),
                               fname=root_fname,
                               cow=FLAGS.use_cow_images,
@@ -879,7 +884,7 @@ class LibvirtConnection(driver.ComputeDriver):
         ifc_template = open(FLAGS.injected_network_template).read()
         ifc_num = -1
         have_injected_networks = False
-        admin_context = context.get_admin_context()
+        admin_context = nova_context.get_admin_context()
         for (network_ref, mapping) in network_info:
             ifc_num += 1
 
diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py
index 1ee8fa1c0..07a6ba6ab 100644
--- a/nova/virt/vmwareapi/vmops.py
+++ b/nova/virt/vmwareapi/vmops.py
@@ -26,7 +26,7 @@ import urllib
 import urllib2

 import uuid

 

-from nova import context

+from nova import context as nova_context

 from nova import db

 from nova import exception

 from nova import flags

@@ -89,7 +89,7 @@ class VMWareVMOps(object):
         LOG.debug(_("Got total of %s instances") % str(len(lst_vm_names)))

         return lst_vm_names

 

-    def spawn(self, instance, network_info):

+    def spawn(self, context, instance, network_info):

         """

         Creates a VM instance.

 

@@ -111,7 +111,7 @@ class VMWareVMOps(object):
         client_factory = self._session._get_vim().client.factory

         service_content = self._session._get_vim().get_service_content()

 

-        network = db.network_get_by_instance(context.get_admin_context(),

+        network = db.network_get_by_instance(nova_context.get_admin_context(),

                                             instance['id'])

 

         net_name = network['bridge']

@@ -329,7 +329,7 @@ class VMWareVMOps(object):
             LOG.debug(_("Powered on the VM instance %s") % instance.name)

         _power_on_vm()

 

-    def snapshot(self, instance, snapshot_name):

+    def snapshot(self, context, instance, snapshot_name):

         """

         Create snapshot from a running VM instance.

         Steps followed are:

@@ -721,11 +721,11 @@ class VMWareVMOps(object):
         Set the machine id of the VM for guest tools to pick up and change

         the IP.

         """

-        admin_context = context.get_admin_context()

+        admin_context = nova_context.get_admin_context()

         vm_ref = self._get_vm_ref_from_the_name(instance.name)

         if vm_ref is None:

             raise exception.InstanceNotFound(instance_id=instance.id)

-        network = db.network_get_by_instance(context.get_admin_context(),

+        network = db.network_get_by_instance(nova_context.get_admin_context(),

                                             instance['id'])

         mac_address = None

         if instance['mac_addresses']:

diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py
index ce57847b2..3d209fa99 100644
--- a/nova/virt/vmwareapi_conn.py
+++ b/nova/virt/vmwareapi_conn.py
@@ -124,13 +124,14 @@ class VMWareESXConnection(driver.ComputeDriver):
         """List VM instances."""

         return self._vmops.list_instances()

 

-    def spawn(self, instance, network_info, block_device_mapping=None):

+    def spawn(self, context, instance, network_info,

+              block_device_mapping=None):

         """Create VM instance."""

-        self._vmops.spawn(instance, network_info)

+        self._vmops.spawn(context, instance, network_info)

 

-    def snapshot(self, instance, name):

+    def snapshot(self, context, instance, name):

         """Create snapshot from a running VM instance."""

-        self._vmops.snapshot(instance, name)

+        self._vmops.snapshot(context, instance, name)

 

     def reboot(self, instance, network_info):

         """Reboot VM instance."""

diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index 60ef0df43..63bc191cf 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -342,7 +342,7 @@ class VMHelper(HelperBase):
         return os.path.join(FLAGS.xenapi_sr_base_path, sr_uuid)
 
     @classmethod
-    def upload_image(cls, session, instance, vdi_uuids, image_id):
+    def upload_image(cls, context, session, instance, vdi_uuids, image_id):
         """ Requests that the Glance plugin bundle the specified VDIs and
         push them into Glance using the specified human-friendly name.
         """
@@ -360,29 +360,30 @@ class VMHelper(HelperBase):
                   'glance_host': glance_host,
                   'glance_port': glance_port,
                   'sr_path': cls.get_sr_path(session),
-                  'os_type': os_type}
+                  'os_type': os_type,
+                  'auth_token': getattr(context, 'auth_token', None)}
 
         kwargs = {'params': pickle.dumps(params)}
         task = session.async_call_plugin('glance', 'upload_vhd', kwargs)
         session.wait_for_task(task, instance.id)
 
     @classmethod
-    def fetch_image(cls, session, instance_id, image, user_id, project_id,
-                    image_type):
+    def fetch_image(cls, context, session, instance_id, image, user_id,
+                    project_id, image_type):
         """Fetch image from glance based on image type.
 
         Returns: A single filename if image_type is KERNEL or RAMDISK
                  A list of dictionaries that describe VDIs, otherwise
         """
         if image_type == ImageType.DISK_VHD:
-            return cls._fetch_image_glance_vhd(
+            return cls._fetch_image_glance_vhd(context,
                 session, instance_id, image, image_type)
         else:
-            return cls._fetch_image_glance_disk(
+            return cls._fetch_image_glance_disk(context,
                 session, instance_id, image, image_type)
 
     @classmethod
-    def _fetch_image_glance_vhd(cls, session, instance_id, image,
+    def _fetch_image_glance_vhd(cls, context, session, instance_id, image,
                                 image_type):
         """Tell glance to download an image and put the VHDs into the SR
 
@@ -404,7 +405,8 @@ class VMHelper(HelperBase):
                   'glance_host': glance_host,
                   'glance_port': glance_port,
                   'uuid_stack': uuid_stack,
-                  'sr_path': cls.get_sr_path(session)}
+                  'sr_path': cls.get_sr_path(session),
+                  'auth_token': getattr(context, 'auth_token', None)}
 
         kwargs = {'params': pickle.dumps(params)}
         task = session.async_call_plugin('glance', 'download_vhd', kwargs)
@@ -430,7 +432,7 @@ class VMHelper(HelperBase):
         return vdis
 
     @classmethod
-    def _fetch_image_glance_disk(cls, session, instance_id, image,
+    def _fetch_image_glance_disk(cls, context, session, instance_id, image,
                                  image_type):
         """Fetch the image from Glance
 
@@ -450,6 +452,7 @@ class VMHelper(HelperBase):
         sr_ref = safe_find_sr(session)
 
         glance_client, image_id = nova.image.get_glance_client(image)
+        glance_client.set_auth_token(getattr(context, 'auth_token', None))
         meta, image_file = glance_client.get_image(image_id)
         virtual_size = int(meta['size'])
         vdi_size = virtual_size
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 7e02e1def..b3b812a48 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -30,7 +30,7 @@ import sys
 import time
 import uuid
 
-from nova import context
+from nova import context as nova_context
 from nova import db
 from nova import exception
 from nova import flags
@@ -113,11 +113,11 @@ class VMOps(object):
         vm_ref = VMHelper.lookup(self._session, instance.name)
         self._start(instance, vm_ref)
 
-    def finish_migration(self, instance, disk_info, network_info,
+    def finish_migration(self, context, instance, disk_info, network_info,
                       resize_instance):
         vdi_uuid = self.link_disks(instance, disk_info['base_copy'],
                 disk_info['cow'])
-        vm_ref = self._create_vm(instance,
+        vm_ref = self._create_vm(context, instance,
                                  [dict(vdi_type='os', vdi_uuid=vdi_uuid)],
                                  network_info)
         if resize_instance:
@@ -134,19 +134,19 @@ class VMOps(object):
         LOG.debug(_("Starting instance %s"), instance.name)
         self._session.call_xenapi('VM.start', vm_ref, False, False)
 
-    def _create_disks(self, instance):
+    def _create_disks(self, context, instance):
         disk_image_type = VMHelper.determine_disk_image_type(instance)
-        vdis = VMHelper.fetch_image(self._session,
+        vdis = VMHelper.fetch_image(context, self._session,
                 instance.id, instance.image_ref,
                 instance.user_id, instance.project_id,
                 disk_image_type)
         return vdis
 
-    def spawn(self, instance, network_info):
+    def spawn(self, context, instance, network_info):
         vdis = None
         try:
-            vdis = self._create_disks(instance)
-            vm_ref = self._create_vm(instance, vdis, network_info)
+            vdis = self._create_disks(context, instance)
+            vm_ref = self._create_vm(context, instance, vdis, network_info)
             self._spawn(instance, vm_ref)
         except (self.XenAPI.Failure, OSError, IOError) as spawn_error:
             LOG.exception(_("instance %s: Failed to spawn"),
@@ -156,11 +156,11 @@ class VMOps(object):
             self._handle_spawn_error(vdis, spawn_error)
             raise spawn_error
 
-    def spawn_rescue(self, instance):
+    def spawn_rescue(self, context, instance, network_info):
         """Spawn a rescue instance."""
-        self.spawn(instance)
+        self.spawn(context, instance, network_info)
 
-    def _create_vm(self, instance, vdis, network_info):
+    def _create_vm(self, context, instance, vdis, network_info):
         """Create VM instance."""
         instance_name = instance.name
         vm_ref = VMHelper.lookup(self._session, instance_name)
@@ -171,7 +171,7 @@ class VMOps(object):
         if not VMHelper.ensure_free_mem(self._session, instance):
             LOG.exception(_('instance %(instance_name)s: not enough free '
                           'memory') % locals())
-            db.instance_set_state(context.get_admin_context(),
+            db.instance_set_state(nova_context.get_admin_context(),
                                   instance['id'],
                                   power_state.SHUTDOWN)
             return
@@ -181,12 +181,12 @@ class VMOps(object):
         ramdisk = None
         try:
             if instance.kernel_id:
-                kernel = VMHelper.fetch_image(self._session, instance.id,
-                        instance.kernel_id, instance.user_id,
+                kernel = VMHelper.fetch_image(context, self._session,
+                        instance.id, instance.kernel_id, instance.user_id,
                         instance.project_id, ImageType.KERNEL)[0]
             if instance.ramdisk_id:
-                ramdisk = VMHelper.fetch_image(self._session, instance.id,
-                        instance.kernel_id, instance.user_id,
+                ramdisk = VMHelper.fetch_image(context, self._session,
+                        instance.id, instance.kernel_id, instance.user_id,
                         instance.project_id, ImageType.RAMDISK)[0]
             # Create the VM ref and attach the first disk
             first_vdi_ref = self._session.call_xenapi('VDI.get_by_uuid',
@@ -206,7 +206,7 @@ class VMOps(object):
 
             if instance.vm_mode != vm_mode:
                 # Update database with normalized (or determined) value
-                db.instance_update(context.get_admin_context(),
+                db.instance_update(nova_context.get_admin_context(),
                                    instance['id'], {'vm_mode': vm_mode})
             vm_ref = VMHelper.create_vm(self._session, instance,
                     kernel and kernel.get('file', None) or None,
@@ -268,7 +268,7 @@ class VMOps(object):
         LOG.info(_('Spawning VM %(instance_name)s created %(vm_ref)s.')
                  % locals())
 
-        ctx = context.get_admin_context()
+        ctx = nova_context.get_admin_context()
         agent_build = db.agent_build_get_by_triple(ctx, 'xen',
                               instance.os_type, instance.architecture)
         if agent_build:
@@ -412,7 +412,7 @@ class VMOps(object):
 
         # if instance_or_vm is an int/long it must be instance id
         elif isinstance(instance_or_vm, (int, long)):
-            ctx = context.get_admin_context()
+            ctx = nova_context.get_admin_context()
             instance_obj = db.instance_get(ctx, instance_or_vm)
             instance_name = instance_obj.name
         else:
@@ -437,9 +437,10 @@ class VMOps(object):
             vm,
             "start")
 
-    def snapshot(self, instance, image_id):
+    def snapshot(self, context, instance, image_id):
         """Create snapshot from a running VM instance.
 
+        :param context: request context
         :param instance: instance to be snapshotted
         :param image_id: id of image to upload to
 
@@ -464,7 +465,7 @@ class VMOps(object):
         try:
             template_vm_ref, template_vdi_uuids = self._get_snapshot(instance)
             # call plugin to ship snapshot off to glance
-            VMHelper.upload_image(
+            VMHelper.upload_image(context,
                     self._session, instance, template_vdi_uuids, image_id)
         finally:
             if template_vm_ref:
@@ -685,7 +686,7 @@ class VMOps(object):
         # Successful return code from password is '0'
         if resp_dict['returncode'] != '0':
             raise RuntimeError(resp_dict['message'])
-        db.instance_update(context.get_admin_context(),
+        db.instance_update(nova_context.get_admin_context(),
                                   instance['id'],
                                   dict(admin_pass=new_pass))
         return resp_dict['message']
@@ -913,7 +914,7 @@ class VMOps(object):
                                          True)
         self._wait_with_callback(instance.id, task, callback)
 
-    def rescue(self, instance, callback):
+    def rescue(self, context, instance, callback, network_info):
         """Rescue the specified instance.
 
             - shutdown the instance VM.
@@ -931,7 +932,7 @@ class VMOps(object):
         self._shutdown(instance, vm_ref)
         self._acquire_bootlock(vm_ref)
         instance._rescue = True
-        self.spawn_rescue(instance)
+        self.spawn_rescue(context, instance, network_info)
         rescue_vm_ref = VMHelper.lookup(self._session, instance.name)
 
         vbd_ref = self._session.get_xenapi().VM.get_VBDs(vm_ref)[0]
diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py
index a3d0abf9f..39afbd650 100644
--- a/nova/virt/xenapi_conn.py
+++ b/nova/virt/xenapi_conn.py
@@ -184,23 +184,24 @@ class XenAPIConnection(driver.ComputeDriver):
     def list_instances_detail(self):
         return self._vmops.list_instances_detail()
 
-    def spawn(self, instance, network_info, block_device_mapping=None):
+    def spawn(self, context, instance, network_info,
+              block_device_mapping=None):
         """Create VM instance"""
-        self._vmops.spawn(instance, network_info)
+        self._vmops.spawn(context, instance, network_info)
 
     def revert_migration(self, instance):
         """Reverts a resize, powering back on the instance"""
         self._vmops.revert_resize(instance)
 
-    def finish_migration(self, instance, disk_info, network_info,
+    def finish_migration(self, context, instance, disk_info, network_info,
                          resize_instance=False):
         """Completes a resize, turning on the migrated instance"""
-        self._vmops.finish_migration(instance, disk_info, network_info,
-                                  resize_instance)
+        self._vmops.finish_migration(context, instance, disk_info,
+                                     network_info, resize_instance)
 
-    def snapshot(self, instance, image_id):
+    def snapshot(self, context, instance, image_id):
         """ Create snapshot from a running VM instance """
-        self._vmops.snapshot(instance, image_id)
+        self._vmops.snapshot(context, instance, image_id)
 
     def reboot(self, instance, network_info):
         """Reboot VM instance"""
@@ -241,9 +242,9 @@ class XenAPIConnection(driver.ComputeDriver):
         """resume the specified instance"""
         self._vmops.resume(instance, callback)
 
-    def rescue(self, instance, callback, network_info):
+    def rescue(self, context, instance, callback, network_info):
         """Rescue the specified instance"""
-        self._vmops.rescue(instance, callback)
+        self._vmops.rescue(context, instance, callback, network_info)
 
     def unrescue(self, instance, callback, network_info):
         """Unrescue the specified instance"""
diff --git a/plugins/xenserver/xenapi/etc/xapi.d/plugins/glance b/plugins/xenserver/xenapi/etc/xapi.d/plugins/glance
index fbe080b22..86e837849 100755
--- a/plugins/xenserver/xenapi/etc/xapi.d/plugins/glance
+++ b/plugins/xenserver/xenapi/etc/xapi.d/plugins/glance
@@ -67,12 +67,17 @@ def _copy_kernel_vdi(dest, copy_args):
 
 
 def _download_tarball(sr_path, staging_path, image_id, glance_host,
-                      glance_port):
+                      glance_port, auth_token):
     """Download the tarball image from Glance and extract it into the staging
     area.
     """
+    # Build request headers
+    headers = {}
+    if auth_token:
+        headers['x-auth-token'] = auth_token
+
     conn = httplib.HTTPConnection(glance_host, glance_port)
-    conn.request('GET', '/v1/images/%s' % image_id)
+    conn.request('GET', '/v1/images/%s' % image_id, headers=headers)
     resp = conn.getresponse()
     if resp.status == httplib.NOT_FOUND:
         raise Exception("Image '%s' not found in Glance" % image_id)
@@ -236,7 +241,8 @@ def _prepare_staging_area_for_upload(sr_path, staging_path, vdi_uuids):
         os.link(source, link_name)
 
 
-def _upload_tarball(staging_path, image_id, glance_host, glance_port, os_type):
+def _upload_tarball(staging_path, image_id, glance_host, glance_port, os_type,
+                    auth_token):
     """
     Create a tarball of the image and then stream that into Glance
     using chunked-transfer-encoded HTTP.
@@ -263,6 +269,10 @@ def _upload_tarball(staging_path, image_id, glance_host, glance_port, os_type):
         'x-image-meta-container-format': 'ovf',
         'x-image-meta-property-os-type': os_type}
 
+    # If we have an auth_token, set an x-auth-token header
+    if auth_token:
+        headers['x-auth-token'] = auth_token
+
     for header, value in headers.iteritems():
         conn.putheader(header, value)
     conn.endheaders()
@@ -364,11 +374,12 @@ def download_vhd(session, args):
     glance_port = params["glance_port"]
     uuid_stack = params["uuid_stack"]
     sr_path = params["sr_path"]
+    auth_token = params["auth_token"]
 
     staging_path = _make_staging_area(sr_path)
     try:
         _download_tarball(sr_path, staging_path, image_id, glance_host,
-                          glance_port)
+                          glance_port, auth_token)
         # Right now, it's easier to return a single string via XenAPI,
         # so we'll json encode the list of VHDs.
         return json.dumps(_import_vhds(sr_path, staging_path, uuid_stack))
@@ -386,12 +397,13 @@ def upload_vhd(session, args):
     glance_port = params["glance_port"]
     sr_path = params["sr_path"]
     os_type = params["os_type"]
+    auth_token = params["auth_token"]
 
     staging_path = _make_staging_area(sr_path)
     try:
         _prepare_staging_area_for_upload(sr_path, staging_path, vdi_uuids)
         _upload_tarball(staging_path, image_id, glance_host, glance_port,
-                        os_type)
+                        os_type, auth_token)
     finally:
         _cleanup_staging_area(staging_path)