pause/unpause in compute manager to use uuids

Related to blueprint internal-uuids. Changes pause_instance and unpause_instance
to expect and handle instance uuids instead of instance ids.

Change-Id: I4f601f686dcaa6d6268d1dd01557a0362a0a89fa

3 files changed, 39 insertions, 30 deletions

diff --git a/nova/compute/api.py b/nova/compute/api.py
index ffd2efd29..5c7ed9ba3 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -1337,21 +1337,23 @@ class API(base.Base):
     def pause(self, context, instance):
         """Pause the given instance."""
         instance_id = instance["id"]
+        instance_uuid = instance["uuid"]
         self.update(context,
                     instance_id,
                     vm_state=vm_states.ACTIVE,
                     task_state=task_states.PAUSING)
-        self._cast_compute_message('pause_instance', context, instance_id)
+        self._cast_compute_message('pause_instance', context, instance_uuid)
 
     @scheduler_api.reroute_compute("unpause")
     def unpause(self, context, instance):
         """Unpause the given instance."""
         instance_id = instance["id"]
+        instance_uuid = instance["uuid"]
         self.update(context,
                     instance_id,
                     vm_state=vm_states.PAUSED,
                     task_state=task_states.UNPAUSING)
-        self._cast_compute_message('unpause_instance', context, instance_id)
+        self._cast_compute_message('unpause_instance', context, instance_uuid)
 
     def _call_compute_message_for_host(self, action, context, host, params):
         """Call method deliberately designed to make host/service only calls"""
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 4927e747d..dd3ab74af 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -1203,34 +1203,34 @@ class ComputeManager(manager.SchedulerDependentManager):
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def pause_instance(self, context, instance_id):
+    def pause_instance(self, context, instance_uuid):
         """Pause an instance on this host."""
-        LOG.audit(_('instance %s: pausing'), instance_id, context=context)
+        LOG.audit(_('instance %s: pausing'), instance_uuid, context=context)
         context = context.elevated()
 
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get_by_uuid(context, instance_uuid)
         self.driver.pause(instance_ref)
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_ref['id'],
                               power_state=current_power_state,
                               vm_state=vm_states.PAUSED,
                               task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
-    def unpause_instance(self, context, instance_id):
+    def unpause_instance(self, context, instance_uuid):
         """Unpause a paused instance on this host."""
-        LOG.audit(_('instance %s: unpausing'), instance_id, context=context)
+        LOG.audit(_('instance %s: unpausing'), instance_uuid, context=context)
         context = context.elevated()
 
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get_by_uuid(context, instance_uuid)
         self.driver.unpause(instance_ref)
 
         current_power_state = self._get_power_state(context, instance_ref)
         self._instance_update(context,
-                              instance_id,
+                              instance_ref['id'],
                               power_state=current_power_state,
                               vm_state=vm_states.ACTIVE,
                               task_state=None)
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 4d0832e2a..397b5e268 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -120,7 +120,7 @@ class BaseTestCase(test.TestCase):
         self.stubs.Set(rpc, 'call', rpc_call_wrapper)
         self.stubs.Set(rpc, 'cast', rpc_cast_wrapper)
 
-    def _create_instance(self, params=None):
+    def _create_fake_instance(self, params=None):
         """Create a test instance"""
         if not params:
             params = {}
@@ -135,10 +135,14 @@ class BaseTestCase(test.TestCase):
         inst['instance_type_id'] = type_id
         inst['ami_launch_index'] = 0
         inst.update(params)
-        return db.instance_create(self.context, inst)['id']
+        return db.instance_create(self.context, inst)
+
+    def _create_instance(self, params=None):
+        """Return a test instance id"""
+        return self._create_fake_instance(params)['id']
 
     def _create_instance_type(self, params=None):
-        """Create a test instance"""
+        """Create a test instance type"""
         if not params:
             params = {}
 
@@ -243,11 +247,13 @@ class ComputeTestCase(BaseTestCase):
         self.compute.terminate_instance(self.context, instance_id)
 
     def test_pause(self):
-        """Ensure instance can be paused"""
-        instance_id = self._create_instance()
+        """Ensure instance can be paused and unpaused"""
+        instance = self._create_fake_instance()
+        instance_id = instance['id']
+        instance_uuid = instance['uuid']
         self.compute.run_instance(self.context, instance_id)
-        self.compute.pause_instance(self.context, instance_id)
-        self.compute.unpause_instance(self.context, instance_id)
+        self.compute.pause_instance(self.context, instance_uuid)
+        self.compute.unpause_instance(self.context, instance_uuid)
         self.compute.terminate_instance(self.context, instance_id)
 
     def test_suspend(self):
@@ -1159,33 +1165,34 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_pause(self):
         """Ensure instance can be paused"""
-        instance_id = self._create_instance()
+        instance = self._create_fake_instance()
+        instance_id = instance['id']
         self.compute.run_instance(self.context, instance_id)
 
-        inst_ref = db.instance_get(self.context, instance_id)
-        self.assertEqual(inst_ref['task_state'], None)
+        self.assertEqual(instance['task_state'], None)
 
-        self.compute_api.pause(self.context, inst_ref)
+        self.compute_api.pause(self.context, instance)
 
-        inst_ref = db.instance_get(self.context, instance_id)
-        self.assertEqual(inst_ref['task_state'], task_states.PAUSING)
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
+        self.assertEqual(instance['task_state'], task_states.PAUSING)
 
         db.instance_destroy(self.context, instance_id)
 
     def test_unpause(self):
         """Ensure instance can be unpaused"""
-        instance_id = self._create_instance()
+        instance = self._create_fake_instance()
+        instance_id = instance['id']
+        instance_uuid = instance['uuid']
         self.compute.run_instance(self.context, instance_id)
 
-        inst_ref = db.instance_get(self.context, instance_id)
-        self.assertEqual(inst_ref['task_state'], None)
+        self.assertEqual(instance['task_state'], None)
 
-        self.compute.pause_instance(self.context, instance_id)
+        self.compute.pause_instance(self.context, instance_uuid)
 
-        self.compute_api.unpause(self.context, inst_ref)
+        self.compute_api.unpause(self.context, instance)
 
-        inst_ref = db.instance_get(self.context, instance_id)
-        self.assertEqual(inst_ref['task_state'], task_states.UNPAUSING)
+        instance = db.instance_get_by_uuid(self.context, instance_uuid)
+        self.assertEqual(instance['task_state'], task_states.UNPAUSING)
 
         db.instance_destroy(self.context, instance_id)