vm state and task state management

partially implements bp task-management
fixes bug 997867

also see http://wiki.openstack.org/VMState

Refactored the following API/state:
* rebuild
* migrate
* resize
* start
* stop
* delete
* soft delete
* rework sync_power_state in compute/manager.

fix broken tests, add transition diagram in dot

Change-Id: I3c5a97508a6dad7175fba12828bd3fa6ef1e50ee

7 files changed, 53 insertions, 38 deletions

diff --git a/nova/tests/api/ec2/test_cloud.py b/nova/tests/api/ec2/test_cloud.py
index a6853a610..6dd6fe916 100644
--- a/nova/tests/api/ec2/test_cloud.py
+++ b/nova/tests/api/ec2/test_cloud.py
@@ -854,7 +854,7 @@ class CloudTestCase(test.TestCase):
         test_instance_state(inst_state.RUNNING_CODE, inst_state.RUNNING,
                             power_state.RUNNING, vm_states.ACTIVE)
         test_instance_state(inst_state.STOPPED_CODE, inst_state.STOPPED,
-                            power_state.NOSTATE, vm_states.SHUTOFF,
+                            power_state.NOSTATE, vm_states.STOPPED,
                             {'shutdown_terminate': False})
 
     def test_describe_instances_no_ipv6(self):
diff --git a/nova/tests/api/openstack/compute/contrib/test_admin_actions.py b/nova/tests/api/openstack/compute/contrib/test_admin_actions.py
index 922e09f0b..3b96b552e 100644
--- a/nova/tests/api/openstack/compute/contrib/test_admin_actions.py
+++ b/nova/tests/api/openstack/compute/contrib/test_admin_actions.py
@@ -57,7 +57,8 @@ def fake_compute_api_raises_invalid_state(*args, **kwargs):
 
 
 def fake_compute_api_get(self, context, instance_id):
-    return {'id': 1, 'uuid': instance_id, 'vm_state': vm_states.ACTIVE}
+    return {'id': 1, 'uuid': instance_id, 'vm_state': vm_states.ACTIVE,
+            'task_state': None}
 
 
 def fake_scheduler_api_live_migration(self, context, block_migration,
diff --git a/nova/tests/api/openstack/compute/test_server_actions.py b/nova/tests/api/openstack/compute/test_server_actions.py
index b82185312..3e3b4eafc 100644
--- a/nova/tests/api/openstack/compute/test_server_actions.py
+++ b/nova/tests/api/openstack/compute/test_server_actions.py
@@ -19,6 +19,7 @@ import mox
 import webob
 
 from nova.api.openstack.compute import servers
+from nova.compute import task_states
 from nova.compute import vm_states
 import nova.db
 from nova import exception
@@ -461,8 +462,8 @@ class ServerActionsControllerTest(test.TestCase):
         context = req.environ['nova.context']
         update(context, mox.IgnoreArg(),
                 image_ref=self._image_href,
-                vm_state=vm_states.REBUILDING,
-                task_state=None, progress=0, **attributes).AndReturn(None)
+                task_state=task_states.REBUILDING,
+                progress=0, **attributes).AndReturn(None)
         self.mox.ReplayAll()
 
         self.controller._action_rebuild(req, FAKE_UUID, body)
diff --git a/nova/tests/api/openstack/compute/test_servers.py b/nova/tests/api/openstack/compute/test_servers.py
index fbc60da68..613747ce5 100644
--- a/nova/tests/api/openstack/compute/test_servers.py
+++ b/nova/tests/api/openstack/compute/test_servers.py
@@ -1331,16 +1331,17 @@ class ServersControllerTest(test.TestCase):
         self.server_delete_called = False
 
         self.stubs.Set(nova.db, 'instance_get_by_uuid',
-                fakes.fake_instance_get(vm_state=vm_states.RESIZING))
+                fakes.fake_instance_get(vm_state=vm_states.ACTIVE,
+                                        task_state=task_states.RESIZE_PREP))
 
-        def instance_destroy_mock(context, id):
+        def instance_destroy_mock(*args, **kwargs):
             self.server_delete_called = True
         self.stubs.Set(nova.db, 'instance_destroy', instance_destroy_mock)
 
