merge trunk

17 files changed, 967 insertions, 102 deletions

diff --git a/contrib/nova.sh b/contrib/nova.sh
index 55dfb971c..d7d34dcbd 100755
--- a/contrib/nova.sh
+++ b/contrib/nova.sh
@@ -18,6 +18,9 @@ if [ ! -n "$HOST_IP" ]; then
 fi
 
 USE_MYSQL=${USE_MYSQL:-0}
+INTERFACE=${INTERFACE:-eth0}
+FLOATING_RANGE=${FLOATING_RANGE:-10.6.0.0/27}
+FIXED_RANGE=${FIXED_RANGE:-10.0.0.0/24}
 MYSQL_PASS=${MYSQL_PASS:-nova}
 TEST=${TEST:-0}
 USE_LDAP=${USE_LDAP:-0}
@@ -72,11 +75,14 @@ if [ "$CMD" == "install" ]; then
     sudo modprobe kvm
     sudo /etc/init.d/libvirt-bin restart
     sudo modprobe nbd
-    sudo apt-get install -y python-twisted python-sqlalchemy python-mox python-greenlet python-carrot
-    sudo apt-get install -y python-migrate python-eventlet python-gflags python-ipy python-tempita
-    sudo apt-get install -y python-libvirt python-libxml2 python-routes python-cheetah
-    sudo apt-get install -y python-netaddr python-paste python-pastedeploy python-glance
-    sudo apt-get install -y python-multiprocessing
+    sudo apt-get install -y python-twisted python-mox python-ipy python-paste
+    sudo apt-get install -y python-migrate python-gflags python-greenlet
+    sudo apt-get install -y python-libvirt python-libxml2 python-routes
+    sudo apt-get install -y python-netaddr python-pastedeploy python-eventlet
+    sudo apt-get install -y python-novaclient python-glance python-cheetah
+    sudo apt-get install -y python-carrot python-tempita python-sqlalchemy
+    sudo apt-get install -y python-suds
+
 
     if [ "$USE_IPV6" == 1 ]; then
         sudo apt-get install -y radvd
@@ -105,7 +111,7 @@ function screen_it {
     screen -S nova -p $1 -X stuff "$2$NL"
 }
 
-if [ "$CMD" == "run" ]; then
+if [ "$CMD" == "run" ] || [ "$CMD" == "run_detached" ]; then
 
   cat >$NOVA_DIR/bin/nova.conf << NOVA_CONF_EOF
 --verbose
@@ -113,6 +119,8 @@ if [ "$CMD" == "run" ]; then
 --dhcpbridge_flagfile=$NOVA_DIR/bin/nova.conf
 --network_manager=nova.network.manager.$NET_MAN
 --my_ip=$HOST_IP
+--public_interface=$INTERFACE
+--vlan_interface=$INTERFACE
 --sql_connection=$SQL_CONN
 --auth_driver=nova.auth.$AUTH
 --libvirt_type=$LIBVIRT_TYPE
@@ -168,10 +176,13 @@ NOVA_CONF_EOF
     # create a project called 'admin' with project manager of 'admin'
     $NOVA_DIR/bin/nova-manage project create admin admin
     # create a small network
-    $NOVA_DIR/bin/nova-manage network create 10.0.0.0/8 1 32
+    $NOVA_DIR/bin/nova-manage network create $FIXED_RANGE 1 32
 
     # create some floating ips
-    $NOVA_DIR/bin/nova-manage floating create `hostname` 10.6.0.0/27
+    $NOVA_DIR/bin/nova-manage floating create `hostname` $FLOATING_RANGE
+
+    # convert old images
+    $NOVA_DIR/bin/nova-manage image convert $DIR/images
 
     # nova api crashes if we start it with a regular screen command,
     # so send the start command by forcing text into the window.
@@ -187,8 +198,10 @@ NOVA_CONF_EOF
     $NOVA_DIR/bin/nova-manage project zipfile admin admin $NOVA_DIR/nova.zip
     unzip -o $NOVA_DIR/nova.zip -d $NOVA_DIR/
 
-    screen_it test ". $NOVA_DIR/novarc"
-    screen -S nova -x
+    screen_it test "export PATH=$NOVA_DIR/bin:$PATH;. $NOVA_DIR/novarc"
+    if [ "$CMD" != "run_detached" ]; then
+      screen -S nova -x
+    fi
 fi
 
 if [ "$CMD" == "run" ] || [ "$CMD" == "terminate" ]; then
diff --git a/etc/api-paste.ini b/etc/api-paste.ini
index 35d4a8391..abe8c20c4 100644
--- a/etc/api-paste.ini
+++ b/etc/api-paste.ini
@@ -98,4 +98,4 @@ paste.app_factory = nova.api.openstack:APIRouterV11.factory
 pipeline = faultwrap osversionapp
 
 [app:osversionapp]
-paste.app_factory = nova.api.openstack:Versions.factory
+paste.app_factory = nova.api.openstack.versions:Versions.factory
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index f429a0972..8fabbce8e 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -33,6 +33,7 @@ from nova.api.openstack import backup_schedules
 from nova.api.openstack import consoles
 from nova.api.openstack import flavors
 from nova.api.openstack import images
