Merge and fix tests.

16 files changed, 202 insertions, 147 deletions

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 8bddf3032..a7a343938 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -84,17 +84,16 @@ def _gen_key(context, user_id, key_name):
 _STATE_DESCRIPTION_MAP = {
     None: 'pending',
     vm_states.ACTIVE: 'running',
-    vm_states.BUILD: 'pending',
-    vm_states.REBUILD: 'pending',
-    vm_states.REBOOT: 'reboot',
-    vm_states.DELETE: 'terminated',
-    vm_states.STOP: 'stopped',
-    vm_states.MIGRATE: 'migrate',
-    vm_states.RESIZE: 'resize',
+    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.VERIFY_RESIZE: 'verify_resize',
-    vm_states.PAUSE: 'pause',
-    vm_states.SUSPEND: 'suspend',
-    vm_states.RESCUE: 'rescue'
+    vm_states.PAUSED: 'pause',
+    vm_states.SUSPENDED: 'suspend',
+    vm_states.RESCUED: 'rescue'
 }
 
 
@@ -1065,8 +1064,8 @@ class CloudController(object):
         def _format_attr_instance_initiated_shutdown_behavior(instance,
                                                                result):
             vm_state = instance['vm_state']
-            state_to_value = {vm_states.STOP: 'stop',
-                              vm_states.DELETE: 'terminate'}
+            state_to_value = {vm_states.STOPPED: 'stop',
+                              vm_states.DELETED: 'terminate'}
             value = state_to_value.get(vm_state)
             if value:
                 result['instanceInitiatedShutdownBehavior'] = value
@@ -1645,7 +1644,7 @@ class CloudController(object):
             vm_state = instance['vm_state']
 
             # if the instance is in subtle state, refuse to proceed.
-            if vm_state not in (vm_states.ACTIVE, vm_states.STOP):
+            if vm_state not in (vm_states.ACTIVE, vm_states.STOPPED):
                 raise exception.InstanceNotRunning(instance_id=ec2_instance_id)
 
             if vm_state == vm_states.ACTIVE:
@@ -1654,7 +1653,7 @@ class CloudController(object):
 
             # wait instance for really stopped
             start_time = time.time()
-            while vm_state != vm_states.STOP:
+            while vm_state != vm_states.STOPPED:
                 time.sleep(1)
                 instance = self.compute_api.get(context, instance_id)
                 vm_state = instance['vm_state']
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 778c1e514..90b2095b8 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -40,32 +40,57 @@ XML_NS_V11 = 'http://docs.openstack.org/compute/api/v1.1'
 
 
 _STATE_MAP = {
-    vm_states.ACTIVE: 'ACTIVE',
-    vm_states.BUILD: 'BUILD',
-    vm_states.REBUILD: 'REBUILD',
-    vm_states.REBOOT: 'REBOOT',
-    vm_states.HARD_REBOOT: 'HARD_REBOOT',
-    vm_states.STOP: 'STOPPED',
-    vm_states.MIGRATE: 'MIGRATING',
-    vm_states.RESIZE: 'RESIZE',
-    vm_states.VERIFY_RESIZE: 'VERIFY_RESIZE',
-    vm_states.PAUSE: 'PAUSED',
-    vm_states.SUSPEND: 'SUSPENDED',
-    vm_states.RESCUE: 'RESCUE',
-    vm_states.ERROR: 'ERROR',
+    vm_states.ACTIVE: {
+        'default': 'ACTIVE',
+        task_states.REBOOTING: 'REBOOT',
+        task_states.HARD_REBOOTING: 'HARD_REBOOT',
+        task_states.PASSWORD: 'PASSWORD',
+    },
+    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.VERIFY_RESIZE: {
+        'default': 'VERIFY_RESIZE',
+    },
+    vm_states.PAUSED: {
+        'default': 'PAUSED',
+    },
+    vm_states.SUSPENDED: {
+        'default': 'SUSPENDED',
+    },
+    vm_states.RESCUED: {
+        'default': 'RESCUE',
+    },
+    vm_states.ERROR: {
+        'default': 'ERROR',
+    },
 }
 
 
-def status_from_state(_vm_state, task_state=None):
+def status_from_state(vm_state, task_state='default'):
     """Given vm_state and task_state, return a status string."""
