Merge from trunk

10 files changed, 1043 insertions, 115 deletions

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 5430f443d..3b217e62e 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -20,7 +20,10 @@ Starting point for routing EC2 requests.
 
 """
 
-import httplib2
+from urlparse import urlparse
+
+import eventlet
+from eventlet.green import httplib
 import webob
 import webob.dec
 import webob.exc
@@ -35,7 +38,6 @@ from nova.api.ec2 import apirequest
 from nova.api.ec2 import ec2utils
 from nova.auth import manager
 
-
 FLAGS = flags.FLAGS
 LOG = logging.getLogger("nova.api")
 flags.DEFINE_integer('lockout_attempts', 5,
@@ -158,7 +160,6 @@ class ToToken(wsgi.Middleware):
         auth_params.pop('Signature')
 
         # Authenticate the request.
-        client = httplib2.Http()
         creds = {'ec2Credentials': {'access': access,
                                     'signature': signature,
                                     'host': req.host,
@@ -166,18 +167,24 @@ class ToToken(wsgi.Middleware):
                                     'path': req.path,
                                     'params': auth_params,
                                    }}
-        headers = {'Content-Type': 'application/json'},
-        resp, content = client.request(FLAGS.keystone_ec2_url,
-                                       'POST',
-                                       headers=headers,
-                                       body=utils.dumps(creds))
+        creds_json = utils.dumps(creds)
+        headers = {'Content-Type': 'application/json'}
+        o = urlparse(FLAGS.keystone_ec2_url)
+        if o.scheme == "http":
+            conn = httplib.HTTPConnection(o.netloc)
+        else:
+            conn = httplib.HTTPSConnection(o.netloc)
+        conn.request('POST', o.path, body=creds_json, headers=headers)
+        response = conn.getresponse().read()
+        conn.close()
+
         # NOTE(vish): We could save a call to keystone by
         #             having keystone return token, tenant,
         #             user, and roles from this call.
-        result = utils.loads(content)
+        result = utils.loads(response)
         # TODO(vish): check for errors
-        token_id = result['auth']['token']['id']
 
+        token_id = result['auth']['token']['id']
         # Authenticated!
         req.headers['X-Auth-Token'] = token_id
         return self.application
@@ -392,18 +399,20 @@ class Executor(wsgi.Application):
         except exception.InstanceNotFound as ex:
             LOG.info(_('InstanceNotFound raised: %s'), unicode(ex),
                      context=context)
-            return self._error(req, context, type(ex).__name__, ex.message)
+            ec2_id = ec2utils.id_to_ec2_id(ex.kwargs['instance_id'])
+            message = ex.message % {'instance_id': ec2_id}
+            return self._error(req, context, type(ex).__name__, message)
         except exception.VolumeNotFound as ex:
             LOG.info(_('VolumeNotFound raised: %s'), unicode(ex),
                      context=context)
-            ec2_id = ec2utils.id_to_ec2_vol_id(ex.volume_id)
-            message = _('Volume %s not found') % ec2_id
+            ec2_id = ec2utils.id_to_ec2_vol_id(ex.kwargs['volume_id'])
+            message = ex.message % {'volume_id': ec2_id}
             return self._error(req, context, type(ex).__name__, message)
         except exception.SnapshotNotFound as ex:
             LOG.info(_('SnapshotNotFound raised: %s'), unicode(ex),
                      context=context)
-            ec2_id = ec2utils.id_to_ec2_snap_id(ex.snapshot_id)
-            message = _('Snapshot %s not found') % ec2_id
+            ec2_id = ec2utils.id_to_ec2_snap_id(ex.kwargs['snapshot_id'])
+            message = ex.message % {'snapshot_id': ec2_id}
             return self._error(req, context, type(ex).__name__, message)
         except exception.NotFound as ex:
             LOG.info(_('NotFound raised: %s'), unicode(ex), context=context)
diff --git a/nova/api/ec2/admin.py b/nova/api/ec2/admin.py
index dfbbc0a2b..75e029509 100644
--- a/nova/api/ec2/admin.py
+++ b/nova/api/ec2/admin.py
@@ -21,7 +21,6 @@ Admin API controller, exposed through http via the api worker.
 """
 
 import base64
-import datetime
 import netaddr
 import urllib
 
@@ -33,6 +32,7 @@ from nova import log as logging
 from nova import utils
 from nova.api.ec2 import ec2utils
 from nova.auth import manager
+from nova.compute import vm_states
 
 
 FLAGS = flags.FLAGS
@@ -273,8 +273,7 @@ class AdminController(object):
         """Get the VPN instance for a project ID."""
         for instance in db.instance_get_all_by_project(context, project_id):
             if (instance['image_id'] == str(FLAGS.vpn_image_id)
-                and not instance['state_description'] in
-                    ['shutting_down', 'shutdown']):
+                and not instance['vm_state'] in [vm_states.DELETED]):
                 return instance
 
     def start_vpn(self, context, project):
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 9aebf92e3..fe44191c8 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -47,6 +47,7 @@ from nova import utils
 from nova import volume
 from nova.api.ec2 import ec2utils
 from nova.compute import instance_types
+from nova.compute import vm_states
 from nova.image import s3
 
 
@@ -78,6 +79,30 @@ def _gen_key(context, user_id, key_name):
     return {'private_key': private_key, 'fingerprint': fingerprint}
 
 
