Merge "lock/unlock in compute manager to use uuids"

2 files changed, 15 insertions, 16 deletions

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index dafb200bf..1e8da977d 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -1289,20 +1289,20 @@ class ComputeManager(manager.SchedulerDependentManager):
                               task_state=None)
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def lock_instance(self, context, instance_id):
+    def lock_instance(self, context, instance_uuid):
         """Lock the given instance."""
         context = context.elevated()
 
-        LOG.debug(_('instance %s: locking'), instance_id, context=context)
-        self.db.instance_update(context, instance_id, {'locked': True})
+        LOG.debug(_('instance %s: locking'), instance_uuid, context=context)
+        self.db.instance_update(context, instance_uuid, {'locked': True})
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def unlock_instance(self, context, instance_id):
+    def unlock_instance(self, context, instance_uuid):
         """Unlock the given instance."""
         context = context.elevated()
 
-        LOG.debug(_('instance %s: unlocking'), instance_id, context=context)
-        self.db.instance_update(context, instance_id, {'locked': False})
+        LOG.debug(_('instance %s: unlocking'), instance_uuid, context=context)
+        self.db.instance_update(context, instance_uuid, {'locked': False})
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     def get_lock(self, context, instance_id):
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index a0289b15d..02365c248 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -523,18 +523,20 @@ class ComputeTestCase(BaseTestCase):
 
     def test_lock(self):
         """ensure locked instance cannot be changed"""
-        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)
 
         non_admin_context = context.RequestContext(None, None, False, False)
 
         # decorator should return False (fail) with locked nonadmin context
-        self.compute.lock_instance(self.context, instance_id)
+        self.compute.lock_instance(self.context, instance_uuid)
         ret_val = self.compute.reboot_instance(non_admin_context, instance_id)
         self.assertEqual(ret_val, False)
 
         # decorator should return None (success) with unlocked nonadmin context
-        self.compute.unlock_instance(self.context, instance_id)
+        self.compute.unlock_instance(self.context, instance_uuid)
         ret_val = self.compute.reboot_instance(non_admin_context, instance_id)
         self.assertEqual(ret_val, None)
 
@@ -2106,22 +2108,19 @@ class ComputeAPITestCase(BaseTestCase):
         self.compute_api.reset_network(self.context, instance)
 
     def test_lock(self):
-        instance_id = self._create_instance()
-        instance = self.compute_api.get(self.context, instance_id)
+        instance = self._create_fake_instance()
         self.compute_api.lock(self.context, instance)
         self.compute_api.delete(self.context, instance)
 
     def test_unlock(self):
-        instance_id = self._create_instance()
-        instance = self.compute_api.get(self.context, instance_id)
+        instance = self._create_fake_instance()
         self.compute_api.unlock(self.context, instance)
         self.compute_api.delete(self.context, instance)
 
     def test_get_lock(self):
-        instance_id = self._create_instance()
-        instance = self.compute_api.get(self.context, instance_id)
+        instance = self._create_fake_instance()
         self.assertFalse(self.compute_api.get_lock(self.context, instance))
-        db.instance_update(self.context, instance_id, {'locked': True})
+        db.instance_update(self.context, instance['id'], {'locked': True})
         self.assertTrue(self.compute_api.get_lock(self.context, instance))
 
     def test_add_remove_security_group(self):