-        self.assertRaises(webob.exc.HTTPConflict,
-                          self.controller.delete,
-                          req,
-                          FAKE_UUID)
+        self.controller.delete(req, FAKE_UUID)
+        # Delete shoud be allowed in any case, even during resizing,
+        # because it may get stuck.
+        self.assertEqual(self.server_delete_called, True)
 
 
 class ServerStatusTest(test.TestCase):
@@ -1374,7 +1375,8 @@ class ServerStatusTest(test.TestCase):
         self.assertEqual(response['server']['status'], 'HARD_REBOOT')
 
     def test_rebuild(self):
-        response = self._get_with_state(vm_states.REBUILDING)
+        response = self._get_with_state(vm_states.ACTIVE,
+                                        task_states.REBUILDING)
         self.assertEqual(response['server']['status'], 'REBUILD')
 
     def test_rebuild_error(self):
@@ -1382,16 +1384,16 @@ class ServerStatusTest(test.TestCase):
         self.assertEqual(response['server']['status'], 'ERROR')
 
     def test_resize(self):
-        response = self._get_with_state(vm_states.RESIZING)
+        response = self._get_with_state(vm_states.ACTIVE,
+                                        task_states.RESIZE_PREP)
         self.assertEqual(response['server']['status'], 'RESIZE')
 
     def test_verify_resize(self):
-        response = self._get_with_state(vm_states.ACTIVE,
-                                        task_states.RESIZE_VERIFY)
+        response = self._get_with_state(vm_states.RESIZED, None)
         self.assertEqual(response['server']['status'], 'VERIFY_RESIZE')
 
     def test_revert_resize(self):
-        response = self._get_with_state(vm_states.RESIZING,
+        response = self._get_with_state(vm_states.RESIZED,
                                         task_states.RESIZE_REVERTING)
         self.assertEqual(response['server']['status'], 'REVERT_RESIZE')
 
diff --git a/nova/tests/compute/test_compute.py b/nova/tests/compute/test_compute.py
index 0a90a754c..c816acc95 100644
--- a/nova/tests/compute/test_compute.py
+++ b/nova/tests/compute/test_compute.py
@@ -44,9 +44,9 @@ from nova import log as logging
 from nova.notifier import test_notifier
 from nova.openstack.common import importutils
 from nova.openstack.common import policy as common_policy
-from nova.openstack.common import timeutils
 from nova.openstack.common import rpc
 from nova.openstack.common.rpc import common as rpc_common
+from nova.openstack.common import timeutils
 import nova.policy
 from nova import quota
 from nova.scheduler import driver as scheduler_driver
@@ -1518,7 +1518,7 @@ class ComputeTestCase(BaseTestCase):
         instance_id = instance['id']
         i_ref = db.instance_get(c, instance_id)
         db.instance_update(c, i_ref['uuid'],
-                           {'vm_state': vm_states.MIGRATING,
+                           {'task_state': task_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',
@@ -1579,7 +1579,7 @@ class ComputeTestCase(BaseTestCase):
         instances = db.instance_get_all(ctxt)
         LOG.info(_("After force-killing instances: %s"), instances)
         self.assertEqual(len(instances), 1)
-        self.assertEqual(power_state.NOSTATE, instances[0]['power_state'])
+        self.assertEqual(task_states.STOPPING, instances[0]['task_state'])
 
     def test_add_instance_fault(self):
         exc_info = None
@@ -1819,17 +1819,17 @@ class ComputeTestCase(BaseTestCase):
         self.assertEqual(call_info['get_nw_info'], 4)
 
     def test_poll_unconfirmed_resizes(self):
-        instances = [{'uuid': 'fake_uuid1', 'vm_state': vm_states.ACTIVE,
-                      'task_state': task_states.RESIZE_VERIFY},
+        instances = [{'uuid': 'fake_uuid1', 'vm_state': vm_states.RESIZED,
+                      'task_state': None},
                      {'uuid': 'noexist'},
                      {'uuid': 'fake_uuid2', 'vm_state': vm_states.ERROR,
-                      'task_state': task_states.RESIZE_VERIFY},
+                      'task_state': None},
                      {'uuid': 'fake_uuid3', 'vm_state': vm_states.ACTIVE,
                       'task_state': task_states.REBOOTING},
                      {'uuid': 'fake_uuid4', 'vm_state': vm_states.ACTIVE,
-                      'task_state': task_states.RESIZE_VERIFY},
+                      'task_state': None},
                      {'uuid': 'fake_uuid5', 'vm_state': vm_states.ACTIVE,
-                      'task_state': task_states.RESIZE_VERIFY}]
+                      'task_state': None}]
         expected_migration_status = {'fake_uuid1': 'confirmed',
                                      'noexist': 'error',
                                      'fake_uuid2': 'error',
@@ -2261,12 +2261,12 @@ class ComputeAPITestCase(BaseTestCase):
         # the instance is shutdown by itself
         db.instance_update(self.context, instance['uuid'],
                            {'power_state': power_state.NOSTATE,
-                            'vm_state': vm_states.SHUTOFF})
-        check_state(instance['uuid'], power_state.NOSTATE, vm_states.SHUTOFF,
+                            'vm_state': vm_states.STOPPED})
+        check_state(instance['uuid'], power_state.NOSTATE, vm_states.STOPPED,
                     None)
 
         start_check_state(instance['uuid'], power_state.NOSTATE,
-                          vm_states.SHUTOFF, task_states.STARTING)
+                          vm_states.STOPPED, task_states.STARTING)
 
         db.instance_destroy(self.context, instance['uuid'])
 