+# EC2 API can return the following values as documented in the EC2 API
+# http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/
+#    ApiReference-ItemType-InstanceStateType.html
+# pending | running | shutting-down | terminated | stopping | stopped
+_STATE_DESCRIPTION_MAP = {
+    None: 'pending',
+    vm_states.ACTIVE: 'running',
+    vm_states.BUILDING: 'pending',
+    vm_states.REBUILDING: 'pending',
+    vm_states.DELETED: 'terminated',
+    vm_states.STOPPED: 'stopped',
+    vm_states.MIGRATING: 'migrate',
+    vm_states.RESIZING: 'resize',
+    vm_states.PAUSED: 'pause',
+    vm_states.SUSPENDED: 'suspend',
+    vm_states.RESCUED: 'rescue',
+}
+
+
+def state_description_from_vm_state(vm_state):
+    """Map the vm state to the server status string"""
+    return _STATE_DESCRIPTION_MAP.get(vm_state, vm_state)
+
+
 # TODO(yamahata): hypervisor dependent default device name
 _DEFAULT_ROOT_DEVICE_NAME = '/dev/sda1'
 _DEFAULT_MAPPINGS = {'ami': 'sda1',
@@ -1039,11 +1064,12 @@ class CloudController(object):
 
         def _format_attr_instance_initiated_shutdown_behavior(instance,
                                                                result):
-            state_description = instance['state_description']
-            state_to_value = {'stopping': 'stop',
-                              'stopped': 'stop',
-                              'terminating': 'terminate'}
-            value = state_to_value.get(state_description)
+            vm_state = instance['vm_state']
+            state_to_value = {
+                vm_states.STOPPED: 'stopped',
+                vm_states.DELETED: 'terminated',
+            }
+            value = state_to_value.get(vm_state)
             if value:
                 result['instanceInitiatedShutdownBehavior'] = value
 
@@ -1198,8 +1224,8 @@ class CloudController(object):
             self._format_kernel_id(instance, i, 'kernelId')
             self._format_ramdisk_id(instance, i, 'ramdiskId')
             i['instanceState'] = {
-                'code': instance['state'],
-                'name': instance['state_description']}
+                'code': instance['power_state'],
+                'name': state_description_from_vm_state(instance['vm_state'])}
             fixed_addr = None
             floating_addr = None
             if instance['fixed_ips']:
@@ -1618,22 +1644,22 @@ class CloudController(object):
         # stop the instance if necessary
         restart_instance = False
         if not no_reboot:
-            state_description = instance['state_description']
+            vm_state = instance['vm_state']
 
             # if the instance is in subtle state, refuse to proceed.
-            if state_description not in ('running', 'stopping', 'stopped'):
+            if vm_state not in (vm_states.ACTIVE, vm_states.STOPPED):
                 raise exception.InstanceNotRunning(instance_id=ec2_instance_id)
 
-            if state_description == 'running':
+            if vm_state == vm_states.ACTIVE:
                 restart_instance = True
                 self.compute_api.stop(context, instance_id=instance_id)
 
             # wait instance for really stopped
             start_time = time.time()
-            while state_description != 'stopped':
+            while vm_state != vm_states.STOPPED:
                 time.sleep(1)
                 instance = self.compute_api.get(context, instance_id)
-                state_description = instance['state_description']
+                vm_state = instance['vm_state']
                 # NOTE(yamahata): timeout and error. 1 hour for now for safety.
                 #                 Is it too short/long?
                 #                 Or is there any better way?
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index c3379cd11..a836a584c 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -29,7 +29,8 @@ from nova import log as logging
 from nova import quota
 from nova.api.openstack import wsgi
 from nova.api.openstack import xmlutil
-from nova.compute import power_state as compute_power_state
+from nova.compute import vm_states
+from nova.compute import task_states
 
 
 LOG = logging.getLogger('nova.api.openstack.common')
@@ -40,36 +41,61 @@ XML_NS_V10 = 'http://docs.rackspacecloud.com/servers/api/v1.0'
 XML_NS_V11 = 'http://docs.openstack.org/compute/api/v1.1'
 
 
