Fix use of elevated context for resize methods

elevated contexts were being passed over RPC to confirm_resize,
revert_resize, and finish_revert_resize methods.  If those methods need
to elevate context, they should do so themselves.

There was 1 case (when deleting an instance in RESIZED) when we'd send a
non-elevated context to confirm_resize().  This would fail because the
migration_get() call there requires admin context and confirm_resize()
on the manager side did not elevate the context itself.

This fixes bug 1071600 and removes sending elevated contexts for these
methods over RPC.

(Ultimately we need some work to make the migration* DB API calls verify
project_id vs requiring admin context..)

Change-Id: I907889502f19fba8059253e52dca084a123016e2

3 files changed, 105 insertions, 119 deletions

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 0e5a6568e..7a05ab3d7 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -1504,8 +1504,8 @@ class API(base.Base):
     @check_instance_state(vm_state=[vm_states.RESIZED])
     def revert_resize(self, context, instance):
         """Reverts a resize, deleting the 'new' instance in the process."""
-        context = context.elevated()
-        migration_ref = self.db.migration_get_by_instance_and_status(context,
+        elevated = context.elevated()
+        migration_ref = self.db.migration_get_by_instance_and_status(elevated,
                 instance['uuid'], 'finished')
 
         # reverse quota reservation for increased resource usage
@@ -1520,7 +1520,7 @@ class API(base.Base):
                 instance=instance, migration_id=migration_ref['id'],
                 host=migration_ref['dest_compute'], reservations=reservations)
 
-        self.db.migration_update(context, migration_ref['id'],
+        self.db.migration_update(elevated, migration_ref['id'],
                                  {'status': 'reverted'})
 
     @wrap_check_policy
@@ -1528,8 +1528,8 @@ class API(base.Base):
     @check_instance_state(vm_state=[vm_states.RESIZED])
     def confirm_resize(self, context, instance):
         """Confirms a migration/resize and deletes the 'old' instance."""
-        context = context.elevated()
-        migration_ref = self.db.migration_get_by_instance_and_status(context,
+        elevated = context.elevated()
+        migration_ref = self.db.migration_get_by_instance_and_status(elevated,
                 instance['uuid'], 'finished')
 
         # reserve quota only for any decrease in resource usage
@@ -1545,7 +1545,7 @@ class API(base.Base):
                 host=migration_ref['source_compute'],
                 reservations=reservations)
 
-        self.db.migration_update(context, migration_ref['id'],
+        self.db.migration_update(elevated, migration_ref['id'],
                 {'status': 'confirmed'})
 
     @staticmethod
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index af183625e..13b9f2d2a 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -1440,7 +1440,8 @@ class ComputeManager(manager.SchedulerDependentManager):
                        migration=None, migration_id=None):
         """Destroys the source instance."""
         if not migration:
-            migration = self.db.migration_get(context, migration_id)
+            migration = self.db.migration_get(context.elevated(),
+                    migration_id)
 
         self._notify_about_instance_usage(context, instance,
                                           "resize.confirm.start")
@@ -1472,8 +1473,8 @@ class ComputeManager(manager.SchedulerDependentManager):
         source machine.
 
         """
-        context = context.elevated()
-        migration_ref = self.db.migration_get(context, migration_id)
+        migration_ref = self.db.migration_get(context.elevated(),
+                migration_id)
 
         # NOTE(comstud): A revert_resize is essentially a resize back to
         # the old size, so we need to send a usage event here.
@@ -1520,7 +1521,8 @@ class ComputeManager(manager.SchedulerDependentManager):
         in the database.
 
         """
-        migration_ref = self.db.migration_get(context, migration_id)
+        elevated = context.elevated()
+        migration_ref = self.db.migration_get(elevated, migration_id)
 
         with self._error_out_instance_on_exception(context, instance['uuid'],
                                                    reservations):
@@ -1572,7 +1574,7 @@ class ComputeManager(manager.SchedulerDependentManager):
                                   expected_task_state=task_states.
                                       RESIZE_REVERTING)
 
