Phew ... ok, this is the last dist-scheduler merge before we get into serious testing and minor tweaks. The heavy lifting is largely done.

This branch adds an OS API POST /zone/boot command which returns a reservation ID (unlike POST /servers which returns a single instance_id). 

This branch requires v2.5 of python-novaclient

Additionally GET /servers can now take an optional reservation_id parameter, which will return all the instances with that reservation ID across all zones.

7 files changed, 482 insertions, 310 deletions

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index c116e4220..ddd9580d7 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -81,7 +81,9 @@ class APIRouter(base_wsgi.Router):
         self._setup_routes(mapper)
         super(APIRouter, self).__init__(mapper)
 
-    def _setup_routes(self, mapper):
+    def _setup_routes(self, mapper, version):
+        """Routes common to all versions."""
+
         server_members = self.server_members
         server_members['action'] = 'POST'
         if FLAGS.allow_admin_api:
@@ -98,11 +100,6 @@ class APIRouter(base_wsgi.Router):
             server_members['reset_network'] = 'POST'
             server_members['inject_network_info'] = 'POST'
 
-            mapper.resource("zone", "zones",
-                        controller=zones.create_resource(),
-                        collection={'detail': 'GET', 'info': 'GET',
-                                    'select': 'POST'})
-
             mapper.resource("user", "users",
                         controller=users.create_resource(),
                         collection={'detail': 'GET'})
@@ -111,10 +108,34 @@ class APIRouter(base_wsgi.Router):
                             controller=accounts.create_resource(),
                             collection={'detail': 'GET'})
 
+            mapper.resource("zone", "zones",
+                        controller=zones.create_resource(version),
+                        collection={'detail': 'GET',
+                                    'info': 'GET',
+                                    'select': 'POST',
+                                    'boot': 'POST'
+                                   })
+
         mapper.resource("console", "consoles",
-                        controller=consoles.create_resource(),
-                        parent_resource=dict(member_name='server',
-                        collection_name='servers'))
+                    controller=consoles.create_resource(),
+                    parent_resource=dict(member_name='server',
+                    collection_name='servers'))
+
+        mapper.resource("server", "servers",
+                        controller=servers.create_resource(version),
+                        collection={'detail': 'GET'},
+                        member=self.server_members)
+
+        mapper.resource("image", "images",
+                        controller=images.create_resource(version),
+                        collection={'detail': 'GET'})
+
+        mapper.resource("limit", "limits",
+                        controller=limits.create_resource(version))
+
+        mapper.resource("flavor", "flavors",
+                        controller=flavors.create_resource(version),
+                        collection={'detail': 'GET'})
 
         super(APIRouter, self).__init__(mapper)
 
@@ -123,20 +144,11 @@ class APIRouterV10(APIRouter):
     """Define routes specific to OpenStack API V1.0."""
 
     def _setup_routes(self, mapper):
-        super(APIRouterV10, self)._setup_routes(mapper)
-        mapper.resource("server", "servers",
-                        controller=servers.create_resource('1.0'),
-                        collection={'detail': 'GET'},
-                        member=self.server_members)
-
+        super(APIRouterV10, self)._setup_routes(mapper, '1.0')
         mapper.resource("image", "images",
                         controller=images.create_resource('1.0'),
                         collection={'detail': 'GET'})
 
-        mapper.resource("flavor", "flavors",
-                        controller=flavors.create_resource('1.0'),
-                        collection={'detail': 'GET'})
-
         mapper.resource("shared_ip_group", "shared_ip_groups",
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.create_resource())
@@ -146,9 +158,6 @@ class APIRouterV10(APIRouter):
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
 