-_STATUS_MAP = {
-    None: 'BUILD',
-    compute_power_state.NOSTATE: 'BUILD',
-    compute_power_state.RUNNING: 'ACTIVE',
-    compute_power_state.BLOCKED: 'ACTIVE',
-    compute_power_state.SUSPENDED: 'SUSPENDED',
-    compute_power_state.PAUSED: 'PAUSED',
-    compute_power_state.SHUTDOWN: 'SHUTDOWN',
-    compute_power_state.SHUTOFF: 'SHUTOFF',
-    compute_power_state.CRASHED: 'ERROR',
-    compute_power_state.FAILED: 'ERROR',
-    compute_power_state.BUILDING: 'BUILD',
+_STATE_MAP = {
+    vm_states.ACTIVE: {
+        'default': 'ACTIVE',
+        task_states.REBOOTING: 'REBOOT',
+        task_states.UPDATING_PASSWORD: 'PASSWORD',
+        task_states.RESIZE_VERIFY: 'VERIFY_RESIZE',
+    },
+    vm_states.BUILDING: {
+        'default': 'BUILD',
+    },
+    vm_states.REBUILDING: {
+        'default': 'REBUILD',
+    },
+    vm_states.STOPPED: {
+        'default': 'STOPPED',
+    },
+    vm_states.MIGRATING: {
+        'default': 'MIGRATING',
+    },
+    vm_states.RESIZING: {
+        'default': 'RESIZE',
+    },
+    vm_states.PAUSED: {
+        'default': 'PAUSED',
+    },
+    vm_states.SUSPENDED: {
+        'default': 'SUSPENDED',
+    },
+    vm_states.RESCUED: {
+        'default': 'RESCUE',
+    },
+    vm_states.ERROR: {
+        'default': 'ERROR',
+    },
+    vm_states.DELETED: {
+        'default': 'DELETED',
+    },
 }
 
 
-def status_from_power_state(power_state):
-    """Map the power state to the server status string"""
-    return _STATUS_MAP[power_state]
+def status_from_state(vm_state, task_state='default'):
+    """Given vm_state and task_state, return a status string."""
+    task_map = _STATE_MAP.get(vm_state, dict(default='UNKNOWN_STATE'))
+    status = task_map.get(task_state, task_map['default'])
+    LOG.debug("Generated %(status)s from vm_state=%(vm_state)s "
+              "task_state=%(task_state)s." % locals())
+    return status
 
 
-def power_states_from_status(status):
-    """Map the server status string to a list of power states"""
-    power_states = []
-    for power_state, status_map in _STATUS_MAP.iteritems():
-        # Skip the 'None' state
-        if power_state is None:
-            continue
-        if status.lower() == status_map.lower():
-            power_states.append(power_state)
-    return power_states
+def vm_state_from_status(status):
+    """Map the server status string to a vm state."""
+    for state, task_map in _STATE_MAP.iteritems():
+        status_string = task_map.get("default")
+        if status.lower() == status_string.lower():
+            return state
 
 
 def get_pagination_params(request):
diff --git a/nova/api/openstack/contrib/floating_ips.py b/nova/api/openstack/contrib/floating_ips.py
index 40086f778..d1add8f83 100644
--- a/nova/api/openstack/contrib/floating_ips.py
+++ b/nova/api/openstack/contrib/floating_ips.py
@@ -36,9 +36,9 @@ def _translate_floating_ip_view(floating_ip):
         result['fixed_ip'] = floating_ip['fixed_ip']['address']
     except (TypeError, KeyError):
         result['fixed_ip'] = None
-    if 'instance' in floating_ip:
-        result['instance_id'] = floating_ip['instance']['id']
-    else:
+    try:
+        result['instance_id'] = floating_ip['fixed_ip']['instance_id']
+    except (TypeError, KeyError):
         result['instance_id'] = None
     return {'floating_ip': result}
 
@@ -96,7 +96,8 @@ class FloatingIPController(object):
         except rpc.RemoteError as ex:
             # NOTE(tr3buchet) - why does this block exist?
             if ex.exc_type == 'NoMoreFloatingIps':
-                raise exception.NoMoreFloatingIps()
+                msg = _("No more floating ips available.")
+                raise webob.exc.HTTPBadRequest(explanation=msg)
             else:
                 raise
 
@@ -138,7 +139,11 @@ class Floating_ips(extensions.ExtensionDescriptor):
             msg = _("Address not specified")
             raise webob.exc.HTTPBadRequest(explanation=msg)
 
-        self.compute_api.associate_floating_ip(context, instance_id, address)
+        try:
+            self.compute_api.associate_floating_ip(context, instance_id,
+                                                   address)
+        except exception.ApiError, e:
+            raise webob.exc.HTTPBadRequest(explanation=e.message)
 
         return webob.Response(status_int=202)
 
diff --git a/nova/api/openstack/contrib/simple_tenant_usage.py b/nova/api/openstack/contrib/simple_tenant_usage.py
new file mode 100644
index 000000000..42691a9fa
--- /dev/null
+++ b/nova/api/openstack/contrib/simple_tenant_usage.py
@@ -0,0 +1,236 @@
+# 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 urlparse
+import webob
+
+from datetime import datetime
+from nova import exception
+from nova import flags
+from nova.compute import api
+from nova.api.openstack import extensions
+from nova.api.openstack import views
+from nova.db.sqlalchemy.session import get_session
+from webob import exc
+
+
+FLAGS = flags.FLAGS
+
+
+class SimpleTenantUsageController(object):
+    def _hours_for(self, instance, period_start, period_stop):
+        launched_at = instance['launched_at']
+        terminated_at = instance['terminated_at']
+        if terminated_at is not None:
+            if not isinstance(terminated_at, datetime):
+                terminated_at = datetime.strptime(terminated_at,
+                                                  "%Y-%m-%d %H:%M:%S.%f")
+
+        if launched_at is not None:
+            if not isinstance(launched_at, datetime):
+                launched_at = datetime.strptime(launched_at,
+                                                "%Y-%m-%d %H:%M:%S.%f")
+
+        if terminated_at and terminated_at < period_start:
+            return 0
+        # nothing if it started after the usage report ended
+        if launched_at and launched_at > period_stop:
+            return 0
+        if launched_at:
+            # if instance launched after period_started, don't charge for first
+            start = max(launched_at, period_start)
+            if terminated_at:
+                # if instance stopped before period_stop, don't charge after
+                stop = min(period_stop, terminated_at)
+            else:
+                # instance is still running, so charge them up to current time
+                stop = period_stop
+            dt = stop - start
+            seconds = dt.days * 3600 * 24 + dt.seconds\
+                      + dt.microseconds / 100000.0
+
+            return seconds / 3600.0
+        else:
+            # instance hasn't launched, so no charge
+            return 0
+
+    def _tenant_usages_for_period(self, context, period_start,
+                                  period_stop, tenant_id=None, detailed=True):
+
+        compute_api = api.API()
+        instances = compute_api.get_active_by_window(context,
+                                                     period_start,
+                                                     period_stop,
+                                                     tenant_id)
+        from nova import log as logging
+        logging.info(instances)
+        rval = {}
+        flavors = {}
+
+        for instance in instances:
+            info = {}
+            info['hours'] = self._hours_for(instance,
+                                            period_start,
+                                            period_stop)
+            flavor_type = instance['instance_type_id']
+
+            if not flavors.get(flavor_type):
+                try:
+                    it_ref = compute_api.get_instance_type(context,
+                                                           flavor_type)
+                    flavors[flavor_type] = it_ref
+                except exception.InstanceTypeNotFound:
+                    # can't bill if there is no instance type
+                    continue
+
+            flavor = flavors[flavor_type]
+
+            info['name'] = instance['display_name']
+
+            info['memory_mb'] = flavor['memory_mb']
+            info['local_gb'] = flavor['local_gb']
+            info['vcpus'] = flavor['vcpus']
+
+            info['tenant_id'] = instance['project_id']
+
+            info['flavor'] = flavor['name']
+
+            info['started_at'] = instance['launched_at']
+
+            info['ended_at'] = instance['terminated_at']
+
+            if info['ended_at']:
+                info['state'] = 'terminated'
+            else:
+                info['state'] = instance['vm_state']
+
+            now = datetime.utcnow()
+
+            if info['state'] == 'terminated':
+                delta = info['ended_at'] - info['started_at']
+            else:
+                delta = now - info['started_at']
+
+            info['uptime'] = delta.days * 24 * 60 + delta.seconds
+
+            if not info['tenant_id'] in rval:
+                summary = {}
+                summary['tenant_id'] = info['tenant_id']
+                if detailed:
+                    summary['server_usages'] = []
+                summary['total_local_gb_usage'] = 0
+                summary['total_vcpus_usage'] = 0
+                summary['total_memory_mb_usage'] = 0
+                summary['total_hours'] = 0
+                summary['start'] = period_start
+                summary['stop'] = period_stop
+                rval[info['tenant_id']] = summary
+
+            summary = rval[info['tenant_id']]
+            summary['total_local_gb_usage'] += info['local_gb'] * info['hours']
+            summary['total_vcpus_usage'] += info['vcpus'] * info['hours']
+            summary['total_memory_mb_usage'] += info['memory_mb']\
+                                                * info['hours']
+
+            summary['total_hours'] += info['hours']
+            if detailed:
+                summary['server_usages'].append(info)
+
+        return rval.values()
+
+    def _parse_datetime(self, dtstr):
+        if isinstance(dtstr, datetime):
+            return dtstr
+        try:
+            return datetime.strptime(dtstr, "%Y-%m-%dT%H:%M:%S")
+        except:
+            try:
+                return datetime.strptime(dtstr, "%Y-%m-%dT%H:%M:%S.%f")
+            except:
+                return datetime.strptime(dtstr, "%Y-%m-%d %H:%M:%S.%f")
+
+    def _get_datetime_range(self, req):
+        qs = req.environ.get('QUERY_STRING', '')
+        env = urlparse.parse_qs(qs)
+        period_start = self._parse_datetime(env.get('start',
+                                    [datetime.utcnow().isoformat()])[0])
+        period_stop = self._parse_datetime(env.get('end',
+                                    [datetime.utcnow().isoformat()])[0])
+
+        detailed = bool(env.get('detailed', False))
+        return (period_start, period_stop, detailed)
+
+    def index(self, req):
+        """Retrive tenant_usage for all tenants"""
+        context = req.environ['nova.context']
+
+        if not context.is_admin and FLAGS.allow_admin_api:
+            return webob.Response(status_int=403)
+
+        (period_start, period_stop, detailed) = self._get_datetime_range(req)
+        usages = self._tenant_usages_for_period(context,
+                                                period_start,
+                                                period_stop,
+                                                detailed=detailed)
+        return {'tenant_usages': usages}
+
+    def show(self, req, id):
+        """Retrive tenant_usage for a specified tenant"""
+        tenant_id = id
+        context = req.environ['nova.context']
+
+        if not context.is_admin and FLAGS.allow_admin_api:
+            if tenant_id != context.project_id:
+                return webob.Response(status_int=403)
+
+        (period_start, period_stop, ignore) = self._get_datetime_range(req)
+        usage = self._tenant_usages_for_period(context,
+                                               period_start,
+                                               period_stop,
+                                               tenant_id=tenant_id,
+                                               detailed=True)
+        if len(usage):
+            usage = usage[0]
+        else:
+            usage = {}
+        return {'tenant_usage': usage}
+
+
+class Simple_tenant_usage(extensions.ExtensionDescriptor):
+    def get_name(self):
+        return "SimpleTenantUsage"
+
+    def get_alias(self):
+        return "os-simple-tenant-usage"
+
+    def get_description(self):
+        return "Simple tenant usage extension"
+
+    def get_namespace(self):
+        return "http://docs.openstack.org/ext/os-simple-tenant-usage/api/v1.1"
+
+    def get_updated(self):
+        return "2011-08-19T00:00:00+00:00"
+
+    def get_resources(self):
+        resources = []
+
+        res = extensions.ResourceExtension('os-simple-tenant-usage',
+                                            SimpleTenantUsageController())
+        resources.append(res)
+
+        return resources
diff --git a/nova/api/openstack/contrib/virtual_storage_arrays.py b/nova/api/openstack/contrib/virtual_storage_arrays.py
new file mode 100644
index 000000000..e09736a28
--- /dev/null
+++ b/nova/api/openstack/contrib/virtual_storage_arrays.py
@@ -0,0 +1,606 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 Zadara Storage Inc.
+# Copyright (c) 2011 OpenStack LLC.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+""" The virtul storage array extension"""
+
+
+from webob import exc
+
+from nova import vsa
+from nova import volume
+from nova import compute
+from nova import network
+from nova import db
+from nova import quota
+from nova import exception
+from nova import log as logging
+from nova.api.openstack import common
+from nova.api.openstack import extensions
+from nova.api.openstack import faults
+from nova.api.openstack import wsgi
+from nova.api.openstack import servers
+from nova.api.openstack.contrib import volumes
+from nova.compute import instance_types
+
+from nova import flags
+FLAGS = flags.FLAGS
+
+LOG = logging.getLogger("nova.api.vsa")
+
+
+def _vsa_view(context, vsa, details=False, instances=None):
+    """Map keys for vsa summary/detailed view."""
+    d = {}
+
+    d['id'] = vsa.get('id')
+    d['name'] = vsa.get('name')
+    d['displayName'] = vsa.get('display_name')
+    d['displayDescription'] = vsa.get('display_description')
+
+    d['createTime'] = vsa.get('created_at')
+    d['status'] = vsa.get('status')
+
+    if 'vsa_instance_type' in vsa:
+        d['vcType'] = vsa['vsa_instance_type'].get('name', None)
+    else:
+        d['vcType'] = vsa['instance_type_id']
+
+    d['vcCount'] = vsa.get('vc_count')
+    d['driveCount'] = vsa.get('vol_count')
+
+    d['ipAddress'] = None
+    for instance in instances:
+        fixed_addr = None
+        floating_addr = None
+        if instance['fixed_ips']:
+            fixed = instance['fixed_ips'][0]
+            fixed_addr = fixed['address']
+            if fixed['floating_ips']:
+                floating_addr = fixed['floating_ips'][0]['address']
+
+        if floating_addr:
+            d['ipAddress'] = floating_addr
+            break
+        else:
+            d['ipAddress'] = d['ipAddress'] or fixed_addr
+
+    return d
+
+
+class VsaController(object):
+    """The Virtual Storage Array API controller for the OpenStack API."""
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "vsa": [
+                    "id",
+                    "name",
+                    "displayName",
+                    "displayDescription",
+                    "createTime",
+                    "status",
+                    "vcType",
+                    "vcCount",
+                    "driveCount",
+                    "ipAddress",
+                    ]}}}
+
+    def __init__(self):
+        self.vsa_api = vsa.API()
+        self.compute_api = compute.API()
+        self.network_api = network.API()
+        super(VsaController, self).__init__()
+
+    def _get_instances_by_vsa_id(self, context, id):
+        return self.compute_api.get_all(context,
+                    search_opts={'metadata': dict(vsa_id=str(id))})
+
+    def _items(self, req, details):
+        """Return summary or detailed list of VSAs."""
+        context = req.environ['nova.context']
+        vsas = self.vsa_api.get_all(context)
+        limited_list = common.limited(vsas, req)
+
+        vsa_list = []
+        for vsa in limited_list:
+            instances = self._get_instances_by_vsa_id(context, vsa.get('id'))
+            vsa_list.append(_vsa_view(context, vsa, details, instances))
+        return {'vsaSet': vsa_list}
+
+    def index(self, req):
+        """Return a short list of VSAs."""
+        return self._items(req, details=False)
+
+    def detail(self, req):
+        """Return a detailed list of VSAs."""
+        return self._items(req, details=True)
+
+    def show(self, req, id):
+        """Return data about the given VSA."""
+        context = req.environ['nova.context']
+
+        try:
+            vsa = self.vsa_api.get(context, vsa_id=id)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
+        instances = self._get_instances_by_vsa_id(context, vsa.get('id'))
+        return {'vsa': _vsa_view(context, vsa, True, instances)}
+
+    def create(self, req, body):
+        """Create a new VSA."""
+        context = req.environ['nova.context']
+
+        if not body or 'vsa' not in body:
+            LOG.debug(_("No body provided"), context=context)
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+
+        vsa = body['vsa']
+
+        display_name = vsa.get('displayName')
+        vc_type = vsa.get('vcType', FLAGS.default_vsa_instance_type)
+        try:
+            instance_type = instance_types.get_instance_type_by_name(vc_type)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
+        LOG.audit(_("Create VSA %(display_name)s of type %(vc_type)s"),
+                    locals(), context=context)
+
+        args = dict(display_name=display_name,
+                display_description=vsa.get('displayDescription'),
+                instance_type=instance_type,
+                storage=vsa.get('storage'),
+                shared=vsa.get('shared'),
+                availability_zone=vsa.get('placement', {}).\
+                                          get('AvailabilityZone'))
+
+        vsa = self.vsa_api.create(context, **args)
+
+        instances = self._get_instances_by_vsa_id(context, vsa.get('id'))
+        return {'vsa': _vsa_view(context, vsa, True, instances)}
+
+    def delete(self, req, id):
+        """Delete a VSA."""
+        context = req.environ['nova.context']
+
+        LOG.audit(_("Delete VSA with id: %s"), id, context=context)
+
+        try:
+            self.vsa_api.delete(context, vsa_id=id)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
+    def associate_address(self, req, id, body):
+        """ /zadr-vsa/{vsa_id}/associate_address
+        auto or manually associate an IP to VSA
+        """
+        context = req.environ['nova.context']
+
+        if body is None:
+            ip = 'auto'
+        else:
+            ip = body.get('ipAddress', 'auto')
+
+        LOG.audit(_("Associate address %(ip)s to VSA %(id)s"),
+                    locals(), context=context)
+
+        try:
+            instances = self._get_instances_by_vsa_id(context, id)
+            if instances is None or len(instances) == 0:
+                return faults.Fault(exc.HTTPNotFound())
+
+            for instance in instances:
+                self.network_api.allocate_for_instance(context, instance,
+                                    vpn=False)
+                # Placeholder
+                return
+
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
+    def disassociate_address(self, req, id, body):
+        """ /zadr-vsa/{vsa_id}/disassociate_address
+        auto or manually associate an IP to VSA
+        """
+        context = req.environ['nova.context']
+
+        if body is None:
+            ip = 'auto'
+        else:
+            ip = body.get('ipAddress', 'auto')
+
+        LOG.audit(_("Disassociate address from VSA %(id)s"),
+                    locals(), context=context)
+        # Placeholder
+
+
+class VsaVolumeDriveController(volumes.VolumeController):
+    """The base class for VSA volumes & drives.
+
+    A child resource of the VSA object. Allows operations with
+    volumes and drives created to/from particular VSA
+
+    """
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "volume": [
+                    "id",
+                    "name",
+                    "status",
+                    "size",
+                    "availabilityZone",
+                    "createdAt",
+                    "displayName",
+                    "displayDescription",
+                    "vsaId",
+                    ]}}}
+
+    def __init__(self):
+        self.volume_api = volume.API()
+        self.vsa_api = vsa.API()
+        super(VsaVolumeDriveController, self).__init__()
+
+    def _translation(self, context, vol, vsa_id, details):
+        if details:
+            translation = volumes._translate_volume_detail_view
+        else:
+            translation = volumes._translate_volume_summary_view
+
+        d = translation(context, vol)
+        d['vsaId'] = vsa_id
+        d['name'] = vol['name']
+        return d
+
+    def _check_volume_ownership(self, context, vsa_id, id):
+        obj = self.object
+        try:
+            volume_ref = self.volume_api.get(context, volume_id=id)
+        except exception.NotFound:
+            LOG.error(_("%(obj)s with ID %(id)s not found"), locals())
+            raise
+
+        own_vsa_id = self.volume_api.get_volume_metadata_value(volume_ref,
+                                                            self.direction)
+        if  own_vsa_id != vsa_id:
+            LOG.error(_("%(obj)s with ID %(id)s belongs to VSA %(own_vsa_id)s"\
+                        " and not to VSA %(vsa_id)s."), locals())
+            raise exception.Invalid()
+
+    def _items(self, req, vsa_id, details):
+        """Return summary or detailed list of volumes for particular VSA."""
+        context = req.environ['nova.context']
+
+        vols = self.volume_api.get_all(context,
+                search_opts={'metadata': {self.direction: str(vsa_id)}})
+        limited_list = common.limited(vols, req)
+
+        res = [self._translation(context, vol, vsa_id, details) \
+               for vol in limited_list]
+
+        return {self.objects: res}
+
+    def index(self, req, vsa_id):
+        """Return a short list of volumes created from particular VSA."""
+        LOG.audit(_("Index. vsa_id=%(vsa_id)s"), locals())
+        return self._items(req, vsa_id, details=False)
+
+    def detail(self, req, vsa_id):
+        """Return a detailed list of volumes created from particular VSA."""
+        LOG.audit(_("Detail. vsa_id=%(vsa_id)s"), locals())
+        return self._items(req, vsa_id, details=True)
+
+    def create(self, req, vsa_id, body):
+        """Create a new volume from VSA."""
+        LOG.audit(_("Create. vsa_id=%(vsa_id)s, body=%(body)s"), locals())
+        context = req.environ['nova.context']
+
+        if not body:
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+
+        vol = body[self.object]
+        size = vol['size']
+        LOG.audit(_("Create volume of %(size)s GB from VSA ID %(vsa_id)s"),
+                    locals(), context=context)
+        try:
+            # create is supported for volumes only (drives created through VSA)
+            volume_type = self.vsa_api.get_vsa_volume_type(context)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
+        new_volume = self.volume_api.create(context,
+                            size,
+                            None,
+                            vol.get('displayName'),
+                            vol.get('displayDescription'),
+                            volume_type=volume_type,
+                            metadata=dict(from_vsa_id=str(vsa_id)))
+
+        return {self.object: self._translation(context, new_volume,
+                                               vsa_id, True)}
+
+    def update(self, req, vsa_id, id, body):
+        """Update a volume."""
+        context = req.environ['nova.context']
+
+        try:
+            self._check_volume_ownership(context, vsa_id, id)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+        except exception.Invalid:
+            return faults.Fault(exc.HTTPBadRequest())
+
+        vol = body[self.object]
+        updatable_fields = [{'displayName': 'display_name'},
+                            {'displayDescription': 'display_description'},
+                            {'status': 'status'},
+                            {'providerLocation': 'provider_location'},
+                            {'providerAuth': 'provider_auth'}]
+        changes = {}
+        for field in updatable_fields:
+            key = field.keys()[0]
+            val = field[key]
+            if key in vol:
+                changes[val] = vol[key]
+
+        obj = self.object
+        LOG.audit(_("Update %(obj)s with id: %(id)s, changes: %(changes)s"),
+                    locals(), context=context)
+
+        try:
+            self.volume_api.update(context, volume_id=id, fields=changes)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+        return exc.HTTPAccepted()
+
+    def delete(self, req, vsa_id, id):
+        """Delete a volume."""
+        context = req.environ['nova.context']
+
+        LOG.audit(_("Delete. vsa_id=%(vsa_id)s, id=%(id)s"), locals())
+
+        try:
+            self._check_volume_ownership(context, vsa_id, id)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+        except exception.Invalid:
+            return faults.Fault(exc.HTTPBadRequest())
+
+        return super(VsaVolumeDriveController, self).delete(req, id)
+
+    def show(self, req, vsa_id, id):
+        """Return data about the given volume."""
+        context = req.environ['nova.context']
+
+        LOG.audit(_("Show. vsa_id=%(vsa_id)s, id=%(id)s"), locals())
+
+        try:
+            self._check_volume_ownership(context, vsa_id, id)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+        except exception.Invalid:
+            return faults.Fault(exc.HTTPBadRequest())
+
+        return super(VsaVolumeDriveController, self).show(req, id)
+
+
+class VsaVolumeController(VsaVolumeDriveController):
+    """The VSA volume API controller for the Openstack API.
+
+    A child resource of the VSA object. Allows operations with volumes created
+    by particular VSA
+
+    """
+
+    def __init__(self):
+        self.direction = 'from_vsa_id'
+        self.objects = 'volumes'
+        self.object = 'volume'
+        super(VsaVolumeController, self).__init__()
+
+
+class VsaDriveController(VsaVolumeDriveController):
+    """The VSA Drive API controller for the Openstack API.
+
+    A child resource of the VSA object. Allows operations with drives created
+    for particular VSA
+
+    """
+
+    def __init__(self):
+        self.direction = 'to_vsa_id'
+        self.objects = 'drives'
+        self.object = 'drive'
+        super(VsaDriveController, self).__init__()
+
+    def create(self, req, vsa_id, body):
+        """Create a new drive for VSA. Should be done through VSA APIs"""
+        return faults.Fault(exc.HTTPBadRequest())
+
+    def update(self, req, vsa_id, id, body):
+        """Update a drive. Should be done through VSA APIs"""
+        return faults.Fault(exc.HTTPBadRequest())
+
+    def delete(self, req, vsa_id, id):
+        """Delete a volume. Should be done through VSA APIs"""
+        return faults.Fault(exc.HTTPBadRequest())
+
+
+class VsaVPoolController(object):
+    """The vPool VSA API controller for the OpenStack API."""
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "vpool": [
+                    "id",
+                    "vsaId",
+                    "name",
+                    "displayName",
+                    "displayDescription",
+                    "driveCount",
+                    "driveIds",
+                    "protection",
+                    "stripeSize",
+                    "stripeWidth",
+                    "createTime",
+                    "status",
+                    ]}}}
+
+    def __init__(self):
+        self.vsa_api = vsa.API()
+        super(VsaVPoolController, self).__init__()
+
+    def index(self, req, vsa_id):
+        """Return a short list of vpools created from particular VSA."""
+        return {'vpools': []}
+
+    def create(self, req, vsa_id, body):
+        """Create a new vPool for VSA."""
+        return faults.Fault(exc.HTTPBadRequest())
+
+    def update(self, req, vsa_id, id, body):
+        """Update vPool parameters."""
+        return faults.Fault(exc.HTTPBadRequest())
+
+    def delete(self, req, vsa_id, id):
+        """Delete a vPool."""
+        return faults.Fault(exc.HTTPBadRequest())
+
+    def show(self, req, vsa_id, id):
+        """Return data about the given vPool."""
+        return faults.Fault(exc.HTTPBadRequest())
+
+
+class VsaVCController(servers.ControllerV11):
+    """The VSA Virtual Controller API controller for the OpenStack API."""
+
+    def __init__(self):
+        self.vsa_api = vsa.API()
+        self.compute_api = compute.API()
+        self.vsa_id = None      # VP-TODO: temporary ugly hack
+        super(VsaVCController, self).__init__()
+
+    def _get_servers(self, req, is_detail):
+        """Returns a list of servers, taking into account any search
+        options specified.
+        """
+
+        if self.vsa_id is None:
+            super(VsaVCController, self)._get_servers(req, is_detail)
+
+        context = req.environ['nova.context']
+
+        search_opts = {'metadata': dict(vsa_id=str(self.vsa_id))}
+        instance_list = self.compute_api.get_all(
+                context, search_opts=search_opts)
+
+        limited_list = self._limit_items(instance_list, req)
+        servers = [self._build_view(req, inst, is_detail)['server']
+                for inst in limited_list]
+        return dict(servers=servers)
+
+    def index(self, req, vsa_id):
+        """Return list of instances for particular VSA."""
+
+        LOG.audit(_("Index instances for VSA %s"), vsa_id)
+
+        self.vsa_id = vsa_id    # VP-TODO: temporary ugly hack
+        result = super(VsaVCController, self).detail(req)
+        self.vsa_id = None
+        return result
+
+    def create(self, req, vsa_id, body):
+        """Create a new instance for VSA."""
+        return faults.Fault(exc.HTTPBadRequest())
+
+    def update(self, req, vsa_id, id, body):
+        """Update VSA instance."""
+        return faults.Fault(exc.HTTPBadRequest())
+
+    def delete(self, req, vsa_id, id):
+        """Delete VSA instance."""
+        return faults.Fault(exc.HTTPBadRequest())
+
+    def show(self, req, vsa_id, id):
+        """Return data about the given instance."""
+        return super(VsaVCController, self).show(req, id)
+
+
+class Virtual_storage_arrays(extensions.ExtensionDescriptor):
+
+    def get_name(self):
+        return "VSAs"
+
+    def get_alias(self):
+        return "zadr-vsa"
+
+    def get_description(self):
+        return "Virtual Storage Arrays support"
+
+    def get_namespace(self):
+        return "http://docs.openstack.org/ext/vsa/api/v1.1"
+
+    def get_updated(self):
+        return "2011-08-25T00:00:00+00:00"
+
+    def get_resources(self):
+        resources = []
+        res = extensions.ResourceExtension(
+                            'zadr-vsa',
+                            VsaController(),
+                            collection_actions={'detail': 'GET'},
+                            member_actions={'add_capacity': 'POST',
+                                            'remove_capacity': 'POST',
+                                            'associate_address': 'POST',
+                                            'disassociate_address': 'POST'})
+        resources.append(res)
+
+        res = extensions.ResourceExtension('volumes',
+                            VsaVolumeController(),
+                            collection_actions={'detail': 'GET'},
+                            parent=dict(
+                                member_name='vsa',
+                                collection_name='zadr-vsa'))
+        resources.append(res)
+
+        res = extensions.ResourceExtension('drives',
+                            VsaDriveController(),
+                            collection_actions={'detail': 'GET'},
+                            parent=dict(
+                                member_name='vsa',
+                                collection_name='zadr-vsa'))
+        resources.append(res)
+
+        res = extensions.ResourceExtension('vpools',
+                            VsaVPoolController(),
+                            parent=dict(
+                                member_name='vsa',
+                                collection_name='zadr-vsa'))
+        resources.append(res)
+
+        res = extensions.ResourceExtension('instances',
+                            VsaVCController(),
+                            parent=dict(
+                                member_name='vsa',
+                                collection_name='zadr-vsa'))
+        resources.append(res)
+
+        return resources
diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 483ff4985..29e071609 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -19,7 +19,6 @@ import base64
 from webob import exc
 from xml.dom import minidom
 