+from nova.api.openstack import image_metadata
 from nova.api.openstack import limits
 from nova.api.openstack import servers
 from nova.api.openstack import server_metadata
@@ -118,9 +119,6 @@ class APIRouter(wsgi.Router):
         mapper.resource("image", "images", controller=images.Controller(),
                         collection={'detail': 'GET'})
 
-        mapper.resource("flavor", "flavors", controller=flavors.Controller(),
-                        collection={'detail': 'GET'})
-
         mapper.resource("shared_ip_group", "shared_ip_groups",
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.Controller())
@@ -139,6 +137,10 @@ class APIRouterV10(APIRouter):
                         collection={'detail': 'GET'},
                         member=self.server_members)
 
+        mapper.resource("flavor", "flavors",
+                        controller=flavors.ControllerV10(),
+                        collection={'detail': 'GET'})
+
 
 class APIRouterV11(APIRouter):
     """Define routes specific to OpenStack API V1.1."""
@@ -149,25 +151,17 @@ class APIRouterV11(APIRouter):
                         controller=servers.ControllerV11(),
                         collection={'detail': 'GET'},
                         member=self.server_members)
+
+        mapper.resource("image_meta", "meta",
+                        controller=image_metadata.Controller(),
+                        parent_resource=dict(member_name='image',
+                        collection_name='images'))
+
         mapper.resource("server_meta", "meta",
                         controller=server_metadata.Controller(),
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
 
-
-class Versions(wsgi.Application):
-    @webob.dec.wsgify(RequestClass=wsgi.Request)
-    def __call__(self, req):
-        """Respond to a request for all OpenStack API versions."""
-        response = {
-            "versions": [
-                dict(status="DEPRECATED", id="v1.0"),
-                dict(status="CURRENT", id="v1.1"),
-            ],
-        }
-        metadata = {
-            "application/xml": {
-                "attributes": dict(version=["status", "id"])}}
-
-        content_type = req.best_match_content_type()
-        return wsgi.Serializer(metadata).serialize(response, content_type)
+        mapper.resource("flavor", "flavors",
+                        controller=flavors.ControllerV11(),
+                        collection={'detail': 'GET'})
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index c99b945fb..5b99b5a6f 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -15,16 +15,12 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from webob import exc
+import webob
 
 from nova import db
-from nova import context
-from nova.api.openstack import faults
-from nova.api.openstack import common
-from nova.compute import instance_types
-from nova.api.openstack.views import flavors as flavors_views
+from nova import exception
 from nova import wsgi
-import nova.api.openstack
+from nova.api.openstack import views
 
 
 class Controller(wsgi.Controller):
@@ -33,33 +29,50 @@ class Controller(wsgi.Controller):
     _serialization_metadata = {
         'application/xml': {
             "attributes": {
-                "flavor": ["id", "name", "ram", "disk"]}}}
+                "flavor": ["id", "name", "ram", "disk"],
+                "link": ["rel", "type", "href"],
+            }
+        }
+    }
 
     def index(self, req):
         """Return all flavors in brief."""
-        return dict(flavors=[dict(id=flavor['id'], name=flavor['name'])
-                             for flavor in self.detail(req)['flavors']])
+        items = self._get_flavors(req, is_detail=False)
+        return dict(flavors=items)
 
     def detail(self, req):
         """Return all flavors in detail."""
-        items = [self.show(req, id)['flavor'] for id in self._all_ids(req)]
+        items = self._get_flavors(req, is_detail=True)
         return dict(flavors=items)
 
+    def _get_flavors(self, req, is_detail=True):
+        """Helper function that returns a list of flavor dicts."""
+        ctxt = req.environ['nova.context']
+        flavors = db.api.instance_type_get_all(ctxt)
+        builder = self._get_view_builder(req)
+        items = [builder.build(flavor, is_detail=is_detail)
+                 for flavor in flavors.values()]
+        return items
+
     def show(self, req, id):
         """Return data about the given flavor id."""
-        ctxt = req.environ['nova.context']
-        flavor = db.api.instance_type_get_by_flavor_id(ctxt, id)
-        values = {
-            "id": flavor["flavorid"],
-            "name": flavor["name"],
-            "ram": flavor["memory_mb"],
-            "disk": flavor["local_gb"],
-        }
+        try:
+            ctxt = req.environ['nova.context']
+            flavor = db.api.instance_type_get_by_flavor_id(ctxt, id)
+        except exception.NotFound:
+            return webob.exc.HTTPNotFound()
+
+        builder = self._get_view_builder(req)
+        values = builder.build(flavor, is_detail=True)
         return dict(flavor=values)
 