-    if _vm_state == vm_states.ACTIVE and task_state == task_states.PASSWORD:
-        return "PASSWORD"
-    return _STATE_MAP.get(_vm_state, "UNKNOWN_STATE")
+    LOG.debug("Generating status for vm_state=%(vm_state)s "
+              "task_state=%(task_state)s." % locals())
+    task_map = _STATE_MAP.get(vm_state, dict(default='UNKNOWN_STATE'))
+    return task_map.get(task_state, task_map['default'])
 
 
 def vm_state_from_status(status):
     """Map the server status string to a vm state."""
-    for state, status_string in _STATE_MAP.iteritems():
+    for state, task_map in _STATE_MAP.iteritems():
+        status_string = task_map.get("default")
         if status.lower() == status_string.lower():
             return state
 
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 0d8eeb752..05d6b32c0 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -61,7 +61,7 @@ class ViewBuilder(object):
 
     def _build_detail(self, inst):
         """Returns a detailed model of a server."""
-        vm_state = inst.get('vm_state', vm_states.BUILD)
+        vm_state = inst.get('vm_state', vm_states.BUILDING)
         task_state = inst.get('task_state')
 
         inst_dict = {
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 0f993015b..8f70d3873 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -76,15 +76,18 @@ def generate_default_hostname(instance):
 
 
 def _is_able_to_shutdown(instance, instance_id):
-    states = {
-        vm_states.DELETE: "Instance %s is already being terminated",
-        vm_states.MIGRATE: "Instance %s is being migrated",
-        vm_states.RESIZE: "Instance %s is being resized",
-        vm_states.STOP: "Instance %s is being stopped",
-    }
-    msg = states.get(instance['vm_state'])
-    if msg:
-        LOG.warning(_(msg), instance_id)
+    vm_state = instance["vm_state"]
+    task_state = instance["task_state"]
+
+    valid_shutdown_states = [
+        vm_states.ACTIVE,
+        vm_states.REBUILDING,
+        vm_states.BUILDING,
+    ]
+
+    if vm_state not in valid_shutdown_states:
+        LOG.warn(_("Instance %(instance_id)s is not in an 'active' state. It "
+                   "is currently %(vm_state)s. Shutdown aborted.") % locals())
         return False
 
     return True
@@ -237,7 +240,7 @@ class API(base.Base):
             'kernel_id': kernel_id or '',
             'ramdisk_id': ramdisk_id or '',
             'power_state': power_state.NOSTATE,
-            'vm_state': vm_states.BUILD,
+            'vm_state': vm_states.BUILDING,
             'user_id': context.user_id,
             'project_id': context.project_id,
             'launch_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
@@ -398,7 +401,7 @@ class API(base.Base):
             updates['display_name'] = "Server %s" % instance_id
             instance['display_name'] = updates['display_name']
         updates['hostname'] = self.hostname_factory(instance)
-        updates['vm_state'] = vm_states.BUILD
+        updates['vm_state'] = vm_states.BUILDING
         updates['task_state'] = task_states.SCHEDULING
 
         instance = self.update(context, instance_id, **updates)
@@ -731,8 +734,8 @@ class API(base.Base):
 
         self.update(context,
                     instance_id,
-                    vm_state=vm_states.DELETE,
-                    terminated_at=utils.utcnow())
+                    vm_state=vm_states.ACTIVE,
+                    task_state=task_states.DELETING)
 
         host = instance['host']
         if host:
@@ -753,7 +756,8 @@ class API(base.Base):
 
         self.update(context,
                     instance_id,
-                    vm_state=vm_states.STOP,
+                    vm_state=vm_states.ACTIVE,
+                    task_state=task_states.STOPPING,
                     terminated_at=utils.utcnow())
 
         host = instance['host']
@@ -767,12 +771,15 @@ class API(base.Base):
         instance = self._get_instance(context, instance_id, 'starting')
         vm_state = instance["vm_state"]
 
-        if vm_state != vm_states.STOP:
+        if vm_state != vm_states.STOPPED:
             LOG.warning(_("Instance %(instance_id)s is not "
                           "stopped. (%(vm_state)s)") % locals())
             return
 