@@ -2344,7 +2344,8 @@ class ComputeAPITestCase(BaseTestCase):
 
         # set the state that the instance gets when soft_delete finishes
         instance = db.instance_update(self.context, instance['uuid'],
-                                      {'vm_state': vm_states.SOFT_DELETE})
+                                      {'vm_state': vm_states.SOFT_DELETED,
+                                       'task_state': None})
 
         self.compute_api.force_delete(self.context, instance)
 
@@ -2432,7 +2433,8 @@ class ComputeAPITestCase(BaseTestCase):
 
         # set the state that the instance gets when soft_delete finishes
         instance = db.instance_update(self.context, instance['uuid'],
-                                      {'vm_state': vm_states.SOFT_DELETE})
+                                      {'vm_state': vm_states.SOFT_DELETED,
+                                       'task_state': None})
 
         self.compute_api.restore(self.context, instance)
 
@@ -2476,7 +2478,7 @@ class ComputeAPITestCase(BaseTestCase):
         self.assertEqual(info['image_ref'], image_ref)
 
         instance = db.instance_get_by_uuid(self.context, instance_uuid)
-        self.assertEqual(instance['vm_state'], vm_states.REBUILDING)
+        self.assertEqual(instance['task_state'], task_states.REBUILDING)
         sys_metadata = db.instance_system_metadata_get(self.context,
                 instance_uuid)
         self.assertEqual(sys_metadata,
@@ -2772,8 +2774,8 @@ class ComputeAPITestCase(BaseTestCase):
                  'status': 'finished'})
         # set the state that the instance gets when resize finishes
         instance = db.instance_update(self.context, instance['uuid'],
-                                      {'task_state': task_states.RESIZE_VERIFY,
-                                       'vm_state': vm_states.ACTIVE})
+                                      {'task_state': None,
+                                       'vm_state': vm_states.RESIZED})
 
         self.compute_api.confirm_resize(context, instance)
         self.compute.terminate_instance(context, instance['uuid'])
@@ -2792,13 +2794,13 @@ class ComputeAPITestCase(BaseTestCase):
                  'status': 'finished'})
         # set the state that the instance gets when resize finishes
         instance = db.instance_update(self.context, instance['uuid'],
-                                      {'task_state': task_states.RESIZE_VERIFY,
-                                       'vm_state': vm_states.ACTIVE})
+                                      {'task_state': None,
+                                       'vm_state': vm_states.RESIZED})
 
         self.compute_api.revert_resize(context, instance)
 
         instance = db.instance_get_by_uuid(context, instance['uuid'])
-        self.assertEqual(instance['vm_state'], vm_states.RESIZING)
+        self.assertEqual(instance['vm_state'], vm_states.RESIZED)
         self.assertEqual(instance['task_state'], task_states.RESIZE_REVERTING)
 
         self.compute.terminate_instance(context, instance['uuid'])