-    def _all_ids(self, req):
-        """Return the list of all flavorids."""
-        ctxt = req.environ['nova.context']
-        inst_types = db.api.instance_type_get_all(ctxt)
-        flavor_ids = [inst_types[i]['flavorid'] for i in inst_types.keys()]
-        return sorted(flavor_ids)
+
+class ControllerV10(Controller):
+    def _get_view_builder(self, req):
+        return views.flavors.ViewBuilder()
+
+
+class ControllerV11(Controller):
+    def _get_view_builder(self, req):
+        base_url = req.application_url
+        return views.flavors.ViewBuilderV11(base_url)
diff --git a/nova/api/openstack/image_metadata.py b/nova/api/openstack/image_metadata.py
new file mode 100644
index 000000000..c9d6ac532
--- /dev/null
+++ b/nova/api/openstack/image_metadata.py
@@ -0,0 +1,93 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from webob import exc
+
+from nova import flags
+from nova import utils
+from nova import wsgi
+from nova.api.openstack import faults
+
+
+FLAGS = flags.FLAGS
+
+
+class Controller(wsgi.Controller):
+    """The image metadata API controller for the Openstack API"""
+
+    def __init__(self):
+        self.image_service = utils.import_object(FLAGS.image_service)
+        super(Controller, self).__init__()
+
+    def _get_metadata(self, context, image_id, image=None):
+        if not image:
+            image = self.image_service.show(context, image_id)
+        metadata = image.get('properties', {})
+        return metadata
+
+    def index(self, req, image_id):
+        """Returns the list of metadata for a given instance"""
+        context = req.environ['nova.context']
+        metadata = self._get_metadata(context, image_id)
+        return dict(metadata=metadata)
+
+    def show(self, req, image_id, id):
+        context = req.environ['nova.context']
+        metadata = self._get_metadata(context, image_id)
+        if id in metadata:
+            return {id: metadata[id]}
+        else:
+            return faults.Fault(exc.HTTPNotFound())
+
+    def create(self, req, image_id):
+        context = req.environ['nova.context']
+        body = self._deserialize(req.body, req.get_content_type())
+        img = self.image_service.show(context, image_id)
+        metadata = self._get_metadata(context, image_id, img)
+        if 'metadata' in body:
+            for key, value in body['metadata'].iteritems():
+                metadata[key] = value
+        img['properties'] = metadata
+        self.image_service.update(context, image_id, img, None)
+        return dict(metadata=metadata)
+
+    def update(self, req, image_id, id):
+        context = req.environ['nova.context']
+        body = self._deserialize(req.body, req.get_content_type())
+        if not id in body:
+            expl = _('Request body and URI mismatch')
+            raise exc.HTTPBadRequest(explanation=expl)
+        if len(body) > 1:
+            expl = _('Request body contains too many items')
+            raise exc.HTTPBadRequest(explanation=expl)
+        img = self.image_service.show(context, image_id)
+        metadata = self._get_metadata(context, image_id, img)
+        metadata[id] = body[id]
+        img['properties'] = metadata
+        self.image_service.update(context, image_id, img, None)
+
+        return req.body
+
+    def delete(self, req, image_id, id):
+        context = req.environ['nova.context']
+        img = self.image_service.show(context, image_id)
+        metadata = self._get_metadata(context, image_id)
+        if not id in metadata:
+            return faults.Fault(exc.HTTPNotFound())
+        metadata.pop(id)
+        img['properties'] = metadata
+        self.image_service.update(context, image_id, img, None)
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 144d14536..75a305a14 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -48,11 +48,15 @@ class Controller(wsgi.Controller):
     """ The Server API controller for the OpenStack API """
 
     _serialization_metadata = {
-        'application/xml': {
+        "application/xml": {
             "attributes": {
                 "server": ["id", "imageId", "name", "flavorId", "hostId",
                            "status", "progress", "adminPass", "flavorRef",
-                           "imageRef"]}}}
+                           "imageRef"],
+                "link": ["rel", "type", "href"],
+            },
+        },
+    }
 
     def __init__(self):
         self.compute_api = compute.API()
@@ -502,33 +506,41 @@ class Controller(wsgi.Controller):
         return dict(actions=actions)
 
     def _get_kernel_ramdisk_from_image(self, req, image_id):