-        self.update(context, instance_id, vm_state=vm_states.ACTIVE)
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.STOPPED,
+                    task_state=task_states.STARTING)
 
         # TODO(yamahata): injected_files isn't supported right now.
         #                 It is used only for osapi. not for ec2 api.
@@ -1001,7 +1008,10 @@ class API(base.Base):
     @scheduler_api.reroute_compute("reboot")
     def reboot(self, context, instance_id):
         """Reboot the given instance."""
-        self.update(context, instance_id, vm_state=vm_states.REBOOT)
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.ACTIVE,
+                    task_state=task_states.REBOOTING)
         self._cast_compute_message('reboot_instance', context, instance_id)
 
     @scheduler_api.reroute_compute("rebuild")
@@ -1010,8 +1020,8 @@ class API(base.Base):
         """Rebuild the given instance with the provided metadata."""
         instance = db.api.instance_get(context, instance_id)
         invalid_rebuild_states = [
-            vm_states.BUILD,
-            vm_states.REBUILD,
+            vm_states.BUILDING,
+            vm_states.REBUILDING,
         ]
 
         if instance["vm_state"] in invalid_rebuild_states:
@@ -1019,23 +1029,23 @@ class API(base.Base):
             raise exception.BuildInProgress(msg)
 
         files_to_inject = files_to_inject or []
+        metadata = metadata or {}
+
         self._check_injected_file_quota(context, files_to_inject)
+        self._check_metadata_properties_quota(context, metadata)
 
-        values = {}
-        if metadata is not None:
-            self._check_metadata_properties_quota(context, metadata)
-            values['metadata'] = metadata
-        if name is not None:
-            values['display_name'] = name
-        self.db.instance_update(context, instance_id, values)
+        self.update(context,
+                    instance_id,
+                    metadata=metadata,
+                    display_name=name,
+                    vm_state=vm_states.ACTIVE,
+                    task_state=task_states.REBUILDING)
 
         rebuild_params = {
             "image_ref": image_href,
             "injected_files": files_to_inject,
         }
 
-        self.update(context, instance_id, vm_state=vm_states.REBUILD)
-
         self._cast_compute_message('rebuild_instance',
                                    context,
                                    instance_id,
@@ -1053,7 +1063,10 @@ class API(base.Base):
             raise exception.MigrationNotFoundByStatus(instance_id=instance_id,
                                                       status='finished')
 
-        self.update(context, instance_id, vm_state=vm_states.ACTIVE)
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.VERIFY_RESIZE,
+                    task_state=task_states.RESIZE_REVERTING)
 
         params = {'migration_id': migration_ref['id']}
         self._cast_compute_message('revert_resize', context,
@@ -1076,7 +1089,10 @@ class API(base.Base):
             raise exception.MigrationNotFoundByStatus(instance_id=instance_id,
                                                       status='finished')
 
-        self.update(context, instance_id, vm_state=vm_states.ACTIVE)
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.VERIFY_RESIZE,
+                    task_state=task_states.RESIZE_CONFIRMING)
 
         params = {'migration_id': migration_ref['id']}
         self._cast_compute_message('confirm_resize', context,
@@ -1123,7 +1139,10 @@ class API(base.Base):
         if (current_memory_mb == new_memory_mb) and flavor_id:
             raise exception.CannotResizeToSameSize()
 
-        self.update(context, instance_id, vm_state=vm_states.RESIZE)
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.ACTIVE,
+                    task_state=task_states.RESIZE_PREP)
 
         instance_ref = self._get_instance(context, instance_id, 'resize')
         self._cast_scheduler_message(context,
@@ -1158,13 +1177,19 @@ class API(base.Base):
     @scheduler_api.reroute_compute("pause")
     def pause(self, context, instance_id):
         """Pause the given instance."""
-        self.update(context, instance_id, vm_state=vm_states.PAUSE)
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.ACTIVE,
+                    task_state=task_states.PAUSING)
         self._cast_compute_message('pause_instance', context, instance_id)
 
     @scheduler_api.reroute_compute("unpause")
     def unpause(self, context, instance_id):
         """Unpause the given instance."""