diff --git a/nova/tests/scheduler/test_scheduler.py b/nova/tests/scheduler/test_scheduler.py
index 9979c5e04..5d1d6c8e9 100644
--- a/nova/tests/scheduler/test_scheduler.py
+++ b/nova/tests/scheduler/test_scheduler.py
@@ -22,6 +22,7 @@ Tests For Scheduler
 from nova.compute import api as compute_api
 from nova.compute import power_state
 from nova.compute import rpcapi as compute_rpcapi
+from nova.compute import task_states
 from nova.compute import vm_states
 from nova import context
 from nova import db
@@ -454,7 +455,7 @@ class SchedulerTestCase(test.TestCase):
         self.driver._live_migration_common_check(self.context, instance,
                 dest, block_migration, disk_over_commit)
         db.instance_update_and_get_original(self.context, instance['id'],
-                {"vm_state": vm_states.MIGRATING}).AndReturn(
+                {"task_state": task_states.MIGRATING}).AndReturn(
                         (instance, instance))
 
         driver.cast_to_compute_host(self.context, instance['host'],
@@ -563,7 +564,7 @@ class SchedulerTestCase(test.TestCase):
                 ).AndReturn(True)
 
         db.instance_update_and_get_original(self.context, instance['id'],
-                {"vm_state": vm_states.MIGRATING}).AndReturn(
+                {"task_state": task_states.MIGRATING}).AndReturn(
                         (instance, instance))
 
         driver.cast_to_compute_host(self.context, instance['host'],
diff --git a/nova/tests/test_imagecache.py b/nova/tests/test_imagecache.py
index 4b1b5dac4..43ee7ed93 100644
--- a/nova/tests/test_imagecache.py
+++ b/nova/tests/test_imagecache.py
@@ -26,7 +26,7 @@ import time
 
 from nova import test
 
-from nova.compute import task_states
+from nova.compute import vm_states
 from nova import db
 from nova import flags
 from nova import log
@@ -150,16 +150,19 @@ class ImageCacheManagerTestCase(test.TestCase):
                                    'host': FLAGS.host,
                                    'name': 'inst-1',
                                    'uuid': '123',
+                                   'vm_state': '',
                                    'task_state': ''},
                                   {'image_ref': '2',
                                    'host': FLAGS.host,
                                    'name': 'inst-2',
                                    'uuid': '456',
+                                   'vm_state': '',
                                    'task_state': ''},
                                   {'image_ref': '2',
                                    'host': 'remotehost',
                                    'name': 'inst-3',
                                    'uuid': '789',
+                                   'vm_state': '',
                                    'task_state': ''}])
 
         image_cache_manager = imagecache.ImageCacheManager()
@@ -183,7 +186,8 @@ class ImageCacheManagerTestCase(test.TestCase):
                                    'host': FLAGS.host,
                                    'name': 'inst-1',
                                    'uuid': '123',
-                                   'task_state': task_states.RESIZE_VERIFY}])
+                                   'vm_state': vm_states.RESIZED,
+                                   'task_state': None}])
 
         image_cache_manager = imagecache.ImageCacheManager()
         image_cache_manager._list_running_instances(None)
@@ -766,11 +770,13 @@ class ImageCacheManagerTestCase(test.TestCase):
                                    'host': FLAGS.host,
                                    'name': 'instance-1',
                                    'uuid': '123',
+                                   'vm_state': '',
                                    'task_state': ''},
                                   {'image_ref': '1',
                                    'host': FLAGS.host,
                                    'name': 'instance-2',
                                    'uuid': '456',
+                                   'vm_state': '',
                                    'task_state': ''}])
 
         image_cache_manager = imagecache.ImageCacheManager()
@@ -865,11 +871,13 @@ class ImageCacheManagerTestCase(test.TestCase):
                                        'host': FLAGS.host,
                                        'name': 'instance-1',
                                        'uuid': '123',
+                                       'vm_state': '',
                                        'task_state': ''},
                                       {'image_ref': '1',
                                        'host': FLAGS.host,
                                        'name': 'instance-2',
                                        'uuid': '456',
+                                       'vm_state': '',
                                        'task_state': ''}])
 
             def touch(filename):