merging trunk

7 files changed, 395 insertions, 83 deletions

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 d9eb832f2..d743a66ef 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -27,7 +27,8 @@ from nova import flags
 from nova import log as logging
 from nova import quota
 from nova.api.openstack import wsgi
-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')
@@ -38,36 +39,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..69b38e229
--- /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['state_description']
+
+            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/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 483ff4985..fd9247f79 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
@@ -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:
@@ -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 e0e40679a..977958f5d 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -22,6 +22,7 @@ from xml.dom import minidom
 import webob
 
 from nova import compute
+from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
@@ -95,17 +96,15 @@ 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:
@@ -145,10 +144,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)
 
@@ -566,6 +571,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']
 
@@ -610,9 +622,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)
@@ -637,6 +648,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']
@@ -752,9 +767,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):