-        self.update(context, instance_id, vm_state=vm_states.ACTIVE)
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.PAUSED,
+                    task_state=task_states.UNPAUSING)
         self._cast_compute_message('unpause_instance', context, instance_id)
 
     def _call_compute_message_for_host(self, action, context, host, params):
@@ -1197,25 +1222,37 @@ class API(base.Base):
     @scheduler_api.reroute_compute("suspend")
     def suspend(self, context, instance_id):
         """Suspend the given instance."""
-        self.update(context, instance_id, vm_state=vm_states.SUSPEND)
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.ACTIVE,
+                    task_state=task_states.SUSPENDING)
         self._cast_compute_message('suspend_instance', context, instance_id)
 
     @scheduler_api.reroute_compute("resume")
     def resume(self, context, instance_id):
         """Resume the given instance."""
-        self.update(context, instance_id, vm_state=vm_states.ACTIVE)
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.SUSPENDED,
+                    task_state=task_states.RESUMING)
         self._cast_compute_message('resume_instance', context, instance_id)
 
     @scheduler_api.reroute_compute("rescue")
     def rescue(self, context, instance_id):
         """Rescue the given instance."""
-        self.update(context, instance_id, vm_state=vm_states.RESCUE)
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.ACTIVE,
+                    task_state=task_states.RESCUING)
         self._cast_compute_message('rescue_instance', context, instance_id)
 
     @scheduler_api.reroute_compute("unrescue")
     def unrescue(self, context, instance_id):
         """Unrescue the given instance."""
-        self.update(context, instance_id, vm_state=vm_states.ACTIVE)
+        self.update(context,
+                    instance_id,
+                    vm_state=vm_states.RESCUED,
+                    task_state=task_states.UNRESCUING)
         self._cast_compute_message('unrescue_instance', context, instance_id)
 
     @scheduler_api.reroute_compute("set_admin_password")
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 75928f7ef..1c2f4ec62 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -372,7 +372,7 @@ class ComputeManager(manager.SchedulerDependentManager):
         updates = {}
         updates['host'] = self.host
         updates['launched_on'] = self.host
-        updates['vm_state'] = vm_states.BUILD
+        updates['vm_state'] = vm_states.BUILDING
         updates['task_state'] = task_states.NETWORKING
         instance = self.db.instance_update(context, instance_id, updates)
         instance['injected_files'] = kwargs.get('injected_files', [])