-        mapper.resource("limit", "limits",
-                        controller=limits.create_resource('1.0'))
-
         mapper.resource("ip", "ips", controller=ips.create_resource(),
                         collection=dict(public='GET', private='GET'),
                         parent_resource=dict(member_name='server',
@@ -159,16 +168,7 @@ class APIRouterV11(APIRouter):
     """Define routes specific to OpenStack API V1.1."""
 
     def _setup_routes(self, mapper):
-        super(APIRouterV11, self)._setup_routes(mapper)
-        mapper.resource("server", "servers",
-                        controller=servers.create_resource('1.1'),
-                        collection={'detail': 'GET'},
-                        member=self.server_members)
-
-        mapper.resource("image", "images",
-                        controller=images.create_resource('1.1'),
-                        collection={'detail': 'GET'})
-
+        super(APIRouterV11, self)._setup_routes(mapper, '1.1')
         mapper.resource("image_meta", "meta",
                         controller=image_metadata.create_resource(),
                         parent_resource=dict(member_name='image',
@@ -178,10 +178,3 @@ class APIRouterV11(APIRouter):
                         controller=server_metadata.create_resource(),
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
-
-        mapper.resource("flavor", "flavors",
-                        controller=flavors.create_resource('1.1'),
-                        collection={'detail': 'GET'})
-
-        mapper.resource("limit", "limits",
-                        controller=limits.create_resource('1.1'))
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index ce7e2805c..4da7ec0ef 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -26,8 +26,6 @@ from nova import log as logging
 
 
 LOG = logging.getLogger('nova.api.openstack.common')
-
-
 FLAGS = flags.FLAGS
 
 
diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
new file mode 100644
index 000000000..fbc6318ef
--- /dev/null
+++ b/nova/api/openstack/create_instance_helper.py
@@ -0,0 +1,346 @@
+# 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 base64
+import re
+import webob
+
+from webob import exc
+from xml.dom import minidom
+
+from nova import exception
+from nova import flags
+from nova import log as logging
+import nova.image
+from nova import quota
+from nova import utils
+
+from nova.compute import instance_types
+from nova.api.openstack import faults
+from nova.api.openstack import wsgi
+from nova.auth import manager as auth_manager
+
+
+LOG = logging.getLogger('nova.api.openstack.create_instance_helper')
+FLAGS = flags.FLAGS
+
+
+class CreateFault(exception.NovaException):
+    message = _("Invalid parameters given to create_instance.")
+
+    def __init__(self, fault):
+        self.fault = fault
+        super(CreateFault, self).__init__()
+
+
+class CreateInstanceHelper(object):
+    """This is the base class for OS API Controllers that
+    are capable of creating instances (currently Servers and Zones).
+
+    Once we stabilize the Zones portion of the API we may be able
+    to move this code back into servers.py
+    """
+
+    def __init__(self, controller):
+        """We need the image service to create an instance."""
+        self.controller = controller
+        self._image_service = utils.import_object(FLAGS.image_service)
+        super(CreateInstanceHelper, self).__init__()
+
+    def create_instance(self, req, body, create_method):
+        """Creates a new server for the given user. The approach
+        used depends on the create_method. For example, the standard
+        POST /server call uses compute.api.create(), while
+        POST /zones/server uses compute.api.create_all_at_once().
+
+        The problem is, both approaches return different values (i.e.
+        [instance dicts] vs. reservation_id). So the handling of the
+        return type from this method is left to the caller.
+        """
+        if not body:
+            raise faults.Fault(exc.HTTPUnprocessableEntity())
+
+        context = req.environ['nova.context']
+
+        password = self.controller._get_server_admin_password(body['server'])
+
+        key_name = None
+        key_data = None
+        key_pairs = auth_manager.AuthManager.get_key_pairs(context)
+        if key_pairs:
+            key_pair = key_pairs[0]
+            key_name = key_pair['name']
+            key_data = key_pair['public_key']
+
+        image_href = self.controller._image_ref_from_req_data(body)
+        try:
+            image_service, image_id = nova.image.get_image_service(image_href)
+            kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image(
+                                                req, image_id)
+            images = set([str(x['id']) for x in image_service.index(context)])
+            assert str(image_id) in images
+        except Exception, e:
+            msg = _("Cannot find requested image %(image_href)s: %(e)s" %
+                                                                    locals())
+            raise faults.Fault(exc.HTTPBadRequest(msg))
+
+        personality = body['server'].get('personality')
+
+        injected_files = []
+        if personality:
+            injected_files = self._get_injected_files(personality)
+
+        flavor_id = self.controller._flavor_id_from_req_data(body)
+
+        if not 'name' in body['server']:
+            msg = _("Server name is not defined")
+            raise exc.HTTPBadRequest(msg)
+
+        zone_blob = body['server'].get('blob')
+        name = body['server']['name']
+        self._validate_server_name(name)
+        name = name.strip()
+
+        reservation_id = body['server'].get('reservation_id')
+
+        try:
+            inst_type = \
+                    instance_types.get_instance_type_by_flavor_id(flavor_id)
+            extra_values = {
+                'instance_type': inst_type,
+                'image_ref': image_href,
+                'password': password
+            }
+
+            return (extra_values,
+                    create_method(context,
+                                  inst_type,
+                                  image_id,
+                                  kernel_id=kernel_id,
+                                  ramdisk_id=ramdisk_id,
+                                  display_name=name,
+                                  display_description=name,
+                                  key_name=key_name,
+                                  key_data=key_data,
+                                  metadata=body['server'].get('metadata', {}),
+                                  injected_files=injected_files,
+                                  admin_password=password,
+                                  zone_blob=zone_blob,
+                                  reservation_id=reservation_id
+                    )
+                )
+        except quota.QuotaError as error:
+            self._handle_quota_error(error)
+        except exception.ImageNotFound as error:
+            msg = _("Can not find requested image")
+            raise faults.Fault(exc.HTTPBadRequest(msg))
+
+        # Let the caller deal with unhandled exceptions.
+
+    def _handle_quota_error(self, error):
+        """
+        Reraise quota errors as api-specific http exceptions
+        """
+        if error.code == "OnsetFileLimitExceeded":
+            expl = _("Personality file limit exceeded")
+            raise exc.HTTPBadRequest(explanation=expl)
+        if error.code == "OnsetFilePathLimitExceeded":
+            expl = _("Personality file path too long")
+            raise exc.HTTPBadRequest(explanation=expl)
+        if error.code == "OnsetFileContentLimitExceeded":
+            expl = _("Personality file content too long")
+            raise exc.HTTPBadRequest(explanation=expl)
+        # if the original error is okay, just reraise it
+        raise error
+
+    def _deserialize_create(self, request):
+        """
+        Deserialize a create request
+
+        Overrides normal behavior in the case of xml content
+        """
+        if request.content_type == "application/xml":
+            deserializer = ServerCreateRequestXMLDeserializer()
+            return deserializer.deserialize(request.body)
+        else:
+            return self._deserialize(request.body, request.get_content_type())
+
+    def _validate_server_name(self, value):
+        if not isinstance(value, basestring):
+            msg = _("Server name is not a string or unicode")
+            raise exc.HTTPBadRequest(msg)
+
+        if value.strip() == '':
+            msg = _("Server name is an empty string")
+            raise exc.HTTPBadRequest(msg)
+
+    def _get_kernel_ramdisk_from_image(self, req, image_id):
+        """Fetch an image from the ImageService, then if present, return the
+        associated kernel and ramdisk image IDs.
+        """
+        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
+
+    @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.ImageUnacceptable(image_id=image_id,
+                                              reason=_("status is not active"))
+
+        if image_meta.get('container_format') != 'ami':
+            return None, None
+
+        try:
+            kernel_id = image_meta['properties']['kernel_id']
+        except KeyError:
+            raise exception.KernelNotFoundForImage(image_id=image_id)
+
+        try:
+            ramdisk_id = image_meta['properties']['ramdisk_id']
+        except KeyError:
+            raise exception.RamdiskNotFoundForImage(image_id=image_id)
+
+        return kernel_id, ramdisk_id
+
+    def _get_injected_files(self, personality):
+        """
+        Create a list of injected files from the personality attribute
+
+        At this time, injected_files must be formatted as a list of
+        (file_path, file_content) pairs for compatibility with the
+        underlying compute service.
+        """
+        injected_files = []
+
+        for item in personality:
+            try:
+                path = item['path']
+                contents = item['contents']
+            except KeyError as key:
+                expl = _('Bad personality format: missing %s') % key
+                raise exc.HTTPBadRequest(explanation=expl)
+            except TypeError:
+                expl = _('Bad personality format')
+                raise exc.HTTPBadRequest(explanation=expl)
+            try:
+                contents = base64.b64decode(contents)
+            except TypeError:
+                expl = _('Personality content for %s cannot be decoded') % path
+                raise exc.HTTPBadRequest(explanation=expl)
+            injected_files.append((path, contents))
+        return injected_files
+
+    def _get_server_admin_password_old_style(self, server):
+        """ Determine the admin password for a server on creation """
+        return utils.generate_password(16)
+
+    def _get_server_admin_password_new_style(self, server):
+        """ Determine the admin password for a server on creation """
+        password = server.get('adminPass')
+
+        if password is None:
+            return utils.generate_password(16)
+        if not isinstance(password, basestring) or password == '':
+            msg = _("Invalid adminPass")
+            raise exc.HTTPBadRequest(msg)
+        return password
+
+
+class ServerXMLDeserializer(wsgi.XMLDeserializer):
+    """
+    Deserializer to handle xml-formatted server create requests.
+
+    Handles standard server attributes as well as optional metadata
+    and personality attributes
+    """
+
+    def create(self, string):
+        """Deserialize an xml-formatted server create request"""
+        dom = minidom.parseString(string)
+        server = self._extract_server(dom)
+        return {'server': server}
+
+    def _extract_server(self, node):
+        """Marshal the server attribute of a parsed request"""
+        server = {}
+        server_node = self._find_first_child_named(node, 'server')
+        for attr in ["name", "imageId", "flavorId", "imageRef", "flavorRef"]:
+            if server_node.getAttribute(attr):
+                server[attr] = server_node.getAttribute(attr)
+        metadata = self._extract_metadata(server_node)
+        if metadata is not None:
+            server["metadata"] = metadata
+        personality = self._extract_personality(server_node)
+        if personality is not None:
+            server["personality"] = personality
+        return server
+
+    def _extract_metadata(self, server_node):
+        """Marshal the metadata attribute of a parsed request"""
+        metadata_node = self._find_first_child_named(server_node, "metadata")
+        if metadata_node is None:
+            return None
+        metadata = {}
+        for meta_node in self._find_children_named(metadata_node, "meta"):
+            key = meta_node.getAttribute("key")
+            metadata[key] = self._extract_text(meta_node)
+        return metadata
+
+    def _extract_personality(self, server_node):
+        """Marshal the personality attribute of a parsed request"""
+        personality_node = \
+                self._find_first_child_named(server_node, "personality")
+        if personality_node is None:
+            return None
+        personality = []
+        for file_node in self._find_children_named(personality_node, "file"):
+            item = {}
+            if file_node.hasAttribute("path"):
+                item["path"] = file_node.getAttribute("path")
+            item["contents"] = self._extract_text(file_node)
+            personality.append(item)
+        return personality
+
+    def _find_first_child_named(self, parent, name):
+        """Search a nodes children for the first child with a given name"""
+        for node in parent.childNodes:
+            if node.nodeName == name:
+                return node
+        return None
+
+    def _find_children_named(self, parent, name):
+        """Return all of a nodes children who have the given name"""
+        for node in parent.childNodes:
+            if node.nodeName == name:
+                yield node
+
+    def _extract_text(self, node):
+        """Get the text field contained by the given node"""
+        if len(node.childNodes) == 1:
+            child = node.childNodes[0]
+            if child.nodeType == child.TEXT_NODE:
+                return child.nodeValue
+        return ""
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 9cf5e8721..798fdd7f7 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -17,24 +17,20 @@ import base64
 import traceback
 
 from webob import exc
-from xml.dom import minidom
 
 from nova import compute
 from nova import exception
 from nova import flags
-import nova.image
 from nova import log as logging
-from nova import quota
 from nova import utils
 from nova.api.openstack import common
+from nova.api.openstack import create_instance_helper as helper
 from nova.api.openstack import faults
 import nova.api.openstack.views.addresses
 import nova.api.openstack.views.flavors
 import nova.api.openstack.views.images
 import nova.api.openstack.views.servers
 from nova.api.openstack import wsgi
-from nova.auth import manager as auth_manager
-from nova.compute import instance_types
 import nova.api.openstack
 from nova.scheduler import api as scheduler_api
 
@@ -48,7 +44,7 @@ class Controller(object):
 
     def __init__(self):
         self.compute_api = compute.API()
-        self._image_service = utils.import_object(FLAGS.image_service)
+        self.helper = helper.CreateInstanceHelper(self)
 
     def index(self, req):
         """ Returns a list of server names and ids for a given user """
@@ -66,12 +62,6 @@ class Controller(object):
             return exc.HTTPBadRequest(str(err))
         return servers
 
-    def _image_ref_from_req_data(self, data):
-        raise NotImplementedError()
-
-    def _flavor_id_from_req_data(self, data):
-        raise NotImplementedError()
-
     def _get_view_builder(self, req):
         raise NotImplementedError()
 
@@ -86,7 +76,10 @@ class Controller(object):
 
         builder - the response model builder
         """
-        instance_list = self.compute_api.get_all(req.environ['nova.context'])
+        reservation_id = req.str_GET.get('reservation_id')
+        instance_list = self.compute_api.get_all(
+                                            req.environ['nova.context'],
+                                            reservation_id=reservation_id)
         limited_list = self._limit_items(instance_list, req)
         builder = self._get_view_builder(req)
         servers = [builder.build(inst, is_detail)['server']
@@ -115,128 +108,25 @@ class Controller(object):
 
     def create(self, req, body):
         """ Creates a new server for a given user """
-        if not body:
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-
-        context = req.environ['nova.context']
-
-        password = self._get_server_admin_password(body['server'])
-
-        key_name = None
-        key_data = None
-        key_pairs = auth_manager.AuthManager.get_key_pairs(context)
-        if key_pairs:
-            key_pair = key_pairs[0]
-            key_name = key_pair['name']
-            key_data = key_pair['public_key']
-
-        image_href = self._image_ref_from_req_data(body)
+        extra_values = None
+        result = None
         try:
-            image_service, image_id = nova.image.get_image_service(image_href)
-            kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image(
-                req, image_service, image_id)
-            images = set([str(x['id']) for x in image_service.index(context)])
-            assert str(image_id) in images
-        except:
-            msg = _("Cannot find requested image %s") % image_href
-            return faults.Fault(exc.HTTPBadRequest(msg))
-
-        personality = body['server'].get('personality')
+            extra_values, result = self.helper.create_instance(
+                                    req, body, self.compute_api.create)
+        except faults.Fault, f:
+            return f
 
-        injected_files = []
-        if personality:
-            injected_files = self._get_injected_files(personality)
+        instances = result
 
-        flavor_id = self._flavor_id_from_req_data(body)
-
-        if not 'name' in body['server']:
-            msg = _("Server name is not defined")
-            return exc.HTTPBadRequest(msg)
-
-        zone_blob = body['server'].get('blob')
-        name = body['server']['name']
-        self._validate_server_name(name)
-        name = name.strip()
-
-        try:
-            inst_type = \
-                instance_types.get_instance_type_by_flavor_id(flavor_id)
-            (inst,) = self.compute_api.create(
-                context,
-                inst_type,
-                image_href,
-                kernel_id=kernel_id,
-                ramdisk_id=ramdisk_id,
-                display_name=name,
-                display_description=name,
-                key_name=key_name,
-                key_data=key_data,
-                metadata=body['server'].get('metadata', {}),
-                injected_files=injected_files,
-                admin_password=password,
-                zone_blob=zone_blob)
-        except quota.QuotaError as error:
-            self._handle_quota_error(error)
-        except exception.ImageNotFound as error:
-            msg = _("Can not find requested image")
-            return faults.Fault(exc.HTTPBadRequest(msg))
-
-        inst['instance_type'] = inst_type
-        inst['image_ref'] = image_href
+        (inst, ) = instances
+        for key in ['instance_type', 'image_ref']:
+            inst[key] = extra_values[key]
 
         builder = self._get_view_builder(req)
         server = builder.build(inst, is_detail=True)
-        server['server']['adminPass'] = password
+        server['server']['adminPass'] = extra_values['password']
         return server
 
-    def _get_injected_files(self, personality):
-        """
-        Create a list of injected files from the personality attribute
-
-        At this time, injected_files must be formatted as a list of
-        (file_path, file_content) pairs for compatibility with the
-        underlying compute service.
-        """
-        injected_files = []
-
-        for item in personality:
-            try:
-                path = item['path']
-                contents = item['contents']
-            except KeyError as key:
-                expl = _('Bad personality format: missing %s') % key
-                raise exc.HTTPBadRequest(explanation=expl)
-            except TypeError:
-                expl = _('Bad personality format')
-                raise exc.HTTPBadRequest(explanation=expl)
-            try:
-                contents = base64.b64decode(contents)
-            except TypeError:
-                expl = _('Personality content for %s cannot be decoded') % path
-                raise exc.HTTPBadRequest(explanation=expl)
-            injected_files.append((path, contents))
-        return injected_files
-
-    def _handle_quota_error(self, error):
-        """
-        Reraise quota errors as api-specific http exceptions
-        """
-        if error.code == "OnsetFileLimitExceeded":
-            expl = _("Personality file limit exceeded")
-            raise exc.HTTPBadRequest(explanation=expl)
-        if error.code == "OnsetFilePathLimitExceeded":
-            expl = _("Personality file path too long")
-            raise exc.HTTPBadRequest(explanation=expl)
-        if error.code == "OnsetFileContentLimitExceeded":
-            expl = _("Personality file content too long")
-            raise exc.HTTPBadRequest(explanation=expl)
-        # if the original error is okay, just reraise it
-        raise error
-
-    def _get_server_admin_password(self, server):
-        """ Determine the admin password for a server on creation """
-        return utils.generate_password(16)
-
     @scheduler_api.redirect_handler
     def update(self, req, id, body):
         """ Updates the server name or password """
@@ -251,7 +141,7 @@ class Controller(object):
 
         if 'name' in body['server']:
             name = body['server']['name']
-            self._validate_server_name(name)
+            self.helper._validate_server_name(name)
             update_dict['display_name'] = name.strip()
 
         self._parse_update(ctxt, id, body, update_dict)
@@ -263,15 +153,6 @@ class Controller(object):
 
         return exc.HTTPNoContent()
 
-    def _validate_server_name(self, value):
-        if not isinstance(value, basestring):
-            msg = _("Server name is not a string or unicode")
-            raise exc.HTTPBadRequest(msg)
-
-        if value.strip() == '':
-            msg = _("Server name is an empty string")
-            raise exc.HTTPBadRequest(msg)
-
     def _parse_update(self, context, id, inst_dict, update_dict):
         pass
 
@@ -520,45 +401,9 @@ class Controller(object):
                 error=item.error))
         return dict(actions=actions)
 
-    def _get_kernel_ramdisk_from_image(self, req, image_service, image_id):
-        """Fetch an image from the ImageService, then if present, return the
-        associated kernel and ramdisk image IDs.
-        """
-        context = req.environ['nova.context']
-        image_meta = 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
-        return self._do_get_kernel_ramdisk_from_image(image_meta)
-
-    @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.ImageUnacceptable(image_id=image_id,
-                                              reason=_("status is not active"))
-
-        if image_meta.get('container_format') != 'ami':
-            return None, None
-
-        try:
-            kernel_id = image_meta['properties']['kernel_id']
-        except KeyError:
-            raise exception.KernelNotFoundForImage(image_id=image_id)
-
-        try:
-            ramdisk_id = image_meta['properties']['ramdisk_id']
-        except KeyError:
-            raise exception.RamdiskNotFoundForImage(image_id=image_id)
-
-        return kernel_id, ramdisk_id
-
 
 class ControllerV10(Controller):
+
     def _image_ref_from_req_data(self, data):
         return data['server']['imageId']
 
@@ -615,6 +460,10 @@ class ControllerV10(Controller):
         response.empty_body = True
         return response
 
+    def _get_server_admin_password(self, server):
+        """ Determine the admin password for a server on creation """
+        return self.helper._get_server_admin_password_old_style(server)
+
 
 class ControllerV11(Controller):
     def _image_ref_from_req_data(self, data):
@@ -724,92 +573,12 @@ class ControllerV11(Controller):
         response.empty_body = True
         return response
 
+    def get_default_xmlns(self, req):
+        return common.XML_NS_V11
+
     def _get_server_admin_password(self, server):
         """ Determine the admin password for a server on creation """
-        password = server.get('adminPass')
-        if password is None:
-            return utils.generate_password(16)
-        if not isinstance(password, basestring) or password == '':
-            msg = _("Invalid adminPass")
-            raise exc.HTTPBadRequest(msg)
-        return password
-
-
-class ServerXMLDeserializer(wsgi.XMLDeserializer):
-    """
-    Deserializer to handle xml-formatted server create requests.
-
-    Handles standard server attributes as well as optional metadata
-    and personality attributes
-    """
-
-    def create(self, string):
-        """Deserialize an xml-formatted server create request"""
-        dom = minidom.parseString(string)
-        server = self._extract_server(dom)
-        return {'server': server}
-
-    def _extract_server(self, node):
-        """Marshal the server attribute of a parsed request"""
-        server = {}
-        server_node = self._find_first_child_named(node, 'server')
-        for attr in ["name", "imageId", "flavorId", "imageRef", "flavorRef"]:
-            if server_node.getAttribute(attr):
-                server[attr] = server_node.getAttribute(attr)
-        metadata = self._extract_metadata(server_node)
-        if metadata is not None:
-            server["metadata"] = metadata
-        personality = self._extract_personality(server_node)
-        if personality is not None:
-            server["personality"] = personality
-        return server
-
-    def _extract_metadata(self, server_node):
-        """Marshal the metadata attribute of a parsed request"""
-        metadata_node = self._find_first_child_named(server_node, "metadata")
-        if metadata_node is None:
-            return None
-        metadata = {}
-        for meta_node in self._find_children_named(metadata_node, "meta"):
-            key = meta_node.getAttribute("key")
-            metadata[key] = self._extract_text(meta_node)
-        return metadata
-
-    def _extract_personality(self, server_node):
-        """Marshal the personality attribute of a parsed request"""
-        personality_node = \
-                self._find_first_child_named(server_node, "personality")
-        if personality_node is None:
-            return None
-        personality = []
-        for file_node in self._find_children_named(personality_node, "file"):
-            item = {}
-            if file_node.hasAttribute("path"):
-                item["path"] = file_node.getAttribute("path")
-            item["contents"] = self._extract_text(file_node)
-            personality.append(item)
-        return personality
-
-    def _find_first_child_named(self, parent, name):
-        """Search a nodes children for the first child with a given name"""
-        for node in parent.childNodes:
-            if node.nodeName == name:
-                return node
-        return None
-
-    def _find_children_named(self, parent, name):
-        """Return all of a nodes children who have the given name"""
-        for node in parent.childNodes:
-            if node.nodeName == name:
-                yield node
-
-    def _extract_text(self, node):
-        """Get the text field contained by the given node"""
-        if len(node.childNodes) == 1:
-            child = node.childNodes[0]
-            if child.nodeType == child.TEXT_NODE:
-                return child.nodeValue
-        return ""
+        return self.helper._get_server_admin_password_new_style(server)
 
 
 def create_resource(version='1.0'):
@@ -845,7 +614,7 @@ def create_resource(version='1.0'):
     }
 
     deserializers = {
-        'application/xml': ServerXMLDeserializer(),
+        'application/xml': helper.ServerXMLDeserializer(),
     }
 
     return wsgi.Resource(controller, serializers=serializers,
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index b2352e3fd..245d0e3fa 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -42,12 +42,15 @@ class ViewBuilder(object):
 
     def build(self, inst, is_detail):
         """Return a dict that represenst a server."""
-        if is_detail:
-            server = self._build_detail(inst)
+        if inst.get('_is_precooked', False):
+            server = dict(server=inst)
         else:
-            server = self._build_simple(inst)
+            if is_detail:
+                server = self._build_detail(inst)
+            else:
+                server = self._build_simple(inst)
 
-        self._build_extra(server, inst)
+            self._build_extra(server, inst)
 
         return server
 
@@ -79,6 +82,7 @@ class ViewBuilder(object):
 
         ctxt = nova.context.get_admin_context()
         compute_api = nova.compute.API()
+
         if compute_api.has_finished_migration(ctxt, inst['id']):
             inst_dict['status'] = 'RESIZE-CONFIRM'
 
diff --git a/nova/api/openstack/wsgi.py b/nova/api/openstack/wsgi.py
index 43b51b64a..0279f784a 100644
--- a/nova/api/openstack/wsgi.py
+++ b/nova/api/openstack/wsgi.py
@@ -380,9 +380,9 @@ class Resource(wsgi.Application):
         try:
             msg_dict = dict(url=request.url, status=response.status_int)
             msg = _("%(url)s returned with HTTP %(status)d") % msg_dict
-        except AttributeError:
-            msg_dict = dict(url=request.url)
-            msg = _("%(url)s returned a fault")
+        except AttributeError, e:
+            msg_dict = dict(url=request.url, e=e)
+            msg = _("%(url)s returned a fault: %(e)s" % msg_dict)
 
         LOG.debug(msg)
 
diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index b2f7898cb..8864f825b 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -21,9 +21,14 @@ from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
+
+from nova.compute import api as compute
+from nova.scheduler import api
+
+from nova.api.openstack import create_instance_helper as helper
 from nova.api.openstack import common
+from nova.api.openstack import faults
 from nova.api.openstack import wsgi
-from nova.scheduler import api
 
 
 FLAGS = flags.FLAGS
@@ -59,6 +64,11 @@ def check_encryption_key(func):
 
 
 class Controller(object):
+    """Controller for Zone resources."""
+
+    def __init__(self):
+        self.compute_api = compute.API()
+        self.helper = helper.CreateInstanceHelper(self)
 
     def index(self, req):
         """Return all zones in brief"""
@@ -93,21 +103,39 @@ class Controller(object):
         return dict(zone=_scrub_zone(zone))
 
     def delete(self, req, id):
+        """Delete a child zone entry."""
         zone_id = int(id)
         api.zone_delete(req.environ['nova.context'], zone_id)
         return {}
 
     def create(self, req, body):
+        """Create a child zone entry."""
         context = req.environ['nova.context']
         zone = api.zone_create(context, body["zone"])
         return dict(zone=_scrub_zone(zone))
 
     def update(self, req, id, body):
+        """Update a child zone entry."""
         context = req.environ['nova.context']
         zone_id = int(id)
         zone = api.zone_update(context, zone_id, body["zone"])
         return dict(zone=_scrub_zone(zone))
 
+    def boot(self, req, body):
+        """Creates a new server for a given user while being Zone aware.
+
+        Returns a reservation ID (a UUID).
+        """
+        result = None
+        try:
+            extra_values, result = self.helper.create_instance(req, body,
+                                    self.compute_api.create_all_at_once)
+        except faults.Fault, f:
+            return f
+
+        reservation_id = result
+        return {'reservation_id': reservation_id}
+
     @check_encryption_key
     def select(self, req, body):
         """Returns a weighted list of costs to create instances
@@ -131,8 +159,37 @@ class Controller(object):
                 blob=cipher_text))
         return cooked
 
+    def _image_ref_from_req_data(self, data):
+        return data['server']['imageId']
+
+    def _flavor_id_from_req_data(self, data):
+        return data['server']['flavorId']
+
+    def _get_server_admin_password(self, server):
+        """ Determine the admin password for a server on creation """
+        return self.helper._get_server_admin_password_old_style(server)
+
+
+class ControllerV11(object):
+    """Controller for 1.1 Zone resources."""
+
+    def _get_server_admin_password(self, server):
+        """ Determine the admin password for a server on creation """
+        return self.helper._get_server_admin_password_new_style(server)
+
+    def _image_ref_from_req_data(self, data):
+        return data['server']['imageRef']
+
+    def _flavor_id_from_req_data(self, data):
+        return data['server']['flavorRef']
+
+
+def create_resource(version):
+    controller = {
+        '1.0': Controller,
+        '1.1': ControllerV11,
+    }[version]()
 
-def create_resource():
     metadata = {
         "attributes": {
             "zone": ["id", "api_url", "name", "capabilities"],
@@ -144,4 +201,9 @@ def create_resource():
                                                   metadata=metadata),
     }
 
-    return wsgi.Resource(Controller(), serializers=serializers)
+    deserializers = {
+        'application/xml': helper.ServerXMLDeserializer(),
+    }
+
+    return wsgi.Resource(controller, serializers=serializers,
+                         deserializers=deserializers)