-from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
@@ -74,20 +73,17 @@ class CreateInstanceHelper(object):
         if not 'server' in body:
             raise exc.HTTPUnprocessableEntity()
 
-        server_dict = body['server']
         context = req.environ['nova.context']
+        server_dict = body['server']
         password = self.controller._get_server_admin_password(server_dict)
 
-        key_name = None
-        key_data = None
-        # TODO(vish): Key pair access should move into a common library
-        #             instead of being accessed directly from the db.
-        key_pairs = db.key_pair_get_all_by_user(context.elevated(),
-                                                context.user_id)
-        if key_pairs:
-            key_pair = key_pairs[0]
-            key_name = key_pair['name']
-            key_data = key_pair['public_key']
+        if not 'name' in server_dict:
+            msg = _("Server name is not defined")
+            raise exc.HTTPBadRequest(explanation=msg)
+
+        name = server_dict['name']
+        self._validate_server_name(name)
+        name = name.strip()
 
         image_href = self.controller._image_ref_from_req_data(body)
         # If the image href was generated by nova api, strip image_href
@@ -98,7 +94,7 @@ class CreateInstanceHelper(object):
         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)
+                                                req, image_service, image_id)
             images = set([str(x['id']) for x in image_service.index(context)])
             assert str(image_id) in images
         except Exception, e:
@@ -133,12 +129,13 @@ class CreateInstanceHelper(object):
             msg = _("Invalid flavorRef provided.")
             raise exc.HTTPBadRequest(explanation=msg)
 
-        if not 'name' in server_dict:
-            msg = _("Server name is not defined")
-            raise exc.HTTPBadRequest(explanation=msg)
-
         zone_blob = server_dict.get('blob')
+
+        # optional openstack extensions:
+        key_name = server_dict.get('key_name')
         user_data = server_dict.get('user_data')
+        self._validate_user_data(user_data)
+
         availability_zone = server_dict.get('availability_zone')
         name = server_dict['name']
         self._validate_server_name(name)
@@ -173,7 +170,6 @@ class CreateInstanceHelper(object):
                                   display_name=name,
                                   display_description=name,
                                   key_name=key_name,
-                                  key_data=key_data,
                                   metadata=server_dict.get('metadata', {}),
                                   access_ip_v4=server_dict.get('accessIPv4'),
                                   access_ip_v6=server_dict.get('accessIPv6'),
@@ -196,6 +192,9 @@ class CreateInstanceHelper(object):
         except exception.FlavorNotFound as error:
             msg = _("Invalid flavorRef provided.")
             raise exc.HTTPBadRequest(explanation=msg)
+        except exception.KeypairNotFound as error:
+            msg = _("Invalid key_name provided.")
+            raise exc.HTTPBadRequest(explanation=msg)
         except exception.SecurityGroupNotFound as error:
             raise exc.HTTPBadRequest(explanation=unicode(error))
         except RemoteError as err:
@@ -248,12 +247,12 @@ class CreateInstanceHelper(object):
             msg = _("Server name is an empty string")
             raise exc.HTTPBadRequest(explanation=msg)
 
-    def _get_kernel_ramdisk_from_image(self, req, image_id):
+    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 = self._image_service.show(context, image_id)
+        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
         kernel_id, ramdisk_id = self._do_get_kernel_ramdisk_from_image(
@@ -370,6 +369,16 @@ class CreateInstanceHelper(object):
 
         return networks
 
+    def _validate_user_data(self, user_data):
+        """Check if the user_data is encoded properly"""
+        if not user_data:
+            return
+        try:
+            user_data = base64.b64decode(user_data)
+        except TypeError:
+            expl = _('Userdata content cannot be decoded')
+            raise exc.HTTPBadRequest(explanation=expl)
+
 
 class ServerXMLDeserializer(wsgi.XMLDeserializer):
     """
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index bb403845d..571185169 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -22,6 +22,7 @@ from webob import exc
 import webob
 
 from nova import compute
+from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
@@ -96,17 +97,23 @@ class Controller(object):
         search_opts['recurse_zones'] = utils.bool_from_str(
                 search_opts.get('recurse_zones', False))
 
-        # If search by 'status', we need to convert it to 'state'
-        # If the status is unknown, bail.
-        # Leave 'state' in search_opts so compute can pass it on to
-        # child zones..
+        # If search by 'status', we need to convert it to 'vm_state'
+        # to pass on to child zones.
         if 'status' in search_opts:
             status = search_opts['status']
-            search_opts['state'] = common.power_states_from_status(status)
-            if len(search_opts['state']) == 0:
+            state = common.vm_state_from_status(status)
+            if state is None:
                 reason = _('Invalid server status: %(status)s') % locals()
-                LOG.error(reason)
                 raise exception.InvalidInput(reason=reason)
+            search_opts['vm_state'] = state
+
+        if 'changes-since' in search_opts:
+            try:
+                parsed = utils.parse_isotime(search_opts['changes-since'])
+            except ValueError:
+                msg = _('Invalid changes-since value')
+                raise exc.HTTPBadRequest(explanation=msg)
+            search_opts['changes-since'] = parsed
 
         # By default, compute's get_all() will return deleted instances.
         # If an admin hasn't specified a 'deleted' search option, we need
@@ -115,23 +122,17 @@ class Controller(object):
         # should return recently deleted images according to the API spec.
 
         if 'deleted' not in search_opts:
-            # Admin hasn't specified deleted filter
             if 'changes-since' not in search_opts:
-                # No 'changes-since', so we need to find non-deleted servers
+                # No 'changes-since', so we only want non-deleted servers
                 search_opts['deleted'] = False
-            else:
-                # This is the default, but just in case..
-                search_opts['deleted'] = True
 
-        instance_list = self.compute_api.get_all(
-                context, search_opts=search_opts)
-
-        # FIXME(comstud): 'changes-since' is not fully implemented.  Where
-        # should this be filtered?
+        instance_list = self.compute_api.get_all(context,
+                                                 search_opts=search_opts)
 
         limited_list = self._limit_items(instance_list, req)
         servers = [self._build_view(req, inst, is_detail)['server']
-                for inst in limited_list]
+                    for inst in limited_list]
+
         return dict(servers=servers)
 
     @scheduler_api.redirect_handler
@@ -144,10 +145,16 @@ class Controller(object):
         except exception.NotFound:
             raise exc.HTTPNotFound()
 
+    def _get_key_name(self, req, body):
+        """ Get default keypair if not set """
+        raise NotImplementedError()
+
     def create(self, req, body):
         """ Creates a new server for a given user """
+        if 'server' in body:
+            body['server']['key_name'] = self._get_key_name(req, body)
+
         extra_values = None
-        result = None
         extra_values, instances = self.helper.create_instance(
                 req, body, self.compute_api.create)
 
@@ -565,6 +572,13 @@ class ControllerV10(Controller):
             raise exc.HTTPNotFound()
         return webob.Response(status_int=202)
 
+    def _get_key_name(self, req, body):
+        context = req.environ["nova.context"]
+        keypairs = db.key_pair_get_all_by_user(context,
+                                               context.user_id)
+        if keypairs:
+            return keypairs[0]['name']
+
     def _image_ref_from_req_data(self, data):
         return data['server']['imageId']
 
@@ -609,9 +623,8 @@ class ControllerV10(Controller):
 
         try:
             self.compute_api.rebuild(context, instance_id, image_id, password)
-        except exception.BuildInProgress:
-            msg = _("Instance %s is currently being rebuilt.") % instance_id
-            LOG.debug(msg)
+        except exception.RebuildRequiresActiveInstance:
+            msg = _("Instance %s must be active to rebuild.") % instance_id
             raise exc.HTTPConflict(explanation=msg)
 
         return webob.Response(status_int=202)
@@ -636,6 +649,10 @@ class ControllerV11(Controller):
         except exception.NotFound:
             raise exc.HTTPNotFound()
 
+    def _get_key_name(self, req, body):
+        if 'server' in body:
+            return body['server'].get('key_name')
+
     def _image_ref_from_req_data(self, data):
         try:
             return data['server']['imageRef']
@@ -751,9 +768,8 @@ class ControllerV11(Controller):
             self.compute_api.rebuild(context, instance_id, image_href,
                                      password, name=name, metadata=metadata,
                                      files_to_inject=personalities)
-        except exception.BuildInProgress:
-            msg = _("Instance %s is currently being rebuilt.") % instance_id
-            LOG.debug(msg)
+        except exception.RebuildRequiresActiveInstance:
+            msg = _("Instance %s must be active to rebuild.") % instance_id
             raise exc.HTTPConflict(explanation=msg)
         except exception.InstanceNotFound:
             msg = _("Instance %s could not be found") % instance_id
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 0ec98591e..3a13d15f1 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -21,13 +21,12 @@ import hashlib
 import os
 
 from nova import exception
-import nova.compute
-import nova.context
 from nova.api.openstack import common
 from nova.api.openstack.views import addresses as addresses_view
 from nova.api.openstack.views import flavors as flavors_view
 from nova.api.openstack.views import images as images_view
 from nova import utils
+from nova.compute import vm_states
 
 
 class ViewBuilder(object):
@@ -61,17 +60,13 @@ class ViewBuilder(object):
 
     def _build_detail(self, inst):
         """Returns a detailed model of a server."""
+        vm_state = inst.get('vm_state', vm_states.BUILDING)
+        task_state = inst.get('task_state')
 
         inst_dict = {
             'id': inst['id'],
             'name': inst['display_name'],
-            'status': common.status_from_power_state(inst.get('state'))}
-
-        ctxt = nova.context.get_admin_context()
-        compute_api = nova.compute.API()
-
-        if compute_api.has_finished_migration(ctxt, inst['uuid']):
-            inst_dict['status'] = 'RESIZE-CONFIRM'
+            'status': common.status_from_state(vm_state, task_state)}
 
         # Return the metadata as a dictionary
         metadata = {}
@@ -188,6 +183,7 @@ class ViewBuilderV11(ViewBuilder):
     def _build_extra(self, response, inst):
         self._build_links(response, inst)
         response['uuid'] = inst['uuid']
+        response['key_name'] = inst.get('key_name', '')
         self._build_config_drive(response, inst)
 
     def _build_links(self, response, inst):