-        """Retrevies kernel and ramdisk IDs from Glance
-
-        Only 'machine' (ami) type use kernel and ramdisk outside of the
-        image.
+        """Fetch an image from the ImageService, then if present, return the
+        associated kernel and ramdisk image IDs.
         """
-        # FIXME(sirp): Since we're retrieving the kernel_id from an
-        # image_property, this means only Glance is supported.
-        # The BaseImageService needs to expose a consistent way of accessing
-        # kernel_id and ramdisk_id
-        image = self._image_service.show(req.environ['nova.context'], image_id)
+        context = req.environ['nova.context']
+        image_meta = self._image_service.show(context, image_id)
+        # NOTE(sirp): extracted to a separate method to aid unit-testing, the
+        # new method doesn't need a request obj or an ImageService stub
+        kernel_id, ramdisk_id = self._do_get_kernel_ramdisk_from_image(
+            image_meta)
+        return kernel_id, ramdisk_id
 
-        if image['status'] != 'active':
+    @staticmethod
+    def  _do_get_kernel_ramdisk_from_image(image_meta):
+        """Given an ImageService image_meta, return kernel and ramdisk image
+        ids if present.
+
+        This is only valid for `ami` style images.
+        """
+        image_id = image_meta['id']
+        if image_meta['status'] != 'active':
             raise exception.Invalid(
                 _("Cannot build from image %(image_id)s, status not active") %
                   locals())
 
-        if image['disk_format'] != 'ami':
+        if image_meta['properties']['disk_format'] != 'ami':
             return None, None
 
         try:
-            kernel_id = image['properties']['kernel_id']
+            kernel_id = image_meta['properties']['kernel_id']
         except KeyError:
             raise exception.NotFound(
                 _("Kernel not found for image %(image_id)s") % locals())
 
         try:
-            ramdisk_id = image['properties']['ramdisk_id']
+            ramdisk_id = image_meta['properties']['ramdisk_id']
         except KeyError:
             raise exception.NotFound(
                 _("Ramdisk not found for image %(image_id)s") % locals())
@@ -572,7 +584,7 @@ class ControllerV11(Controller):
             base_url)
         addresses_builder = nova.api.openstack.views.addresses.ViewBuilderV11()
         return nova.api.openstack.views.servers.ViewBuilderV11(
-            addresses_builder, flavor_builder, image_builder)
+            addresses_builder, flavor_builder, image_builder, base_url)
 
     def _get_addresses_view_builder(self, req):
         return nova.api.openstack.views.addresses.ViewBuilderV11(req)
diff --git a/nova/api/openstack/versions.py b/nova/api/openstack/versions.py
new file mode 100644
index 000000000..33f1dd628
--- /dev/null
+++ b/nova/api/openstack/versions.py
@@ -0,0 +1,54 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import webob.dec
+import webob.exc
+
+from nova import wsgi
+import nova.api.openstack.views.versions
+
+
+class Versions(wsgi.Application):
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def __call__(self, req):
+        """Respond to a request for all OpenStack API versions."""
+        version_objs = [
+            {
+                "id": "v1.1",
+                "status": "CURRENT",
+            },
+            {
+                "id": "v1.0",
+                "status": "DEPRECATED",
+            },
+        ]
+
+        builder = nova.api.openstack.views.versions.get_view_builder(req)
+        versions = [builder.build(version) for version in version_objs]
+        response = dict(versions=versions)
+
+        metadata = {
+            "application/xml": {
+                "attributes": {
+                    "version": ["status", "id"],
+                    "link": ["rel", "href"],
+                }
+            }
+        }
+
+        content_type = req.best_match_content_type()
+        return wsgi.Serializer(metadata).serialize(response, content_type)
diff --git a/nova/api/openstack/views/flavors.py b/nova/api/openstack/views/flavors.py
index 18bd779c0..462890ab2 100644
--- a/nova/api/openstack/views/flavors.py
+++ b/nova/api/openstack/views/flavors.py
@@ -19,16 +19,78 @@ from nova.api.openstack import common
 
 
 class ViewBuilder(object):
-    def __init__(self):
-        pass
 
-    def build(self, flavor_obj):
-        raise NotImplementedError()
+    def build(self, flavor_obj, is_detail=False):
+        """Generic method used to generate a flavor entity."""
+        if is_detail:
+            flavor = self._build_detail(flavor_obj)
+        else:
+            flavor = self._build_simple(flavor_obj)
+
+        self._build_extra(flavor)
+
+        return flavor
+
+    def _build_simple(self, flavor_obj):
+        """Build a minimal representation of a flavor."""
+        return {
+            "id": flavor_obj["flavorid"],
+            "name": flavor_obj["name"],
+        }
+
+    def _build_detail(self, flavor_obj):
+        """Build a more complete representation of a flavor."""
+        simple = self._build_simple(flavor_obj)
+
+        detail = {
+            "ram": flavor_obj["memory_mb"],
+            "disk": flavor_obj["local_gb"],
+        }
+
+        detail.update(simple)
+
+        return detail
+
+    def _build_extra(self, flavor_obj):
+        """Hook for version-specific changes to newly created flavor object."""
+        pass
 
 
 class ViewBuilderV11(ViewBuilder):
+    """Openstack API v1.1 flavors view builder."""
+
     def __init__(self, base_url):
+        """
+        :param base_url: url of the root wsgi application
+        """
         self.base_url = base_url
 
+    def _build_extra(self, flavor_obj):
+        flavor_obj["links"] = self._build_links(flavor_obj)
+
+    def _build_links(self, flavor_obj):
+        """Generate a container of links that refer to the provided flavor."""
+        href = self.generate_href(flavor_obj["id"])
+
+        links = [
+            {
+                "rel": "self",
+                "href": href,
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": href,
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": href,
+            },
+        ]
+
+        return links
+
     def generate_href(self, flavor_id):
+        """Create an url that refers to a specific flavor id."""
         return "%s/flavors/%s" % (self.base_url, flavor_id)
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index f93435198..4e7f62eb3 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -16,6 +16,7 @@
 #    under the License.
 
 import hashlib
+import os
 
 from nova.compute import power_state
 import nova.compute
@@ -41,9 +42,13 @@ class ViewBuilder(object):
     def build(self, inst, is_detail):
         """Return a dict that represenst a server."""
         if is_detail:
-            return self._build_detail(inst)
+            server = self._build_detail(inst)
         else:
-            return self._build_simple(inst)
+            server = self._build_simple(inst)
+
+        self._build_extra(server, inst)
+
+        return server
 
     def _build_simple(self, inst):
         """Return a simple model of a server."""
@@ -97,29 +102,67 @@ class ViewBuilder(object):
         """Return the flavor sub-resource of a server."""
         raise NotImplementedError()
 
+    def _build_extra(self, response, inst):
+        pass
+
 
 class ViewBuilderV10(ViewBuilder):
     """Model an Openstack API V1.0 server response."""
 
     def _build_image(self, response, inst):
-        response['imageId'] = inst['image_id']
+        if 'image_id' in dict(inst):
+            response['imageId'] = inst['image_id']
 
     def _build_flavor(self, response, inst):
-        response['flavorId'] = inst['instance_type']
+        if 'instance_type' in dict(inst):
+            response['flavorId'] = inst['instance_type']
 
 
 class ViewBuilderV11(ViewBuilder):
     """Model an Openstack API V1.0 server response."""
-
-    def __init__(self, addresses_builder, flavor_builder, image_builder):
+    def __init__(self, addresses_builder, flavor_builder, image_builder,
+                 base_url):
         ViewBuilder.__init__(self, addresses_builder)
         self.flavor_builder = flavor_builder
         self.image_builder = image_builder
+        self.base_url = base_url
 
     def _build_image(self, response, inst):
-        image_id = inst["image_id"]
-        response["imageRef"] = self.image_builder.generate_href(image_id)
+        if "image_id" in dict(inst):
+            image_id = inst.get("image_id")
+            response["imageRef"] = self.image_builder.generate_href(image_id)
 
     def _build_flavor(self, response, inst):
-        flavor_id = inst["instance_type"]
-        response["flavorRef"] = self.flavor_builder.generate_href(flavor_id)
+        if "instance_type" in dict(inst):
+            flavor_id = inst["instance_type"]
+            flavor_ref = self.flavor_builder.generate_href(flavor_id)
+            response["flavorRef"] = flavor_ref
+
+    def _build_extra(self, response, inst):
+        self._build_links(response, inst)
+
+    def _build_links(self, response, inst):
+        href = self.generate_href(inst["id"])
+
+        links = [
+            {
+                "rel": "self",
+                "href": href,
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": href,
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": href,
+            },
+        ]
+
+        response["server"]["links"] = links
+
+    def generate_href(self, server_id):
+        """Create an url that refers to a specific server id."""
+        return os.path.join(self.base_url, "servers", str(server_id))
diff --git a/nova/api/openstack/views/versions.py b/nova/api/openstack/views/versions.py
new file mode 100644
index 000000000..d0145c94a
--- /dev/null
+++ b/nova/api/openstack/views/versions.py
@@ -0,0 +1,59 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import os
+
+
+def get_view_builder(req):
+    base_url = req.application_url
+    return ViewBuilder(base_url)
+
+
+class ViewBuilder(object):
+
+    def __init__(self, base_url):
+        """
+        :param base_url: url of the root wsgi application
+        """
+        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"],
+            "links": self._build_links(version_data),
+        }
+
+        return version
+
+    def _build_links(self, version_data):
+        """Generate a container of links that refer to the provided version."""
+        href = self.generate_href(version_data["id"])
+
+        links = [
+            {
+                "rel": "self",
+                "href": href,
+            },
+        ]
+
+        return links
+
+    def generate_href(self, version_number):
+        """Create an url that refers to a specific version_number."""
+        return os.path.join(self.base_url, version_number)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 86eea105d..b2a13a01b 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2389,7 +2389,7 @@ def instance_type_get_by_flavor_id(context, id):
                                     filter_by(flavorid=int(id)).\
                                     first()
     if not inst_type:
-        raise exception.NotFound(_("No flavor with name %s") % id)
+        raise exception.NotFound(_("No flavor with flavorid %s") % id)
     else:
         return dict(inst_type)
 
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 3cc68a536..8b0729c35 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -35,6 +35,7 @@ from nova import utils
 import nova.api.openstack.auth
 from nova.api import openstack
 from nova.api.openstack import auth
+from nova.api.openstack import versions
 from nova.api.openstack import limits
 from nova.auth.manager import User, Project
 from nova.image import glance
@@ -85,7 +86,7 @@ def wsgi_app(inner_app10=None, inner_app11=None):
               limits.RateLimitingMiddleware(inner_app11)))
     mapper['/v1.0'] = api10
     mapper['/v1.1'] = api11
-    mapper['/'] = openstack.FaultWrapper(openstack.Versions())
+    mapper['/'] = openstack.FaultWrapper(versions.Versions())
     return mapper
 
 
@@ -184,15 +185,19 @@ def stub_out_glance(stubs, initial_fixtures=None):
                                for _ in range(20))
             image_meta['id'] = image_id
             self.fixtures.append(image_meta)
-            return image_meta
+            return copy.deepcopy(image_meta)
 
         def fake_update_image(self, image_id, image_meta, data=None):
+            for attr in ('created_at', 'updated_at', 'deleted_at', 'deleted'):
+                if attr in image_meta:
+                    del image_meta[attr]
+
             f = self._find_image(image_id)
             if not f:
                 raise glance_exc.NotFound
 
             f.update(image_meta)
-            return f
+            return copy.deepcopy(f)
 
         def fake_delete_image(self, image_id):
             f = self._find_image(image_id)
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 4f504808c..954d72adf 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -19,11 +19,10 @@ import json
 import stubout
 import webob
 
-from nova import test
-import nova.api
+import nova.db.api
 from nova import context
-from nova.api.openstack import flavors
-from nova import db
+from nova import exception
+from nova import test
 from nova.tests.api.openstack import fakes
 
 
@@ -48,6 +47,10 @@ def return_instance_types(context, num=2):
     return instance_types
 
 
+def return_instance_type_not_found(context, flavorid):
+    raise exception.NotFound()
+
+
 class FlavorsTest(test.TestCase):
     def setUp(self):
         super(FlavorsTest, self).setUp()
@@ -67,7 +70,7 @@ class FlavorsTest(test.TestCase):
         self.stubs.UnsetAll()
         super(FlavorsTest, self).tearDown()
 
-    def test_get_flavor_list(self):
+    def test_get_flavor_list_v1_0(self):
         req = webob.Request.blank('/v1.0/flavors')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
@@ -84,7 +87,7 @@ class FlavorsTest(test.TestCase):
         ]
         self.assertEqual(flavors, expected)
 
-    def test_get_flavor_list_detail(self):
+    def test_get_flavor_list_detail_v1_0(self):
         req = webob.Request.blank('/v1.0/flavors/detail')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
@@ -105,7 +108,7 @@ class FlavorsTest(test.TestCase):
         ]
         self.assertEqual(flavors, expected)
 
-    def test_get_flavor_by_id(self):
+    def test_get_flavor_by_id_v1_0(self):
         req = webob.Request.blank('/v1.0/flavors/12')
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
@@ -117,3 +120,144 @@ class FlavorsTest(test.TestCase):
             "disk": "10",
         }
         self.assertEqual(flavor, expected)
+
+    def test_get_flavor_by_invalid_id(self):
+        self.stubs.Set(nova.db.api, "instance_type_get_by_flavor_id",
+                       return_instance_type_not_found)
+        req = webob.Request.blank('/v1.0/flavors/asdf')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 404)
+
+    def test_get_flavor_by_id_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors/12')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavor"]
+        expected = {
+            "id": "12",
+            "name": "flavor 12",
+            "ram": "256",
+            "disk": "10",
+            "links": [
+                {
+                    "rel": "self",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
+                {
+                    "rel": "bookmark",
+                    "type": "application/json",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
+                {
+                    "rel": "bookmark",
+                    "type": "application/xml",
+                    "href": "http://localhost/v1.1/flavors/12",
+                },
+            ],
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                ],
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                ],
+            },
+        ]
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_detail_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors/detail')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)["flavors"]
+        expected = [
+            {
+                "id": "1",
+                "name": "flavor 1",
+                "ram": "256",
+                "disk": "10",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/1",
+                    },
+                ],
+            },
+            {
+                "id": "2",
+                "name": "flavor 2",
+                "ram": "256",
+                "disk": "10",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/json",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "type": "application/xml",
+                        "href": "http://localhost/v1.1/flavors/2",
+                    },
+                ],
+            },
+        ]
+        self.assertEqual(flavor, expected)
diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
new file mode 100644
index 000000000..9be753f84
--- /dev/null
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -0,0 +1,166 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import json
+import stubout
+import unittest
+import webob
+
+
+from nova import flags
+from nova.api import openstack
+from nova.tests.api.openstack import fakes
+import nova.wsgi
+
+
+FLAGS = flags.FLAGS
+
+
+class ImageMetaDataTest(unittest.TestCase):
+
+    IMAGE_FIXTURES = [
+        {'status': 'active',
+        'name': 'image1',
+        'deleted': False,
+        'container_format': None,
+        'created_at': '2011-03-22T17:40:15',
+        'disk_format': None,
+        'updated_at': '2011-03-22T17:40:15',
+        'id': '1',
+        'location': 'file:///var/lib/glance/images/1',
+        'is_public': True,
+        'deleted_at': None,
+        'properties': {
+            'type': 'ramdisk',
+            'key1': 'value1',
+            'key2': 'value2'
+        },
+        'size': 5882349},
+        {'status': 'active',
+        'name': 'image2',
+        'deleted': False,
+        'container_format': None,
+        'created_at': '2011-03-22T17:40:15',
+        'disk_format': None,
+        'updated_at': '2011-03-22T17:40:15',
+        'id': '2',
+        'location': 'file:///var/lib/glance/images/2',
+        'is_public': True,
+        'deleted_at': None,
+        'properties': {
+            'type': 'ramdisk',
+            'key1': 'value1',
+            'key2': 'value2'
+        },
+        'size': 5882349},
+        ]
+
+    def setUp(self):
+        super(ImageMetaDataTest, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        self.orig_image_service = FLAGS.image_service
+        FLAGS.image_service = 'nova.image.glance.GlanceImageService'
+        fakes.FakeAuthManager.auth_data = {}
+        fakes.FakeAuthDatabase.data = {}
+        fakes.stub_out_auth(self.stubs)
+        fakes.stub_out_glance(self.stubs, self.IMAGE_FIXTURES)
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        FLAGS.image_service = self.orig_image_service
+        super(ImageMetaDataTest, self).tearDown()
+
+    def test_index(self):
+        req = webob.Request.blank('/v1.1/images/1/meta')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value1', res_dict['metadata']['key1'])
+
+    def test_show(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value1', res_dict['key1'])
+
+    def test_show_not_found(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key9')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(404, res.status_int)
+
+    def test_create(self):
+        req = webob.Request.blank('/v1.1/images/2/meta')
+        req.environ['api.version'] = '1.1'
+        req.method = 'POST'
+        req.body = '{"metadata": {"key9": "value9"}}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(200, res.status_int)
+        self.assertEqual('value9', res_dict['metadata']['key9'])
+        # other items should not be modified
+        self.assertEqual('value1', res_dict['metadata']['key1'])
+        self.assertEqual('value2', res_dict['metadata']['key2'])
+        self.assertEqual(1, len(res_dict))
+
+    def test_update_item(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "zz"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+        res_dict = json.loads(res.body)
+        self.assertEqual('zz', res_dict['key1'])
+
+    def test_update_item_too_many_keys(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1", "key2": "value2"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_update_item_body_uri_mismatch(self):
+        req = webob.Request.blank('/v1.1/images/1/meta/bad')
+        req.environ['api.version'] = '1.1'
+        req.method = 'PUT'
+        req.body = '{"key1": "value1"}'
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, res.status_int)
+
+    def test_delete(self):
+        req = webob.Request.blank('/v1.1/images/2/meta/key1')
+        req.environ['api.version'] = '1.1'
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(200, res.status_int)
+
+    def test_delete_not_found(self):
+        req = webob.Request.blank('/v1.1/images/2/meta/blah')
+        req.environ['api.version'] = '1.1'
+        req.method = 'DELETE'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(404, res.status_int)
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index c48cc5179..737b43c7b 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -26,6 +26,7 @@ import webob
 
 from nova import context
 from nova import db
+from nova import exception
 from nova import flags
 from nova import test
 import nova.api.openstack
@@ -164,6 +165,33 @@ class ServersTest(test.TestCase):
         self.assertEqual(res_dict['server']['id'], 1)
         self.assertEqual(res_dict['server']['name'], 'server1')
 
+    def test_get_server_by_id_v11(self):
+        req = webob.Request.blank('/v1.1/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], 1)
+        self.assertEqual(res_dict['server']['name'], 'server1')
+
+        expected_links = [
+            {
+                "rel": "self",
+                "href": "http://localhost/v1.1/servers/1",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/servers/1",
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/servers/1",
+            },
+        ]
+
+        print res_dict['server']
+        self.assertEqual(res_dict['server']['links'], expected_links)
+
     def test_get_server_by_id_with_addresses(self):
         private = "192.168.0.3"
         public = ["1.2.3.4"]
@@ -186,7 +214,6 @@ class ServersTest(test.TestCase):
         new_return_server = return_server_with_addresses(private, public)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
         req = webob.Request.blank('/v1.1/servers/1')
-        req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict['server']['id'], 1)
@@ -211,6 +238,35 @@ class ServersTest(test.TestCase):
             self.assertEqual(s.get('imageId', None), None)
             i += 1
 
+    def test_get_server_list_v11(self):
+        req = webob.Request.blank('/v1.1/servers')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        for i, s in enumerate(res_dict['servers']):
+            self.assertEqual(s['id'], i)
+            self.assertEqual(s['name'], 'server%d' % i)
+            self.assertEqual(s.get('imageId', None), None)
+
+            expected_links = [
+            {
+                "rel": "self",
+                "href": "http://localhost/v1.1/servers/%d" % (i,),
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/json",
+                "href": "http://localhost/v1.1/servers/%d" % (i,),
+            },
+            {
+                "rel": "bookmark",
+                "type": "application/xml",
+                "href": "http://localhost/v1.1/servers/%d" % (i,),
+            },
+        ]
+
+        self.assertEqual(s['links'], expected_links)
+
     def test_get_servers_with_limit(self):
         req = webob.Request.blank('/v1.0/servers?limit=3')
         res = req.get_response(fakes.wsgi_app())
@@ -458,7 +514,6 @@ class ServersTest(test.TestCase):
 
     def test_get_all_server_details_v1_1(self):
         req = webob.Request.blank('/v1.1/servers/detail')
-        req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
 
@@ -1260,3 +1315,57 @@ class TestServerInstanceCreation(test.TestCase):
         server = dom.childNodes[0]
         self.assertEquals(server.nodeName, 'server')
         self.assertTrue(server.getAttribute('adminPass').startswith('fake'))
+
+
+class TestGetKernelRamdiskFromImage(test.TestCase):
+    """
+    If we're building from an AMI-style image, we need to be able to fetch the
+    kernel and ramdisk associated with the machine image. This information is
+    stored with the image metadata and return via the ImageService.
+
+    These tests ensure that we parse the metadata return the ImageService
+    correctly and that we handle failure modes appropriately.
+    """
+
+    def test_status_not_active(self):
+        """We should only allow fetching of kernel and ramdisk information if
+        we have a 'fully-formed' image, aka 'active'
+        """
+        image_meta = {'id': 1, 'status': 'queued'}
+        self.assertRaises(exception.Invalid, self._get_k_r, image_meta)
+
+    def test_not_ami(self):
+        """Anything other than ami should return no kernel and no ramdisk"""
+        image_meta = {'id': 1, 'status': 'active',
+                      'properties': {'disk_format': 'vhd'}}
+        kernel_id, ramdisk_id = self._get_k_r(image_meta)
+        self.assertEqual(kernel_id, None)
+        self.assertEqual(ramdisk_id, None)
+
+    def test_ami_no_kernel(self):
+        """If an ami is missing a kernel it should raise NotFound"""
+        image_meta = {'id': 1, 'status': 'active',
+                      'properties': {'disk_format': 'ami', 'ramdisk_id': 1}}
+        self.assertRaises(exception.NotFound, self._get_k_r, image_meta)
+
+    def test_ami_no_ramdisk(self):
+        """If an ami is missing a ramdisk it should raise NotFound"""
+        image_meta = {'id': 1, 'status': 'active',
+                      'properties': {'disk_format': 'ami', 'kernel_id': 1}}
+        self.assertRaises(exception.NotFound, self._get_k_r, image_meta)
+
+    def test_ami_kernel_ramdisk_present(self):
+        """Return IDs if both kernel and ramdisk are present"""
+        image_meta = {'id': 1, 'status': 'active',
+                      'properties': {'disk_format': 'ami', 'kernel_id': 1,
+                                     'ramdisk_id': 2}}
+        kernel_id, ramdisk_id = self._get_k_r(image_meta)
+        self.assertEqual(kernel_id, 1)
+        self.assertEqual(ramdisk_id, 2)
+
+    @staticmethod
+    def _get_k_r(image_meta):
+        """Rebinding function to a shorter name for convenience"""
+        kernel_id, ramdisk_id = \
+            servers.Controller._do_get_kernel_ramdisk_from_image(image_meta)
+        return kernel_id, ramdisk_id
diff --git a/nova/tests/api/openstack/test_versions.py b/nova/tests/api/openstack/test_versions.py
new file mode 100644
index 000000000..ebb59a9a6
--- /dev/null
+++ b/nova/tests/api/openstack/test_versions.py
@@ -0,0 +1,97 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import json
+import webob
+
+from nova import context
+from nova import test
+from nova.tests.api.openstack import fakes
+from nova.api.openstack import views
+
+
+class VersionsTest(test.TestCase):
+    def setUp(self):
+        super(VersionsTest, self).setUp()
+        self.context = context.get_admin_context()
+
+    def tearDown(self):
+        super(VersionsTest, self).tearDown()
+
+    def test_get_version_list(self):
+        req = webob.Request.blank('/')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        versions = json.loads(res.body)["versions"]
+        expected = [
+            {
+                "id": "v1.1",
+                "status": "CURRENT",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1",
+                    }
+                ],
+            },
+            {
+                "id": "v1.0",
+                "status": "DEPRECATED",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.0",
+                    }
+                ],
+            },
+        ]
+        self.assertEqual(versions, expected)
+
+    def test_view_builder(self):
+        base_url = "http://example.org/"
+
+        version_data = {
+            "id": "3.2.1",
+            "status": "CURRENT",
+        }
+
+        expected = {
+            "id": "3.2.1",
+            "status": "CURRENT",
+            "links": [
+                {
+                    "rel": "self",
+                    "href": "http://example.org/3.2.1",
+                },
+            ],
+        }
+
+        builder = views.versions.ViewBuilder(base_url)
+        output = builder.build(version_data)
+
+        self.assertEqual(output, expected)
+
+    def test_generate_href(self):
+        base_url = "http://example.org/app/"
+        version_number = "v1.4.6"
+
+        expected = "http://example.org/app/v1.4.6"
+
+        builder = views.versions.ViewBuilder(base_url)
+        actual = builder.generate_href(version_number)
+
+        self.assertEqual(actual, expected)
diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py
index 5962507d7..36457ee87 100644
--- a/nova/virt/libvirt_conn.py
+++ b/nova/virt/libvirt_conn.py
@@ -760,11 +760,12 @@ class LibvirtConnection(driver.ComputeDriver):
                    'dns': network_ref['dns'],
                    'address_v6': address_v6,
                    'gateway_v6': network_ref['gateway_v6'],
-                   'netmask_v6': network_ref['netmask_v6'],
-                   'use_ipv6': FLAGS.use_ipv6}
+                   'netmask_v6': network_ref['netmask_v6']}
             nets.append(net_info)
 
-        net = str(Template(ifc_template, searchList=[{'interfaces': nets}]))
+        net = str(Template(ifc_template,
+                           searchList=[{'interfaces': nets,
+                                        'use_ipv6': FLAGS.use_ipv6}]))
 
         if key or net:
             inst_name = inst['name']