@@ -397,7 +397,7 @@ class ComputeManager(manager.SchedulerDependentManager):
 
             self._instance_update(context,
                                   instance_id,
-                                  vm_state=vm_states.BUILD,
+                                  vm_state=vm_states.BUILDING,
                                   task_state=task_states.BLOCK_DEVICE_MAPPING)
 
             (swap, ephemerals,
@@ -411,6 +411,7 @@ class ComputeManager(manager.SchedulerDependentManager):
 
             self._instance_update(context,
                                   instance_id,
+                                  vm_state=vm_states.BUILDING,
                                   task_state=task_states.SPAWN)
 
             # TODO(vish) check to make sure the availability zone matches
@@ -487,6 +488,11 @@ class ComputeManager(manager.SchedulerDependentManager):
         """Terminate an instance on this host."""
         self._shutdown_instance(context, instance_id, 'Terminating')
         instance = self.db.instance_get(context.elevated(), instance_id)
+        self._instance_update(context,
+                              instance_id,
+                              vm_state=vm_states.DELETED,
+                              task_state=None,
+                              terminated_at=utils.utcnow())
 
         # TODO(ja): should we keep it in a terminated state for a bit?
         self.db.instance_destroy(context, instance_id)
@@ -500,7 +506,10 @@ class ComputeManager(manager.SchedulerDependentManager):
     def stop_instance(self, context, instance_id):
         """Stopping an instance on this host."""
         self._shutdown_instance(context, instance_id, 'Stopping')
-        # instance state will be updated to stopped by _poll_instance_states()
+        self._instance_update(context,
+                              instance_id,
+                              vm_state=vm_states.STOPPED,
+                              task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
@@ -523,15 +532,15 @@ class ComputeManager(manager.SchedulerDependentManager):
         self._instance_update(context,
                               instance_id,
                               power_state=current_power_state,
-                              vm_state=vm_states.REBUILD,
-                              task_state=task_states.REBUILDING)
+                              vm_state=vm_states.REBUILDING,
+                              task_state=None)
 
         network_info = self._get_instance_nw_info(context, instance_ref)
         self.driver.destroy(instance_ref, network_info)
 
         self._instance_update(context,
                               instance_id,
-                              vm_state=vm_states.REBUILD,
+                              vm_state=vm_states.REBUILDING,
                               task_state=task_states.BLOCK_DEVICE_MAPPING)
 
         bd_mapping = self._setup_block_device_mapping(context, instance_id)
@@ -544,7 +553,7 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         self._instance_update(context,
                               instance_id,
-                              vm_state=vm_states.REBUILD,
+                              vm_state=vm_states.REBUILDING,
                               task_state=task_states.SPAWN)
 
         self.driver.spawn(context, instance_ref, network_info, bd_mapping)
@@ -577,7 +586,7 @@ class ComputeManager(manager.SchedulerDependentManager):
         self._instance_update(context,
                               instance_id,
                               power_state=current_power_state,
-                              vm_state=vm_states.REBOOT,
+                              vm_state=vm_states.ACTIVE,
                               task_state=task_states.REBOOTING)
 
         if instance_ref['power_state'] != power_state.RUNNING:
@@ -612,7 +621,11 @@ class ComputeManager(manager.SchedulerDependentManager):
         :param rotation: int representing how many backups to keep around;
             None if rotation shouldn't be used (as in the case of snapshots)
         """
-        if image_type != "snapshot" and image_type != "backup":
+        if image_type == "snapshot":
+            task_state = task_states.SNAPSHOTTING
+        elif image_type == "backup":
+            task_state = task_states.BACKING_UP
+        else:
             raise Exception(_('Image type not recognized %s') % image_type)
 
         context = context.elevated()
@@ -623,7 +636,7 @@ class ComputeManager(manager.SchedulerDependentManager):
                               instance_id,
                               power_state=current_power_state,
                               vm_state=vm_states.ACTIVE,
-                              task_state=image_type)
+                              task_state=task_state)
 
         LOG.audit(_('instance %s: snapshotting'), instance_id,
                   context=context)
@@ -785,11 +798,6 @@ class ComputeManager(manager.SchedulerDependentManager):
         LOG.audit(_('instance %s: rescuing'), instance_id, context=context)
         context = context.elevated()
 
-        self._instance_update(context,
-                              instance_id,
-                              vm_state=vm_states.RESCUE,
-                              task_state=task_states.RESCUING)
-
         instance_ref = self.db.instance_get(context, instance_id)
         network_info = self._get_instance_nw_info(context, instance_ref)
 
@@ -799,8 +807,8 @@ class ComputeManager(manager.SchedulerDependentManager):
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
                               instance_id,
-                              vm_state=vm_states.RESCUE,
-                              task_state=task_states.RESCUED,
+                              vm_state=vm_states.RESCUED,
+                              task_state=None,
                               power_state=current_power_state)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
@@ -810,11 +818,6 @@ class ComputeManager(manager.SchedulerDependentManager):
         LOG.audit(_('instance %s: unrescuing'), instance_id, context=context)
         context = context.elevated()
 
-        self._instance_update(context,
-                              instance_id,
-                              vm_state=vm_states.ACTIVE,
-                              task_state=task_states.UNRESCUING)
-
         instance_ref = self.db.instance_get(context, instance_id)
         network_info = self._get_instance_nw_info(context, instance_ref)
 
@@ -1046,11 +1049,6 @@ class ComputeManager(manager.SchedulerDependentManager):
         LOG.audit(_('instance %s: pausing'), instance_id, context=context)
         context = context.elevated()
 
-        self._instance_update(context,
-                              instance_id,
-                              vm_state=vm_states.PAUSE,
-                              task_state=task_states.PAUSING)
-
         instance_ref = self.db.instance_get(context, instance_id)
         self.driver.pause(instance_ref, lambda result: None)
 
@@ -1058,7 +1056,7 @@ class ComputeManager(manager.SchedulerDependentManager):
         self._instance_update(context,
                               instance_id,
                               power_state=current_power_state,
-                              vm_state=vm_states.PAUSE,
+                              vm_state=vm_states.PAUSED,
                               task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
@@ -1068,11 +1066,6 @@ class ComputeManager(manager.SchedulerDependentManager):
         LOG.audit(_('instance %s: unpausing'), instance_id, context=context)
         context = context.elevated()
 
-        self._instance_update(context,
-                              instance_id,
-                              vm_state=vm_states.ACTIVE,
-                              task_state=task_states.UNPAUSING)
-
         instance_ref = self.db.instance_get(context, instance_id)
         self.driver.unpause(instance_ref, lambda result: None)
 
@@ -1109,11 +1102,6 @@ class ComputeManager(manager.SchedulerDependentManager):
         LOG.audit(_('instance %s: suspending'), instance_id, context=context)
         context = context.elevated()
 
-        self._instance_update(context,
-                              instance_id,
-                              vm_state=vm_states.SUSPEND,
-                              task_state=task_states.SUSPENDING)
-
         instance_ref = self.db.instance_get(context, instance_id)
         self.driver.suspend(instance_ref, lambda result: None)
 
@@ -1121,7 +1109,7 @@ class ComputeManager(manager.SchedulerDependentManager):
         self._instance_update(context,
                               instance_id,
                               power_state=current_power_state,
-                              vm_state=vm_states.SUSPEND,
+                              vm_state=vm_states.SUSPENDED,
                               task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
@@ -1131,11 +1119,6 @@ class ComputeManager(manager.SchedulerDependentManager):
         LOG.audit(_('instance %s: resuming'), instance_id, context=context)
         context = context.elevated()
 
-        self._instance_update(context,
-                              instance_id,
-                              vm_state=vm_states.ACTIVE,
-                              task_state=task_states.RESUMING)
-
         instance_ref = self.db.instance_get(context, instance_id)
         self.driver.resume(instance_ref, lambda result: None)
 
diff --git a/nova/compute/task_states.py b/nova/compute/task_states.py
index 885a30ebe..d186edc3f 100644
--- a/nova/compute/task_states.py
+++ b/nova/compute/task_states.py
@@ -22,18 +22,21 @@ BLOCK_DEVICE_MAPPING='block_device_mapping'
 NETWORKING='networking'
 SPAWN='spawn'
 
-SNAPSHOT='snapshot'
-BACKUP='backup'
+SNAPSHOTTING='snapshotting'
+BACKING_UP='backing_up'
 PASSWORD='password'
 
 RESIZE_PREP='resize_prep'
 RESIZE_MIGRATING='resize_migrating'
 RESIZE_MIGRATED='resize_migrated'
 RESIZE_FINISH='resize_finish'
+RESIZE_REVERTING='resize_reverting'
+RESIZE_CONFIRMING='resize_confirming'
 
 REBUILDING='rebuilding'
 
 REBOOTING='rebooting'
+HARD_REBOOTING='hard_rebooting'
 PAUSING='pausing'
 UNPAUSING='unpausing'
 SUSPENDING='suspending'
@@ -42,3 +45,7 @@ RESUMING='resuming'
 RESCUING='rescuing'
 RESCUED='rescued'
 UNRESCUING='unrescuing'
+
+DELETING='deleting'
+STOPPING='stopping'
+STARTING='starting'
diff --git a/nova/compute/vm_states.py b/nova/compute/vm_states.py
index d3d168001..342fa905e 100644
--- a/nova/compute/vm_states.py
+++ b/nova/compute/vm_states.py
@@ -18,16 +18,17 @@
 """Possible vm states for instances"""
 
 ACTIVE='active'
-BUILD='build'
-REBUILD='rebuild'
-REBOOT='reboot'
-HARD_REBOOT='hard_reboot'
-DELETE='delete'
-STOP='stop'
-MIGRATE='migrate'
-RESIZE='resize'
+BUILDING='building'
+REBUILDING='rebuilding'
+
+PAUSED='paused'
+SUSPENDED='suspended'
+RESCUED='rescued'
+DELETED='deleted'
+STOPPED='stopped'
+
+MIGRATING='migrating'
+RESIZING='resizing'
 VERIFY_RESIZE='verify_resize'
-PAUSE='pause'
-SUSPEND='suspend'
-RESCUE='rescue'
+
 ERROR='error'
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index a5ed2363f..3e690e094 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1239,7 +1239,7 @@ def instance_get_all_by_filters(context, filters):
     # Filters for exact matches that we can do along with the SQL query...
     # For other filters that don't match this, we will do regexp matching
     exact_match_filter_names = ['project_id', 'user_id', 'image_ref',
-            'state', 'instance_type_id', 'deleted']
+            'vm_state', 'instance_type_id', 'deleted']
 
     query_filters = [key for key in filters.iterkeys()
             if key in exact_match_filter_names]
diff --git a/nova/exception.py b/nova/exception.py
index e8cb7bcb5..eaeea24e3 100644
--- a/nova/exception.py
+++ b/nova/exception.py
@@ -318,9 +318,6 @@ class InvalidEc2Id(Invalid):
 class NotFound(NovaException):
     message = _("Resource could not be found.")
 
-    def __init__(self, *args, **kwargs):
-        super(NotFound, self).__init__(**kwargs)
-
 
 class FlagNotSet(NotFound):
     message = _("Required flag %(flag)s not set.")
diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py
index fd00ce495..22f4e14f9 100644
--- a/nova/scheduler/driver.py
+++ b/nova/scheduler/driver.py
@@ -105,7 +105,7 @@ class Scheduler(object):
                                           dest, block_migration)
 
         # Changing instance_state.
-        values = {"vm_state": vm_states.MIGRATE}
+        values = {"vm_state": vm_states.MIGRATING}
         db.instance_update(context, instance_id, values)
 
         # Changing volume state
diff --git a/nova/tests/api/openstack/test_server_actions.py b/nova/tests/api/openstack/test_server_actions.py
index 011f83773..d2755e1d9 100644
--- a/nova/tests/api/openstack/test_server_actions.py
+++ b/nova/tests/api/openstack/test_server_actions.py
@@ -165,7 +165,7 @@ class ServerActionsTest(test.TestCase):
             },
         }
 
-        state = vm_states.BUILD
+        state = vm_states.BUILDING
         new_return_server = return_server_with_state(state)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
         self.stubs.Set(nova.db, 'instance_get_by_uuid',
@@ -628,7 +628,7 @@ class ServerActionsTestV11(test.TestCase):
             },
         }
 
-        state = vm_states.BUILD
+        state = vm_states.BUILDING
         new_return_server = return_server_with_state(state)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
         self.stubs.Set(nova.db, 'instance_get_by_uuid',
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index dc037d10e..f1d5e608a 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -188,7 +188,7 @@ def stub_instance(id, user_id='fake', project_id='fake', private_address=None,
         "launch_index": 0,
         "key_name": "",
         "key_data": "",
-        "vm_state": vm_state or vm_states.BUILD,
+        "vm_state": vm_state or vm_states.BUILDING,
         "task_state": task_state,
         "memory_mb": 0,
         "vcpus": 0,
@@ -2313,15 +2313,17 @@ class TestServerStatus(test.TestCase):
         self.assertEqual(response['server']['status'], 'ACTIVE')
 
     def test_reboot(self):
-        response = self._get_with_state(vm_states.REBOOT)
+        response = self._get_with_state(vm_states.ACTIVE,
+                                        task_states.REBOOTING)
         self.assertEqual(response['server']['status'], 'REBOOT')
 
     def test_hard_reboot(self):
-        response = self._get_with_state(vm_states.HARD_REBOOT)
+        response = self._get_with_state(vm_states.ACTIVE,
+                                        task_states.HARD_REBOOTING)
         self.assertEqual(response['server']['status'], 'HARD_REBOOT')
 
     def test_rebuild(self):
-        response = self._get_with_state(vm_states.REBUILD)
+        response = self._get_with_state(vm_states.REBUILDING)
         self.assertEqual(response['server']['status'], 'REBUILD')
 
     def test_rebuild_error(self):
@@ -2329,7 +2331,7 @@ class TestServerStatus(test.TestCase):
         self.assertEqual(response['server']['status'], 'ERROR')
 
     def test_resize(self):
-        response = self._get_with_state(vm_states.RESIZE)
+        response = self._get_with_state(vm_states.RESIZING)
         self.assertEqual(response['server']['status'], 'RESIZE')
 
     def test_verify_resize(self):
@@ -2341,7 +2343,7 @@ class TestServerStatus(test.TestCase):
         self.assertEqual(response['server']['status'], 'PASSWORD')
 
     def test_stopped(self):
-        response = self._get_with_state(vm_states.STOP)
+        response = self._get_with_state(vm_states.STOPPED)
         self.assertEqual(response['server']['status'], 'STOPPED')
 
 
@@ -3235,7 +3237,7 @@ class ServersViewBuilderV11Test(test.TestCase):
             "launch_index": 0,
             "key_name": "",
             "key_data": "",
-            "vm_state": vm_states.BUILD,
+            "vm_state": vm_states.BUILDING,
             "task_state": None,
             "memory_mb": 0,
             "vcpus": 0,
diff --git a/nova/tests/scheduler/test_scheduler.py b/nova/tests/scheduler/test_scheduler.py
index a1281ae73..a52dd041a 100644
--- a/nova/tests/scheduler/test_scheduler.py
+++ b/nova/tests/scheduler/test_scheduler.py
@@ -669,7 +669,7 @@ class SimpleDriverTestCase(test.TestCase):
                                       block_migration=False)
 
         i_ref = db.instance_get(self.context, instance_id)
-        self.assertTrue(i_ref['vm_state'] == vm_states.MIGRATE)
+        self.assertTrue(i_ref['vm_state'] == vm_states.MIGRATING)
         db.instance_destroy(self.context, instance_id)
         db.volume_destroy(self.context, v_ref['id'])
 
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index 4d148f39e..9d58b7341 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -1175,12 +1175,16 @@ class CloudTestCase(test.TestCase):
 
     def _wait_for_running(self, instance_id):
         def is_running(info):
-            return info['vm_state'] == vm_states.ACTIVE
+            vm_state = info["vm_state"]
+            task_state = info["task_state"]
+            return vm_state == vm_states.ACTIVE and task_state == None
         self._wait_for_state(self.context, instance_id, is_running)
 
     def _wait_for_stopped(self, instance_id):
         def is_stopped(info):
-            return info['vm_state'] == vm_states.STOP
+            vm_state = info["vm_state"]
+            task_state = info["task_state"]
+            return vm_state == vm_states.STOPPED and task_state == None
         self._wait_for_state(self.context, instance_id, is_stopped)
 
     def _wait_for_terminate(self, instance_id):
@@ -1563,7 +1567,7 @@ class CloudTestCase(test.TestCase):
                 'id': 0,
                 'root_device_name': '/dev/sdh',
                 'security_groups': [{'name': 'fake0'}, {'name': 'fake1'}],
-                'vm_state': vm_states.STOP,
+                'vm_state': vm_states.STOPPED,
                 'instance_type': {'name': 'fake_type'},
                 'kernel_id': 1,
                 'ramdisk_id': 2,
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index ca1bbc69f..6469ace7f 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -826,7 +826,7 @@ class ComputeTestCase(test.TestCase):
         c = context.get_admin_context()
         instance_id = self._create_instance()
         i_ref = db.instance_get(c, instance_id)
-        db.instance_update(c, i_ref['id'], {'vm_state': vm_states.MIGRATE,
+        db.instance_update(c, i_ref['id'], {'vm_state': vm_states.MIGRATING,
                                             'power_state': power_state.PAUSED})
         v_ref = db.volume_create(c, {'size': 1, 'instance_id': instance_id})
         fix_addr = db.fixed_ip_create(c, {'address': '1.1.1.1',
diff --git a/nova/tests/vmwareapi/db_fakes.py b/nova/tests/vmwareapi/db_fakes.py
index b56956f96..0d896239a 100644
--- a/nova/tests/vmwareapi/db_fakes.py
+++ b/nova/tests/vmwareapi/db_fakes.py
@@ -66,7 +66,7 @@ def stub_out_db_instance_api(stubs):
             'image_ref': values['image_ref'],

             'kernel_id': values['kernel_id'],

             'ramdisk_id': values['ramdisk_id'],

-            'vm_state': vm_states.BUILD,

+            'vm_state': vm_states.BUILDING,

             'task_state': task_states.SCHEDULING,

             'user_id': values['user_id'],

             'project_id': values['project_id'],