-            self.db.migration_update(context, migration_id,
+            self.db.migration_update(elevated, migration_id,
                     {'status': 'reverted'})
 
             self._notify_about_instance_usage(
@@ -1600,7 +1602,6 @@ class ComputeManager(manager.SchedulerDependentManager):
         Possibly changes the RAM and disk size in the process.
 
         """
-        context = context.elevated()
         with self._error_out_instance_on_exception(context, instance['uuid'],
                                                    reservations):
             compute_utils.notify_usage_exists(
@@ -1620,7 +1621,7 @@ class ComputeManager(manager.SchedulerDependentManager):
             old_instance_type = instance_types.get_instance_type(
                     old_instance_type_id)
 
-            migration_ref = self.db.migration_create(context,
+            migration_ref = self.db.migration_create(context.elevated(),
                     {'instance_uuid': instance['uuid'],
                      'source_compute': instance['host'],
                      'dest_compute': self.host,
@@ -1647,9 +1648,9 @@ class ComputeManager(manager.SchedulerDependentManager):
     def resize_instance(self, context, instance, image,
                         reservations=None, migration=None, migration_id=None):
         """Starts the migration of a running instance to another host."""
-        context = context.elevated()
+        elevated = context.elevated()
         if not migration:
-            migration = self.db.migration_get(context, migration_id)
+            migration = self.db.migration_get(elevated, migration_id)
         with self._error_out_instance_on_exception(context, instance['uuid'],
                                                    reservations):
             instance_type_ref = self.db.instance_type_get(context,
@@ -1657,7 +1658,7 @@ class ComputeManager(manager.SchedulerDependentManager):
 
             network_info = self._get_instance_nw_info(context, instance)
 
-            self.db.migration_update(context,
+            self.db.migration_update(elevated,
                                      migration['id'],
                                      {'status': 'migrating'})
 
@@ -1689,7 +1690,7 @@ class ComputeManager(manager.SchedulerDependentManager):
                 self.network_api.migrate_instance_start(context, instance,
                                                            self.host)
 
-            migration = self.db.migration_update(context,
+            migration = self.db.migration_update(elevated,
                                                  migration['id'],
                                                  {'status': 'post-migrating'})
 
@@ -1767,7 +1768,7 @@ class ComputeManager(manager.SchedulerDependentManager):
                                          expected_task_state=task_states.
                                              RESIZE_FINISH)
 
-        self.db.migration_update(context, migration['id'],
+        self.db.migration_update(context.elevated(), migration['id'],
                                  {'status': 'finished'})
 
         self._notify_about_instance_usage(
@@ -1786,7 +1787,8 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         """
         if not migration:
-            migration = self.db.migration_get(context, migration_id)
+            migration = self.db.migration_get(context.elevated(),
+                    migration_id)
         try:
             self._finish_resize(context, instance, migration,
                                 disk_info, image)
diff --git a/nova/tests/compute/test_compute.py b/nova/tests/compute/test_compute.py
index d989c488e..34a5f17d0 100644
--- a/nova/tests/compute/test_compute.py
+++ b/nova/tests/compute/test_compute.py
@@ -1603,19 +1603,18 @@ class ComputeTestCase(BaseTestCase):
 
         reservations = self._ensure_quota_reservations_committed()
 
-        context = self.context.elevated()
         instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_type = instance_types.get_default_instance_type()
         db.instance_update(self.context, instance["uuid"],
                           {"task_state": task_states.RESIZE_PREP})
-        self.compute.prep_resize(context, instance=instance,
+        self.compute.prep_resize(self.context, instance=instance,
                                  instance_type=instance_type,
                                  image={})
-        migration_ref = db.migration_get_by_instance_and_status(context,
-                instance['uuid'], 'pre-migrating')
+        migration_ref = db.migration_get_by_instance_and_status(
+                self.context.elevated(), instance['uuid'], 'pre-migrating')
         db.instance_update(self.context, instance["uuid"],
                            {"task_state": task_states.RESIZE_MIGRATED})
-        self.compute.finish_resize(context,
+        self.compute.finish_resize(self.context,
                 migration=jsonutils.to_primitive(migration_ref),
                 disk_info={}, image={}, instance=instance,
                 reservations=reservations)
@@ -1634,24 +1633,23 @@ class ComputeTestCase(BaseTestCase):
 
         reservations = self._ensure_quota_reservations_rolledback()
 
-        context = self.context.elevated()
         instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_type = instance_types.get_default_instance_type()
-        self.compute.prep_resize(context, instance=instance,
+        self.compute.prep_resize(self.context, instance=instance,
                                  instance_type=instance_type,
                                  image={}, reservations=reservations)
-        migration_ref = db.migration_get_by_instance_and_status(context,
-                instance['uuid'], 'pre-migrating')
+        migration_ref = db.migration_get_by_instance_and_status(
+                self.context.elevated(), instance['uuid'], 'pre-migrating')
 
         db.instance_update(self.context, instance["uuid"],
                            {"task_state": task_states.RESIZE_MIGRATED})
         self.assertRaises(test.TestingException, self.compute.finish_resize,
-                          context,
+                          self.context,
                           migration=jsonutils.to_primitive(migration_ref),
                           disk_info={}, image={}, instance=instance,
                           reservations=reservations)
 
-        instance = db.instance_get_by_uuid(context, instance['uuid'])
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         self.assertEqual(instance['vm_state'], vm_states.ERROR)
         self.compute.terminate_instance(self.context,
                 instance=jsonutils.to_primitive(instance))
@@ -1728,7 +1726,6 @@ class ComputeTestCase(BaseTestCase):
         cur_time = datetime.datetime(2012, 12, 21, 12, 21)
         timeutils.set_time_override(old_time)
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        context = self.context.elevated()
         old_type_id = instance_types.get_instance_type_by_name(
                                                 'm1.tiny')['id']
         new_type = instance_types.get_instance_type_by_name('m1.small')
@@ -1739,18 +1736,16 @@ class ComputeTestCase(BaseTestCase):
         db.instance_update(self.context, instance['uuid'], {'host': 'foo'})
         db.instance_update(self.context, instance["uuid"],
                            {"task_state": task_states.RESIZE_PREP})
-        self.compute.prep_resize(context, instance=instance,
+        self.compute.prep_resize(self.context, instance=instance,
                 instance_type=new_type, image={})
-        migration_ref = db.migration_get_by_instance_and_status(context,
-                                                instance['uuid'],
-                                                'pre-migrating')
-        self.compute.resize_instance(context, instance=instance,
-                                     migration=migration_ref,
-                                     image={})
+        migration_ref = db.migration_get_by_instance_and_status(
+                self.context.elevated(), instance['uuid'], 'pre-migrating')
+        self.compute.resize_instance(self.context, instance=instance,
+                migration=migration_ref, image={})
         timeutils.set_time_override(cur_time)
         test_notifier.NOTIFICATIONS = []
 
-        self.compute.finish_resize(context,
+        self.compute.finish_resize(self.context,
                 migration=jsonutils.to_primitive(migration_ref),
                 disk_info={}, image={}, instance=instance)
 
@@ -1774,7 +1769,7 @@ class ComputeTestCase(BaseTestCase):
         self.assertEqual(payload['launched_at'], str(cur_time))
         image_ref_url = utils.generate_image_url(FAKE_IMAGE_REF)
         self.assertEquals(payload['image_ref_url'], image_ref_url)
-        self.compute.terminate_instance(context,
+        self.compute.terminate_instance(self.context,
             instance=jsonutils.to_primitive(instance))
 
     def test_resize_instance_notification(self):
@@ -1783,7 +1778,6 @@ class ComputeTestCase(BaseTestCase):
         cur_time = datetime.datetime(2012, 12, 21, 12, 21)
         timeutils.set_time_override(old_time)
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        context = self.context.elevated()
 
         self.compute.run_instance(self.context, instance=instance)
         timeutils.set_time_override(cur_time)
@@ -1791,9 +1785,9 @@ class ComputeTestCase(BaseTestCase):
 
         db.instance_update(self.context, instance['uuid'], {'host': 'foo'})
         instance_type = instance_types.get_default_instance_type()
-        self.compute.prep_resize(context, instance=instance,
+        self.compute.prep_resize(self.context, instance=instance,
                 instance_type=instance_type, image={})
-        db.migration_get_by_instance_and_status(context,
+        db.migration_get_by_instance_and_status(self.context.elevated(),
                                                 instance['uuid'],
                                                 'pre-migrating')
 
@@ -1820,14 +1814,13 @@ class ComputeTestCase(BaseTestCase):
         self.assertTrue('launched_at' in payload)
         image_ref_url = utils.generate_image_url(FAKE_IMAGE_REF)
         self.assertEquals(payload['image_ref_url'], image_ref_url)
-        self.compute.terminate_instance(context, instance=instance)
+        self.compute.terminate_instance(self.context, instance=instance)
 
     def test_prep_resize_instance_migration_error(self):
         """Ensure prep_resize raise a migration error"""
         self.flags(host="foo", allow_resize_to_same_host=False)
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        context = self.context.elevated()
 
         reservations = self._ensure_quota_reservations_rolledback()
 
@@ -1838,10 +1831,10 @@ class ComputeTestCase(BaseTestCase):
         instance_type = instance_types.get_default_instance_type()
 
         self.assertRaises(exception.MigrationError, self.compute.prep_resize,
-                          context, instance=new_instance,
+                          self.context, instance=new_instance,
                           instance_type=instance_type, image={},
                           reservations=reservations)
-        self.compute.terminate_instance(context, instance=new_instance)
+        self.compute.terminate_instance(self.context, instance=new_instance)
 
     def test_resize_instance_driver_error(self):
         """Ensure instance status set to Error on resize error"""
@@ -1854,53 +1847,51 @@ class ComputeTestCase(BaseTestCase):
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_type = instance_types.get_default_instance_type()
-        context = self.context.elevated()
 
         reservations = self._ensure_quota_reservations_rolledback()
 
         self.compute.run_instance(self.context, instance=instance)
         db.instance_update(self.context, instance['uuid'], {'host': 'foo'})
-        self.compute.prep_resize(context, instance=instance,
+        self.compute.prep_resize(self.context, instance=instance,
                                  instance_type=instance_type, image={},
                                  reservations=reservations)
-        migration_ref = db.migration_get_by_instance_and_status(context,
-                instance['uuid'], 'pre-migrating')
+        migration_ref = db.migration_get_by_instance_and_status(
+                self.context.elevated(), instance['uuid'], 'pre-migrating')
 
         db.instance_update(self.context, instance['uuid'],
                            {"task_state": task_states.RESIZE_PREP})
         #verify
         self.assertRaises(test.TestingException, self.compute.resize_instance,
-                          context, instance=instance,
+                          self.context, instance=instance,
                           migration=migration_ref, image={},
                           reservations=reservations)
-        instance = db.instance_get_by_uuid(context, instance['uuid'])
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         self.assertEqual(instance['vm_state'], vm_states.ERROR)
 
-        self.compute.terminate_instance(context,
+        self.compute.terminate_instance(self.context,
             instance=jsonutils.to_primitive(instance))
 
     def test_resize_instance(self):
         """Ensure instance can be migrated/resized"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_type = instance_types.get_default_instance_type()
-        context = self.context.elevated()
 
         self.compute.run_instance(self.context, instance=instance)
         db.instance_update(self.context, instance['uuid'],
                            {'host': 'foo'})
-        self.compute.prep_resize(context, instance=instance,
+        self.compute.prep_resize(self.context, instance=instance,
                 instance_type=instance_type, image={})
-        migration_ref = db.migration_get_by_instance_and_status(context,
-                instance['uuid'], 'pre-migrating')
+        migration_ref = db.migration_get_by_instance_and_status(
+                self.context.elevated(), instance['uuid'], 'pre-migrating')
         db.instance_update(self.context, instance['uuid'],
                            {"task_state": task_states.RESIZE_PREP})
-        self.compute.resize_instance(context, instance=instance,
+        self.compute.resize_instance(self.context, instance=instance,
                                      migration=migration_ref,
                                      image={})
-        inst = db.instance_get_by_uuid(context, instance['uuid'])
+        inst = db.instance_get_by_uuid(self.context, instance['uuid'])
         self.assertEqual(migration_ref['dest_compute'], inst['host'])
 
-        self.compute.terminate_instance(context,
+        self.compute.terminate_instance(self.context,
             instance=jsonutils.to_primitive(instance))
 
     def test_finish_revert_resize(self):
@@ -1913,43 +1904,44 @@ class ComputeTestCase(BaseTestCase):
 
         reservations = self._ensure_quota_reservations_committed()
 
-        context = self.context.elevated()
         instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
 
         self.compute.run_instance(self.context, instance=instance)
 
         # Confirm the instance size before the resize starts
-        inst_ref = db.instance_get_by_uuid(context, instance['uuid'])
-        instance_type_ref = db.instance_type_get(context,
+        inst_ref = db.instance_get_by_uuid(self.context, instance['uuid'])
+        instance_type_ref = db.instance_type_get(self.context,
                 inst_ref['instance_type_id'])
         self.assertEqual(instance_type_ref['flavorid'], '1')
 
         new_inst_ref = db.instance_update(self.context, instance['uuid'],
                                           {'host': 'foo'})
 
-        new_instance_type_ref = db.instance_type_get_by_flavor_id(context, 3)
-        self.compute.prep_resize(context,
+        new_instance_type_ref = db.instance_type_get_by_flavor_id(
+                self.context, 3)
+        self.compute.prep_resize(self.context,
                 instance=jsonutils.to_primitive(new_inst_ref),
                 instance_type=jsonutils.to_primitive(new_instance_type_ref),
                 image={}, reservations=reservations)
 
-        migration_ref = db.migration_get_by_instance_and_status(context,
+        migration_ref = db.migration_get_by_instance_and_status(
+                self.context.elevated(),
                 inst_ref['uuid'], 'pre-migrating')
 
         instance = jsonutils.to_primitive(inst_ref)
         db.instance_update(self.context, instance["uuid"],
                            {"task_state": task_states.RESIZE_PREP})
-        self.compute.resize_instance(context, instance=instance,
+        self.compute.resize_instance(self.context, instance=instance,
                                      migration=migration_ref,
                                      image={})
-        self.compute.finish_resize(context,
+        self.compute.finish_resize(self.context,
                     migration=jsonutils.to_primitive(migration_ref),
                     disk_info={}, image={}, instance=instance)
 
         # Prove that the instance size is now the new size
-        inst_ref = db.instance_get_by_uuid(context, instance['uuid'])
-        instance_type_ref = db.instance_type_get(context,
+        inst_ref = db.instance_get_by_uuid(self.context, instance['uuid'])
+        instance_type_ref = db.instance_type_get(self.context,
                 inst_ref['instance_type_id'])
         self.assertEqual(instance_type_ref['flavorid'], '3')
 
@@ -1957,7 +1949,7 @@ class ComputeTestCase(BaseTestCase):
         rpcinst = jsonutils.to_primitive(inst_ref)
         db.instance_update(self.context, instance["uuid"],
                            {"task_state": task_states.RESIZE_REVERTING})
-        self.compute.revert_resize(context,
+        self.compute.revert_resize(self.context,
                 migration_id=migration_ref['id'], instance=rpcinst,
                 reservations=reservations)
 
@@ -1969,21 +1961,21 @@ class ComputeTestCase(BaseTestCase):
         self.stubs.Set(network_api.API, 'setup_networks_on_host',
                        fake_setup_networks_on_host)
 
-        self.compute.finish_revert_resize(context,
+        self.compute.finish_revert_resize(self.context,
                 migration_id=migration_ref['id'], instance=rpcinst,
                 reservations=reservations)
 
-        instance = db.instance_get_by_uuid(context, instance['uuid'])
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         self.assertEqual(instance['vm_state'], vm_states.ACTIVE)
         self.assertEqual(instance['task_state'], None)
 
-        inst_ref = db.instance_get_by_uuid(context, instance['uuid'])
-        instance_type_ref = db.instance_type_get(context,
+        inst_ref = db.instance_get_by_uuid(self.context, instance['uuid'])
+        instance_type_ref = db.instance_type_get(self.context,
                 inst_ref['instance_type_id'])
         self.assertEqual(instance_type_ref['flavorid'], '1')
         self.assertEqual(inst_ref['host'], migration_ref['source_compute'])
 
-        self.compute.terminate_instance(context,
+        self.compute.terminate_instance(self.context,
             instance=jsonutils.to_primitive(inst_ref))
 
     def test_get_by_flavor_id(self):
@@ -2017,24 +2009,23 @@ class ComputeTestCase(BaseTestCase):
 
         inst_ref = jsonutils.to_primitive(self._create_fake_instance())
         instance_type = instance_types.get_default_instance_type()
-        context = self.context.elevated()
 
         self.compute.run_instance(self.context, instance=inst_ref)
         db.instance_update(self.context, inst_ref['uuid'], {'host': 'foo'})
-        self.compute.prep_resize(context, instance=inst_ref,
+        self.compute.prep_resize(self.context, instance=inst_ref,
                                  instance_type=instance_type,
                                  image={}, reservations=reservations)
-        migration_ref = db.migration_get_by_instance_and_status(context,
-                inst_ref['uuid'], 'pre-migrating')
+        migration_ref = db.migration_get_by_instance_and_status(
+                self.context.elevated(), inst_ref['uuid'], 'pre-migrating')
         db.instance_update(self.context, inst_ref['uuid'],
                            {"task_state": task_states.RESIZE_PREP})
         self.assertRaises(test.TestingException, self.compute.resize_instance,
-                          context, instance=inst_ref,
+                          self.context, instance=inst_ref,
                           migration=migration_ref, image={},
                           reservations=reservations)
-        inst_ref = db.instance_get_by_uuid(context, inst_ref['uuid'])
+        inst_ref = db.instance_get_by_uuid(self.context, inst_ref['uuid'])
         self.assertEqual(inst_ref['vm_state'], vm_states.ERROR)
-        self.compute.terminate_instance(context,
+        self.compute.terminate_instance(self.context,
             instance=jsonutils.to_primitive(inst_ref))
 
     def test_check_can_live_migrate_source_works_correctly(self):
@@ -3731,13 +3722,12 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_resize_confirm_through_api(self):
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        context = self.context.elevated()
         self.compute.run_instance(self.context, instance=instance)
-        instance = db.instance_get_by_uuid(context, instance['uuid'])
-        self.compute_api.resize(context, instance, '4')
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
+        self.compute_api.resize(self.context, instance, '4')
 
         # create a fake migration record (manager does this)
-        db.migration_create(context,
+        db.migration_create(self.context.elevated(),
                 {'instance_uuid': instance['uuid'],
                  'status': 'finished'})
         # set the state that the instance gets when resize finishes
@@ -3745,20 +3735,19 @@ class ComputeAPITestCase(BaseTestCase):
                                       {'task_state': None,
                                        'vm_state': vm_states.RESIZED})
 
-        self.compute_api.confirm_resize(context, instance)
-        self.compute.terminate_instance(context,
+        self.compute_api.confirm_resize(self.context, instance)
+        self.compute.terminate_instance(self.context,
             instance=jsonutils.to_primitive(instance))
 
     def test_resize_revert_through_api(self):
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        context = self.context.elevated()
-        instance = db.instance_get_by_uuid(context, instance['uuid'])
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         self.compute.run_instance(self.context, instance=instance)
 
-        self.compute_api.resize(context, instance, '4')
+        self.compute_api.resize(self.context, instance, '4')
 
         # create a fake migration record (manager does this)
-        db.migration_create(context,
+        db.migration_create(self.context.elevated(),
                 {'instance_uuid': instance['uuid'],
                  'status': 'finished'})
         # set the state that the instance gets when resize finishes
@@ -3766,54 +3755,51 @@ class ComputeAPITestCase(BaseTestCase):
                                       {'task_state': None,
                                        'vm_state': vm_states.RESIZED})
 
-        self.compute_api.revert_resize(context, instance)
+        self.compute_api.revert_resize(self.context, instance)
 
-        instance = db.instance_get_by_uuid(context, instance['uuid'])
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         self.assertEqual(instance['vm_state'], vm_states.RESIZED)
         self.assertEqual(instance['task_state'], task_states.RESIZE_REVERTING)
 
-        self.compute.terminate_instance(context,
+        self.compute.terminate_instance(self.context,
             instance=jsonutils.to_primitive(instance))
 
     def test_resize_invalid_flavor_fails(self):
         """Ensure invalid flavors raise"""
         instance = self._create_fake_instance()
-        context = self.context.elevated()
-        instance = db.instance_get_by_uuid(context, instance['uuid'])
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         instance = jsonutils.to_primitive(instance)
         self.compute.run_instance(self.context, instance=instance)
 
         self.assertRaises(exception.NotFound, self.compute_api.resize,
-                context, instance, 200)
+                self.context, instance, 200)
 
-        self.compute.terminate_instance(context, instance=instance)
+        self.compute.terminate_instance(self.context, instance=instance)
 
     def test_resize_same_flavor_fails(self):
         """Ensure invalid flavors raise"""
-        context = self.context.elevated()
         instance = self._create_fake_instance()
-        instance = db.instance_get_by_uuid(context, instance['uuid'])
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         instance = jsonutils.to_primitive(instance)
 
         self.compute.run_instance(self.context, instance=instance)
 
         self.assertRaises(exception.CannotResizeToSameFlavor,
-                          self.compute_api.resize, context, instance, 1)
+                          self.compute_api.resize, self.context, instance, 1)
 
-        self.compute.terminate_instance(context, instance=instance)
+        self.compute.terminate_instance(self.context, instance=instance)
 
     def test_migrate(self):
-        context = self.context.elevated()
         instance = self._create_fake_instance()
-        instance = db.instance_get_by_uuid(context, instance['uuid'])
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         instance = jsonutils.to_primitive(instance)
         self.compute.run_instance(self.context, instance=instance)
         # Migrate simply calls resize() without a flavor_id.
-        self.compute_api.resize(context, instance, None)
-        self.compute.terminate_instance(context, instance=instance)
+        self.compute_api.resize(self.context, instance, None)
+        self.compute.terminate_instance(self.context, instance=instance)
 
     def test_resize_request_spec(self):
-        def _fake_cast(context, topic, msg):
+        def _fake_cast(_context, _topic, msg):
             request_spec = msg['args']['request_spec']
             filter_properties = msg['args']['filter_properties']
             instance_properties = request_spec['instance_properties']
@@ -3833,9 +3819,8 @@ class ComputeAPITestCase(BaseTestCase):
 
         self.stubs.Set(rpc, 'cast', _fake_cast)
 
-        context = self.context.elevated()
         instance = self._create_fake_instance(dict(host='host2'))
-        instance = db.instance_get_by_uuid(context, instance['uuid'])
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         instance = jsonutils.to_primitive(instance)
         orig_instance_type = instance['instance_type']
         self.compute.run_instance(self.context, instance=instance)
@@ -3850,12 +3835,12 @@ class ComputeAPITestCase(BaseTestCase):
         # different host
         self.flags(host='host3')
         try:
-            self.compute_api.resize(context, instance, None)
+            self.compute_api.resize(self.context, instance, None)
         finally:
-            self.compute.terminate_instance(context, instance=instance)
+            self.compute.terminate_instance(self.context, instance=instance)
 
     def test_resize_request_spec_noavoid(self):
-        def _fake_cast(context, topic, msg):
+        def _fake_cast(_context, topic, msg):
             request_spec = msg['args']['request_spec']
             filter_properties = msg['args']['filter_properties']
             instance_properties = request_spec['instance_properties']
@@ -3870,9 +3855,8 @@ class ComputeAPITestCase(BaseTestCase):
         self.stubs.Set(rpc, 'cast', _fake_cast)
         self.flags(allow_resize_to_same_host=True)
 
-        context = self.context.elevated()
         instance = self._create_fake_instance(dict(host='host2'))
-        instance = db.instance_get_by_uuid(context, instance['uuid'])
+        instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         instance = jsonutils.to_primitive(instance)
         self.compute.run_instance(self.context, instance=instance)
         # We need to set the host to something 'known'.  Unfortunately,
@@ -3885,9 +3869,9 @@ class ComputeAPITestCase(BaseTestCase):
                 dict(host='host2', progress=10))
         # different host
         try:
-            self.compute_api.resize(context, instance, None)
+            self.compute_api.resize(self.context, instance, None)
         finally:
-            self.compute.terminate_instance(context, instance=instance)
+            self.compute.terminate_instance(self.context, instance=instance)
 
     def test_get(self):
         """Test get instance"""