Send full instance to run_instance.

This patch updates run_instance in the compute manager to take a full
instance instead of just an instance UUID.  This reduces db access
required by the compute nodes.  The scheduler code needed some work here
as well since it wasn't using the compute rpcapi for calling
run_instance.

Part of blueprint no-db-messaging.

Change-Id: If5545748122b4ff9e2da6788cbd4b0fa26c4db99

8 files changed, 238 insertions, 210 deletions

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index f6e3ff9cf..f34a4aea8 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -273,7 +273,7 @@ def _get_image_meta(context, image_ref):
 class ComputeManager(manager.SchedulerDependentManager):
     """Manages the running instances from creation to destruction."""
 
-    RPC_API_VERSION = '1.38'
+    RPC_API_VERSION = '1.39'
 
     def __init__(self, compute_driver=None, *args, **kwargs):
         """Load configuration options and connect to the hypervisor."""
@@ -496,13 +496,20 @@ class ComputeManager(manager.SchedulerDependentManager):
             'block_device_mapping': block_device_mapping
         }
 
-    def _run_instance(self, context, instance_uuid, request_spec,
+    def _run_instance(self, context, request_spec,
                       filter_properties, requested_networks, injected_files,
-                      admin_password, is_first_time):
+                      admin_password, is_first_time, instance, instance_uuid):
         """Launch a new instance with specified options."""
         context = context.elevated()
+
+        if not instance:
+            try:
+                instance = self.db.instance_get_by_uuid(context, instance_uuid)
+            except exception.InstanceNotFound:
+                LOG.warn(_("Instance not found."), instance_uuid=instance_uuid)
+                return
+
         try:
-            instance = self.db.instance_get_by_uuid(context, instance_uuid)
             self._check_instance_not_already_created(context, instance)
             image_meta = self._check_image_size(context, instance)
             extra_usage_info = {"image_name": image_meta['name']}
@@ -533,11 +540,9 @@ class ComputeManager(manager.SchedulerDependentManager):
                 self._notify_about_instance_usage(context, instance,
                         "create.end", network_info=network_info,
                         extra_usage_info=extra_usage_info)
-        except exception.InstanceNotFound:
-            LOG.warn(_("Instance not found."), instance_uuid=instance_uuid)
         except Exception:
             with excutils.save_and_reraise_exception():
-                self._set_instance_error_state(context, instance_uuid)
+                self._set_instance_error_state(context, instance['uuid'])
 
     def _reschedule_or_reraise(self, context, instance, requested_networks,
                                admin_password, injected_files, is_first_time,
@@ -824,15 +829,15 @@ class ComputeManager(manager.SchedulerDependentManager):
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @wrap_instance_fault
-    def run_instance(self, context, instance_uuid, request_spec=None,
+    def run_instance(self, context, request_spec=None,
                      filter_properties={}, requested_networks=None,
                      injected_files=[], admin_password=None,
-                     is_first_time=False):
+                     is_first_time=False, instance=None, instance_uuid=None):
         @utils.synchronized(instance_uuid)
         def do_run_instance():
-            self._run_instance(context, instance_uuid, request_spec,
+            self._run_instance(context, request_spec,
                     filter_properties, requested_networks, injected_files,
-                    admin_password, is_first_time)
+                    admin_password, is_first_time, instance, instance_uuid)
         do_run_instance()
 
     def _shutdown_instance(self, context, instance):
diff --git a/nova/compute/rpcapi.py b/nova/compute/rpcapi.py
index 517cfca4d..72babd380 100644
--- a/nova/compute/rpcapi.py
+++ b/nova/compute/rpcapi.py
@@ -117,6 +117,7 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
                 - remove instance_uuid, add instance
                 - remove instance_type_id, add instance_type
                 - remove topic, it was unused
+        1.39 - Remove instance_uuid, add instance argument to run_instance()
     '''
 
     BASE_RPC_API_VERSION = '1.0'
@@ -422,6 +423,19 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
             topic=_compute_topic(self.topic, ctxt, host, None),
             version='1.32')
 
+    def run_instance(self, ctxt, instance, host, request_spec,
+                     filter_properties, requested_networks,
+                     injected_files, admin_password,
+                     is_first_time):
+        instance_p = jsonutils.to_primitive(instance)
+        self.cast(ctxt, self.make_msg('run_instance', instance=instance_p,
+                request_spec=request_spec, filter_properties=filter_properties,
+                requested_networks=requested_networks,
+                injected_files=injected_files, admin_password=admin_password,
+                is_first_time=is_first_time),
+                topic=_compute_topic(self.topic, ctxt, host, None),
+                version='1.39')
+
     def set_admin_password(self, ctxt, instance, new_pass):
         instance_p = jsonutils.to_primitive(instance)
         return self.call(ctxt, self.make_msg('set_admin_password',
diff --git a/nova/scheduler/chance.py b/nova/scheduler/chance.py
index d3378c38c..5afd6361d 100644
--- a/nova/scheduler/chance.py
+++ b/nova/scheduler/chance.py
@@ -73,14 +73,16 @@ class ChanceScheduler(driver.Scheduler):
             request_spec['instance_properties']['launch_index'] = num
             instance = self.create_instance_db_entry(context, request_spec,
                                                      reservations)
-            driver.cast_to_compute_host(context, host,
-                    'run_instance', instance_uuid=instance['uuid'],
+            updated_instance = driver.instance_update_db(context,
+                    instance['uuid'], host)
+            self.compute_rpcapi.run_instance(context,
+                    instance=updated_instance, host=host,
                     requested_networks=requested_networks,
                     injected_files=injected_files,
                     admin_password=admin_password, is_first_time=is_first_time,
                     request_spec=request_spec,
                     filter_properties=filter_properties)
-            instances.append(driver.encode_instance(instance))
+            instances.append(driver.encode_instance(updated_instance))
             # So if we loop around, create_instance_db_entry will actually
             # create a new entry, instead of assume it's been created
             # already
diff --git a/nova/scheduler/filter_scheduler.py b/nova/scheduler/filter_scheduler.py
index de44ace46..2d8e31758 100644
--- a/nova/scheduler/filter_scheduler.py
+++ b/nova/scheduler/filter_scheduler.py
@@ -144,14 +144,17 @@ class FilterScheduler(driver.Scheduler):
                         'scheduler.run_instance.scheduled', notifier.INFO,
                         payload)
 
-        driver.cast_to_compute_host(context, weighted_host.host_state.host,
-                'run_instance', instance_uuid=instance['uuid'],
+        updated_instance = driver.instance_update_db(context, instance['uuid'],
+                weighted_host.host_state.host)
+
+        self.compute_rpcapi.run_instance(context, instance=updated_instance,
+                host=weighted_host.host_state.host,
                 request_spec=request_spec, filter_properties=filter_properties,
                 requested_networks=requested_networks,
                 injected_files=injected_files,
                 admin_password=admin_password, is_first_time=is_first_time)
 
-        inst = driver.encode_instance(instance, local=True)
+        inst = driver.encode_instance(updated_instance, local=True)
 
         # So if another instance is created, create_instance_db_entry will
         # actually create a new entry, instead of assume it's been created
diff --git a/nova/tests/compute/test_compute.py b/nova/tests/compute/test_compute.py
index 443a25e6c..e0305cadc 100644
--- a/nova/tests/compute/test_compute.py
+++ b/nova/tests/compute/test_compute.py
@@ -261,11 +261,11 @@ class ComputeTestCase(BaseTestCase):
     def test_create_instance_with_img_ref_associates_config_drive(self):
         """Make sure create associates a config drive."""
 
-        instance = self._create_fake_instance(
-                        params={'config_drive': '1234', })
+        instance = jsonutils.to_primitive(self._create_fake_instance(
+                        params={'config_drive': '1234', }))
 
         try:
-            self.compute.run_instance(self.context, instance['uuid'])
+            self.compute.run_instance(self.context, instance=instance)
             instances = db.instance_get_all(context.get_admin_context())
             instance = instances[0]
 
@@ -276,11 +276,11 @@ class ComputeTestCase(BaseTestCase):
     def test_create_instance_associates_config_drive(self):
         """Make sure create associates a config drive."""
 
-        instance = self._create_fake_instance(
-                        params={'config_drive': '1234', })
+        instance = jsonutils.to_primitive(self._create_fake_instance(
+                        params={'config_drive': '1234', }))
 
         try:
-            self.compute.run_instance(self.context, instance['uuid'])
+            self.compute.run_instance(self.context, instance=instance)
             instances = db.instance_get_all(context.get_admin_context())
             instance = instances[0]
 
@@ -290,10 +290,10 @@ class ComputeTestCase(BaseTestCase):
 
     def test_default_access_ip(self):
         self.flags(default_access_ip_network_name='test1', stub_network=False)
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
 
         try:
-            self.compute.run_instance(self.context, instance['uuid'],
+            self.compute.run_instance(self.context, instance=instance,
                     is_first_time=True)
             instances = db.instance_get_all(context.get_admin_context())
             instance = instances[0]
@@ -304,10 +304,10 @@ class ComputeTestCase(BaseTestCase):
             db.instance_destroy(self.context, instance['uuid'])
 
     def test_no_default_access_ip(self):
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
 
         try:
-            self.compute.run_instance(self.context, instance['uuid'],
+            self.compute.run_instance(self.context, instance=instance,
                     is_first_time=True)
             instances = db.instance_get_all(context.get_admin_context())
             instance = instances[0]
@@ -338,7 +338,7 @@ class ComputeTestCase(BaseTestCase):
                        '_setup_block_device_mapping', fake)
         instance_uuid = self._create_instance()
         self.assertRaises(test.TestingException, self.compute.run_instance,
-                          self.context, instance_uuid)
+                          self.context, instance_uuid=instance_uuid)
         #check state is failed even after the periodic poll
         self._assert_state({'vm_state': vm_states.ERROR,
                             'task_state': task_states.BLOCK_DEVICE_MAPPING})
@@ -356,7 +356,7 @@ class ComputeTestCase(BaseTestCase):
         self.stubs.Set(self.compute.driver, 'spawn', fake)
         instance_uuid = self._create_instance()
         self.assertRaises(test.TestingException, self.compute.run_instance,
-                          self.context, instance_uuid)
+                          self.context, instance_uuid=instance_uuid)
         #check state is failed even after the periodic poll
         self._assert_state({'vm_state': vm_states.ERROR,
                             'task_state': task_states.SPAWNING})
@@ -380,7 +380,7 @@ class ComputeTestCase(BaseTestCase):
         """Make sure it is possible to  run and terminate instance"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
 
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         instances = db.instance_get_all(context.get_admin_context())
         LOG.info(_("Running instances: %s"), instances)
@@ -396,7 +396,7 @@ class ComputeTestCase(BaseTestCase):
         # This is as reported in LP bug 1008875
         instance = jsonutils.to_primitive(self._create_fake_instance())
 
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         instances = db.instance_get_all(context.get_admin_context())
         LOG.info(_("Running instances: %s"), instances)
@@ -421,7 +421,7 @@ class ComputeTestCase(BaseTestCase):
         self.assertEqual(instance['launched_at'], None)
         self.assertEqual(instance['deleted_at'], None)
         launch = timeutils.utcnow()
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
         instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         self.assert_(instance['launched_at'] > launch)
         self.assertEqual(instance['deleted_at'], None)
@@ -435,16 +435,14 @@ class ComputeTestCase(BaseTestCase):
     def test_stop(self):
         """Ensure instance can be stopped"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
         self.compute.stop_instance(self.context, instance=instance)
         self.compute.terminate_instance(self.context, instance=instance)
 
     def test_start(self):
         """Ensure instance can be started"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
         self.compute.stop_instance(self.context, instance=instance)
         self.compute.start_instance(self.context, instance=instance)
         self.compute.terminate_instance(self.context, instance=instance)
@@ -468,7 +466,7 @@ class ComputeTestCase(BaseTestCase):
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         # Make sure these methods work with both instance and instance_uuid
 
@@ -497,8 +495,7 @@ class ComputeTestCase(BaseTestCase):
                        fake_driver_power_on)
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
         self.compute.power_on_instance(self.context, instance=instance)
         self.assertTrue(called['power_on'])
         self.compute.terminate_instance(self.context, instance=instance)
@@ -515,28 +512,23 @@ class ComputeTestCase(BaseTestCase):
                        fake_driver_power_off)
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
         self.compute.power_off_instance(self.context, instance=instance)
         self.assertTrue(called['power_off'])
         self.compute.terminate_instance(self.context, instance=instance)
 
     def test_pause(self):
         """Ensure instance can be paused and unpaused"""
-        instance = self._create_fake_instance()
-        instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
-        self.compute.pause_instance(self.context,
-                instance=jsonutils.to_primitive(instance))
-        self.compute.unpause_instance(self.context,
-                instance=jsonutils.to_primitive(instance))
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=instance)
+        self.compute.pause_instance(self.context, instance=instance)
+        self.compute.unpause_instance(self.context, instance=instance)
         self.compute.terminate_instance(self.context, instance=instance)
 
     def test_suspend(self):
         """ensure instance can be suspended and resumed"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
         self.compute.suspend_instance(self.context, instance=instance)
         self.compute.resume_instance(self.context, instance=instance)
         self.compute.terminate_instance(self.context, instance=instance)
@@ -547,13 +539,13 @@ class ComputeTestCase(BaseTestCase):
             raise test.TestingException()
         self.stubs.Set(self.compute.driver, 'suspend', fake)
 
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
         self.assertRaises(test.TestingException,
                           self.compute.suspend_instance,
                           self.context,
-                          instance=jsonutils.to_primitive(instance))
+                          instance=instance)
         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=instance)
@@ -561,10 +553,9 @@ class ComputeTestCase(BaseTestCase):
     def test_rebuild(self):
         """Ensure instance can be rebuilt"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        instance_uuid = instance['uuid']
         image_ref = instance['image_ref']
 
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
         self.compute.rebuild_instance(self.context, image_ref, image_ref,
                 instance=instance)
         self.compute.terminate_instance(self.context, instance=instance)
@@ -578,7 +569,7 @@ class ComputeTestCase(BaseTestCase):
         instance_uuid = instance['uuid']
         image_ref = instance['image_ref']
 
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
         timeutils.set_time_override(cur_time)
         self.compute.rebuild_instance(self.context, image_ref, image_ref,
                 instance=instance)
@@ -589,14 +580,14 @@ class ComputeTestCase(BaseTestCase):
 
     def test_reboot_soft(self):
         """Ensure instance can be soft rebooted"""
-        instance = self._create_fake_instance()
-        self.compute.run_instance(self.context, instance['uuid'])
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=instance)
         db.instance_update(self.context, instance['uuid'],
                            {'task_state': task_states.REBOOTING})
 
         reboot_type = "SOFT"
         self.compute.reboot_instance(self.context,
-                                     instance=jsonutils.to_primitive(instance),
+                                     instance=instance,
                                      reboot_type=reboot_type)
 
         inst_ref = db.instance_get_by_uuid(self.context, instance['uuid'])
@@ -608,14 +599,13 @@ class ComputeTestCase(BaseTestCase):
 
     def test_reboot_hard(self):
         """Ensure instance can be hard rebooted"""
-        instance = self._create_fake_instance()
-        self.compute.run_instance(self.context, instance['uuid'])
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=instance)
         db.instance_update(self.context, instance['uuid'],
                            {'task_state': task_states.REBOOTING_HARD})
 
         reboot_type = "HARD"
-        self.compute.reboot_instance(self.context,
-                                     instance=jsonutils.to_primitive(instance),
+        self.compute.reboot_instance(self.context, instance=instance,
                                      reboot_type=reboot_type)
 
         inst_ref = db.instance_get_by_uuid(self.context, instance['uuid'])
@@ -628,7 +618,7 @@ class ComputeTestCase(BaseTestCase):
     def test_set_admin_password(self):
         """Ensure instance can have its admin password set"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
         db.instance_update(self.context, instance['uuid'],
                            {'task_state': task_states.UPDATING_PASSWORD})
 
@@ -647,8 +637,8 @@ class ComputeTestCase(BaseTestCase):
 
     def test_set_admin_password_bad_state(self):
         """Test setting password while instance is rebuilding."""
-        instance = self._create_fake_instance()
-        self.compute.run_instance(self.context, instance['uuid'])
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=instance)
         db.instance_update(self.context, instance['uuid'], {
             "power_state": power_state.NOSTATE,
         })
@@ -688,8 +678,8 @@ class ComputeTestCase(BaseTestCase):
         self.stubs.Set(nova.virt.fake.FakeDriver, 'set_admin_password',
                        fake_driver_set_pass)
 
-        instance = self._create_fake_instance()
-        self.compute.run_instance(self.context, instance['uuid'])
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=instance)
         db.instance_update(self.context, instance['uuid'],
                            {'task_state': task_states.UPDATING_PASSWORD})
 
@@ -744,7 +734,7 @@ class ComputeTestCase(BaseTestCase):
                        fake_driver_inject_file)
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
         self.compute.inject_file(self.context, "/tmp/test",
                 "File Contents", instance=instance)
         self.assertTrue(called['inject'])
@@ -761,8 +751,7 @@ class ComputeTestCase(BaseTestCase):
                        fake_driver_inject_network)
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
         self.compute.inject_network_info(self.context, instance=instance)
         self.assertTrue(called['inject'])
         self.compute.terminate_instance(self.context, instance=instance)
@@ -779,7 +768,7 @@ class ComputeTestCase(BaseTestCase):
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         # Make sure it works with both an instance and instance_uuid
         self.compute.reset_network(self.context, instance=instance)
@@ -794,7 +783,7 @@ class ComputeTestCase(BaseTestCase):
         instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
         name = "myfakesnapshot"
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
         self.compute.snapshot_instance(self.context, name, instance=instance)
         self.compute.terminate_instance(self.context, instance=instance)
 
@@ -806,7 +795,7 @@ class ComputeTestCase(BaseTestCase):
         self.stubs.Set(self.compute.driver, 'snapshot', fake_snapshot)
 
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
         self.assertRaises(test.TestingException,
                           self.compute.snapshot_instance,
                           self.context, "failing_snapshot", instance=instance)
@@ -830,7 +819,7 @@ class ComputeTestCase(BaseTestCase):
     def test_console_output(self):
         """Make sure we can get console output from instance"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         output = self.compute.get_console_output(self.context,
                 instance=instance)
@@ -840,7 +829,7 @@ class ComputeTestCase(BaseTestCase):
     def test_console_output_tail(self):
         """Make sure we can get console output from instance"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         output = self.compute.get_console_output(self.context,
                 instance=instance, tail_length=2)
@@ -850,7 +839,7 @@ class ComputeTestCase(BaseTestCase):
     def test_novnc_vnc_console(self):
         """Make sure we can a vnc console for an instance."""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         # Try with the full instance
         console = self.compute.get_vnc_console(self.context, 'novnc',
@@ -867,7 +856,7 @@ class ComputeTestCase(BaseTestCase):
     def test_xvpvnc_vnc_console(self):
         """Make sure we can a vnc console for an instance."""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         console = self.compute.get_vnc_console(self.context, 'xvpvnc',
                                                instance=instance)
@@ -877,7 +866,7 @@ class ComputeTestCase(BaseTestCase):
     def test_invalid_vnc_console_type(self):
         """Raise useful error if console type is an unrecognised string"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         self.assertRaises(exception.ConsoleTypeInvalid,
                           self.compute.get_vnc_console,
@@ -887,7 +876,7 @@ class ComputeTestCase(BaseTestCase):
     def test_missing_vnc_console_type(self):
         """Raise useful error is console type is None"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         self.assertRaises(exception.ConsoleTypeInvalid,
                           self.compute.get_vnc_console,
@@ -897,7 +886,7 @@ class ComputeTestCase(BaseTestCase):
     def test_diagnostics(self):
         """Make sure we can get diagnostics for an instance."""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         diagnostics = self.compute.get_diagnostics(self.context,
                 instance_uuid=instance['uuid'])
@@ -952,9 +941,9 @@ class ComputeTestCase(BaseTestCase):
 
     def test_run_instance_usage_notification(self):
         """Ensure run instance generates appropriate usage notification"""
-        inst_ref = self._create_fake_instance()
-        instance_uuid = inst_ref['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        instance_uuid = instance['uuid']
+        self.compute.run_instance(self.context, instance=instance)
         self.assertEquals(len(test_notifier.NOTIFICATIONS), 2)
         inst_ref = db.instance_get_by_uuid(self.context, instance_uuid)
         msg = test_notifier.NOTIFICATIONS[0]
@@ -988,12 +977,11 @@ class ComputeTestCase(BaseTestCase):
         cur_time = datetime.datetime(2012, 12, 21, 12, 21)
         timeutils.set_time_override(old_time)
 
-        inst_ref = self._create_fake_instance()
-        self.compute.run_instance(self.context, inst_ref['uuid'])
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=instance)
         test_notifier.NOTIFICATIONS = []
         timeutils.set_time_override(cur_time)
-        self.compute.terminate_instance(self.context,
-                instance=jsonutils.to_primitive(inst_ref))
+        self.compute.terminate_instance(self.context, instance=instance)
 
         self.assertEquals(len(test_notifier.NOTIFICATIONS), 4)
 
@@ -1010,7 +998,7 @@ class ComputeTestCase(BaseTestCase):
         payload = msg1['payload']
         self.assertEquals(payload['tenant_id'], self.project_id)
         self.assertEquals(payload['user_id'], self.user_id)
-        self.assertEquals(payload['instance_id'], inst_ref.uuid)
+        self.assertEquals(payload['instance_id'], instance['uuid'])
         self.assertEquals(payload['instance_type'], 'm1.tiny')
         type_id = instance_types.get_instance_type_by_name('m1.tiny')['id']
         self.assertEquals(str(payload['instance_type_id']), str(type_id))
@@ -1025,17 +1013,16 @@ class ComputeTestCase(BaseTestCase):
     def test_run_instance_existing(self):
         """Ensure failure when running an instance that already exists"""
         instance = jsonutils.to_primitive(self._create_fake_instance())
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
         self.assertRaises(exception.Invalid,
                           self.compute.run_instance,
                           self.context,
-                          instance['uuid'])
+                          instance=instance)
         self.compute.terminate_instance(self.context, instance=instance)
 
     def test_instance_set_to_error_on_uncaught_exception(self):
         """Test that instance is set to error state when exception is raised"""
-        instance = self._create_fake_instance()
-        instance_uuid = instance['uuid']
+        instance = jsonutils.to_primitive(self._create_fake_instance())
 
         self.mox.StubOutWithMock(self.compute.network_api,
                                  "allocate_for_instance")
@@ -1052,10 +1039,10 @@ class ComputeTestCase(BaseTestCase):
         self.assertRaises(rpc_common.RemoteError,
                           self.compute.run_instance,
                           self.context,
-                          instance_uuid)
+                          instance=instance)
 
         instance = db.instance_get_by_uuid(context.get_admin_context(),
-                                           instance_uuid)
+                                           instance['uuid'])
         self.assertEqual(vm_states.ERROR, instance['vm_state'])
 
         self.compute.terminate_instance(self.context,
@@ -1080,7 +1067,7 @@ class ComputeTestCase(BaseTestCase):
 
     def test_network_is_deallocated_on_spawn_failure(self):
         """When a spawn fails the network must be deallocated"""
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
 
         self.mox.StubOutWithMock(self.compute, "_setup_block_device_mapping")
         self.compute._setup_block_device_mapping(
@@ -1091,11 +1078,9 @@ class ComputeTestCase(BaseTestCase):
 
         self.assertRaises(rpc.common.RemoteError,
                           self.compute.run_instance,
-                          self.context,
-                          instance['uuid'])
+                          self.context, instance=instance)
 
-        self.compute.terminate_instance(self.context,
-                instance=jsonutils.to_primitive(instance))
+        self.compute.terminate_instance(self.context, instance=instance)
 
     def test_get_lock(self):
         instance = jsonutils.to_primitive(self._create_fake_instance())
@@ -1106,9 +1091,9 @@ class ComputeTestCase(BaseTestCase):
 
     def test_lock(self):
         """ensure locked instance cannot be changed"""
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         non_admin_context = context.RequestContext(None,
                                                    None,
@@ -1187,8 +1172,8 @@ class ComputeTestCase(BaseTestCase):
         old_time = datetime.datetime(2012, 4, 1)
         cur_time = datetime.datetime(2012, 12, 21, 12, 21)
         timeutils.set_time_override(old_time)
-        inst_ref = self._create_fake_instance()
-        self.compute.run_instance(self.context, inst_ref['uuid'])
+        inst_ref = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=inst_ref)
         timeutils.set_time_override(cur_time)
 
         test_notifier.NOTIFICATIONS = []
@@ -1255,7 +1240,7 @@ class ComputeTestCase(BaseTestCase):
         new_type = instance_types.get_instance_type_by_name('m1.small')
         new_type = jsonutils.to_primitive(new_type)
         new_type_id = new_type['id']
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         db.instance_update(self.context, instance['uuid'], {'host': 'foo'})
         self.compute.prep_resize(context, instance=instance,
@@ -1300,16 +1285,15 @@ class ComputeTestCase(BaseTestCase):
         old_time = datetime.datetime(2012, 4, 1)
         cur_time = datetime.datetime(2012, 12, 21, 12, 21)
         timeutils.set_time_override(old_time)
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         context = self.context.elevated()
 
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
         timeutils.set_time_override(cur_time)
         test_notifier.NOTIFICATIONS = []
 
         db.instance_update(self.context, instance['uuid'], {'host': 'foo'})
-        self.compute.prep_resize(context,
-                instance=jsonutils.to_primitive(instance),
+        self.compute.prep_resize(context, instance=instance,
                 instance_type={}, image={})
         db.migration_get_by_instance_and_status(context,
                                                 instance['uuid'],
@@ -1338,26 +1322,24 @@ 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=jsonutils.to_primitive(instance))
+        self.compute.terminate_instance(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 = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         context = self.context.elevated()
 
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
         new_instance = db.instance_update(self.context, instance['uuid'],
                                           {'host': 'foo'})
+        new_instance = jsonutils.to_primitive(new_instance)
 
         self.assertRaises(exception.MigrationError, self.compute.prep_resize,
-                          context,
-                          instance=jsonutils.to_primitive(new_instance),
+                          context, instance=new_instance,
                           instance_type={}, image={})
-        self.compute.terminate_instance(context,
-            instance=jsonutils.to_primitive(new_instance))
+        self.compute.terminate_instance(context, instance=new_instance)
 
     def test_resize_instance_driver_error(self):
         """Ensure instance status set to Error on resize error"""
@@ -1371,7 +1353,7 @@ class ComputeTestCase(BaseTestCase):
         instance = jsonutils.to_primitive(self._create_fake_instance())
         context = self.context.elevated()
 
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
         db.instance_update(self.context, instance['uuid'], {'host': 'foo'})
         self.compute.prep_resize(context, instance=instance,
                                  instance_type={}, image={})
@@ -1392,7 +1374,7 @@ class ComputeTestCase(BaseTestCase):
         instance = jsonutils.to_primitive(self._create_fake_instance())
         context = self.context.elevated()
 
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
         db.instance_update(self.context, instance['uuid'],
                            {'host': 'foo'})
         self.compute.prep_resize(context, instance=instance,
@@ -1413,10 +1395,10 @@ class ComputeTestCase(BaseTestCase):
         self.stubs.Set(self.compute.driver, 'finish_revert_migration', fake)
 
         context = self.context.elevated()
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
 
-        self.compute.run_instance(self.context, 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'])
@@ -1475,12 +1457,11 @@ class ComputeTestCase(BaseTestCase):
     def test_resize_same_source_fails(self):
         """Ensure instance fails to migrate when source and destination are
         the same host"""
-        instance = self._create_fake_instance()
-        self.compute.run_instance(self.context, instance['uuid'])
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=instance)
         instance = db.instance_get_by_uuid(self.context, instance['uuid'])
         self.assertRaises(exception.MigrationError, self.compute.prep_resize,
-                self.context,
-                instance=jsonutils.to_primitive(instance),
+                self.context, instance=instance,
                 instance_type={}, image={})
         self.compute.terminate_instance(self.context,
                 instance=jsonutils.to_primitive(instance))
@@ -1496,7 +1477,7 @@ class ComputeTestCase(BaseTestCase):
         inst_ref = jsonutils.to_primitive(self._create_fake_instance())
         context = self.context.elevated()
 
-        self.compute.run_instance(self.context, inst_ref['uuid'])
+        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, instance_type={},
                                  image={})
@@ -1801,9 +1782,9 @@ class ComputeTestCase(BaseTestCase):
         self.stubs.Set(compute_manager.ComputeManager,
                 '_report_driver_status', nop_report_driver_status)
 
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
 
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         instances = db.instance_get_all(context.get_admin_context())
         LOG.info(_("Running instances: %s"), instances)
@@ -2234,9 +2215,9 @@ class ComputeAPITestCase(BaseTestCase):
         }
 
     def _run_instance(self):
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         instance = db.instance_get_by_uuid(self.context, instance_uuid)
         self.assertEqual(instance['task_state'], None)
@@ -2439,7 +2420,7 @@ class ComputeAPITestCase(BaseTestCase):
     def test_start(self):
         instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         self.compute.stop_instance(self.context, instance=instance)
 
@@ -2454,9 +2435,9 @@ class ComputeAPITestCase(BaseTestCase):
         db.instance_destroy(self.context, instance['uuid'])
 
     def test_stop(self):
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         instance = db.instance_get_by_uuid(self.context, instance_uuid)
         self.assertEqual(instance['task_state'], None)
@@ -2481,8 +2462,8 @@ class ComputeAPITestCase(BaseTestCase):
             self.compute_api.start(self.context, instance)
             check_state(instance_uuid, power_state_, vm_state_, task_state_)
 
-        instance = self._create_fake_instance()
-        self.compute.run_instance(self.context, instance['uuid'])
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=instance)
 
         check_state(instance['uuid'], power_state.RUNNING, vm_states.ACTIVE,
                     None)
@@ -2562,9 +2543,9 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_force_delete(self):
         """Ensure instance can be deleted after a soft delete"""
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         instance = db.instance_get_by_uuid(self.context, instance_uuid)
         self.compute_api.soft_delete(self.context, instance)
@@ -2584,9 +2565,9 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_suspend(self):
         """Ensure instance can be suspended"""
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         self.assertEqual(instance['task_state'], None)
 
@@ -2599,8 +2580,8 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_resume(self):
         """Ensure instance can be resumed (if suspended)"""
-        instance = self._create_fake_instance()
-        self.compute.run_instance(self.context, instance['uuid'])
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=instance)
         db.instance_update(self.context, instance['uuid'],
                            {'vm_state': vm_states.SUSPENDED})
         instance = db.instance_get(self.context, instance['id'])
@@ -2616,9 +2597,9 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_pause(self):
         """Ensure instance can be paused"""
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         self.assertEqual(instance['task_state'], None)
 
@@ -2631,14 +2612,13 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_unpause(self):
         """Ensure instance can be unpaused"""
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         self.assertEqual(instance['task_state'], None)
 
-        self.compute.pause_instance(self.context,
-                instance=jsonutils.to_primitive(instance))
+        self.compute.pause_instance(self.context, instance=instance)
         # set the state that the instance gets when pause finishes
         instance = db.instance_update(self.context, instance['uuid'],
                                       {'vm_state': vm_states.PAUSED})
@@ -2652,9 +2632,9 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_restore(self):
         """Ensure instance can be restored from a soft delete"""
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         instance = db.instance_get_by_uuid(self.context, instance_uuid)
         self.compute_api.soft_delete(self.context, instance)
@@ -2675,9 +2655,9 @@ class ComputeAPITestCase(BaseTestCase):
         db.instance_destroy(self.context, instance['uuid'])
 
     def test_rebuild(self):
-        inst_ref = self._create_fake_instance()
-        instance_uuid = inst_ref['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        instance_uuid = instance['uuid']
+        self.compute.run_instance(self.context, instance=instance)
 
         instance = db.instance_get_by_uuid(self.context, instance_uuid)
         self.assertEqual(instance['task_state'], None)
@@ -2721,10 +2701,10 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_reboot_soft(self):
         """Ensure instance can be soft rebooted"""
-        inst_ref = self._create_fake_instance()
-        self.compute.run_instance(self.context, inst_ref['uuid'])
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=instance)
 
-        inst_ref = db.instance_get_by_uuid(self.context, inst_ref['uuid'])
+        inst_ref = db.instance_get_by_uuid(self.context, instance['uuid'])
         self.assertEqual(inst_ref['task_state'], None)
 
         reboot_type = "SOFT"
@@ -2737,10 +2717,10 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_reboot_hard(self):
         """Ensure instance can be hard rebooted"""
-        inst_ref = self._create_fake_instance()
-        self.compute.run_instance(self.context, inst_ref['uuid'])
+        instance = jsonutils.to_primitive(self._create_fake_instance())
+        self.compute.run_instance(self.context, instance=instance)
 
-        inst_ref = db.instance_get_by_uuid(self.context, inst_ref['uuid'])
+        inst_ref = db.instance_get_by_uuid(self.context, instance['uuid'])
         self.assertEqual(inst_ref['task_state'], None)
 
         reboot_type = "HARD"
@@ -2763,9 +2743,9 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_set_admin_password(self):
         """Ensure instance can have its admin password set"""
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         inst_ref = db.instance_get_by_uuid(self.context, instance_uuid)
         self.assertEqual(inst_ref['vm_state'], vm_states.ACTIVE)
@@ -2787,9 +2767,9 @@ class ComputeAPITestCase(BaseTestCase):
                 instance=jsonutils.to_primitive(inst_ref))
 
     def test_rescue_unrescue(self):
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         instance_uuid = instance['uuid']
-        self.compute.run_instance(self.context, instance_uuid)
+        self.compute.run_instance(self.context, instance=instance)
 
         instance = db.instance_get_by_uuid(self.context, instance_uuid)
         self.assertEqual(instance['vm_state'], vm_states.ACTIVE)
@@ -3001,9 +2981,9 @@ class ComputeAPITestCase(BaseTestCase):
         db.instance_destroy(self.context, instance['uuid'])
 
     def test_resize_confirm_through_api(self):
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         context = self.context.elevated()
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
         instance = db.instance_get_by_uuid(context, instance['uuid'])
         self.compute_api.resize(context, instance, '4')
 
@@ -3021,10 +3001,10 @@ class ComputeAPITestCase(BaseTestCase):
             instance=jsonutils.to_primitive(instance))
 
     def test_resize_revert_through_api(self):
-        instance = self._create_fake_instance()
+        instance = jsonutils.to_primitive(self._create_fake_instance())
         context = self.context.elevated()
         instance = db.instance_get_by_uuid(context, instance['uuid'])
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         self.compute_api.resize(context, instance, '4')
 
@@ -3051,37 +3031,37 @@ class ComputeAPITestCase(BaseTestCase):
         instance = self._create_fake_instance()
         context = self.context.elevated()
         instance = db.instance_get_by_uuid(context, instance['uuid'])
-        self.compute.run_instance(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.compute.terminate_instance(context,
-                instance=jsonutils.to_primitive(instance))
+        self.compute.terminate_instance(context, instance=instance)
 
     def test_resize_same_size_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 = jsonutils.to_primitive(instance)
 
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context, instance=instance)
 
         self.assertRaises(exception.CannotResizeToSameSize,
                           self.compute_api.resize, context, instance, 1)
 
-        self.compute.terminate_instance(context,
-                instance=jsonutils.to_primitive(instance))
+        self.compute.terminate_instance(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'])
-        self.compute.run_instance(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=jsonutils.to_primitive(instance))
+        self.compute.terminate_instance(context, instance=instance)
 
     def test_resize_request_spec(self):
         def _fake_cast(context, topic, msg):
@@ -3096,12 +3076,12 @@ class ComputeAPITestCase(BaseTestCase):
         context = self.context.elevated()
         instance = self._create_fake_instance(dict(host='host2'))
         instance = db.instance_get_by_uuid(context, instance['uuid'])
-        self.compute.run_instance(self.context, instance['uuid'])
+        instance = jsonutils.to_primitive(instance)
+        self.compute.run_instance(self.context, instance=instance)
         try:
             self.compute_api.resize(context, instance, None)
         finally:
-            self.compute.terminate_instance(context,
-                    instance=jsonutils.to_primitive(instance))
+            self.compute.terminate_instance(context, instance=instance)
 
     def test_resize_request_spec_noavoid(self):
         def _fake_cast(context, topic, msg):
@@ -3117,12 +3097,12 @@ class ComputeAPITestCase(BaseTestCase):
         context = self.context.elevated()
         instance = self._create_fake_instance(dict(host='host2'))
         instance = db.instance_get_by_uuid(context, instance['uuid'])
-        self.compute.run_instance(self.context, instance['uuid'])
+        instance = jsonutils.to_primitive(instance)
+        self.compute.run_instance(self.context, instance=instance)
         try:
             self.compute_api.resize(context, instance, None)
         finally:
-            self.compute.terminate_instance(context,
-                    instance=jsonutils.to_primitive(instance))
+            self.compute.terminate_instance(context, instance=instance)
 
     def test_get(self):
         """Test get instance"""
@@ -3697,10 +3677,10 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_instance_unknown_architecture(self):
         """Test if the architecture is unknown."""
-        instance = self._create_fake_instance(
-                        params={'architecture': ''})
+        instance = jsonutils.to_primitive(self._create_fake_instance(
+                        params={'architecture': ''}))
         try:
-            self.compute.run_instance(self.context, instance['uuid'])
+            self.compute.run_instance(self.context, instance=instance)
             instances = db.instance_get_all(context.get_admin_context())
             instance = instances[0]
             self.assertNotEqual(instance['architecture'], 'Unknown')
@@ -3822,14 +3802,16 @@ class ComputeAPITestCase(BaseTestCase):
 
     def test_inject_network_info(self):
         instance = self._create_fake_instance()
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context,
+                instance=jsonutils.to_primitive(instance))
         instance = self.compute_api.get(self.context, instance['uuid'])
         self.compute_api.inject_network_info(self.context, instance)
         self.compute_api.delete(self.context, instance)
 
     def test_reset_network(self):
         instance = self._create_fake_instance()
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context,
+                instance=jsonutils.to_primitive(instance))
         instance = self.compute_api.get(self.context, instance['uuid'])
         self.compute_api.reset_network(self.context, instance)
 
@@ -3852,7 +3834,8 @@ class ComputeAPITestCase(BaseTestCase):
     def test_add_remove_security_group(self):
         instance = self._create_fake_instance()
 
-        self.compute.run_instance(self.context, instance['uuid'])
+        self.compute.run_instance(self.context,
+                instance=jsonutils.to_primitive(instance))
         instance = self.compute_api.get(self.context, instance['uuid'])
         security_group_name = self._create_group()['name']
         self.security_group_api.add_to_instance(self.context,
@@ -4501,14 +4484,16 @@ class ComputeReschedulingExceptionTestCase(BaseTestCase):
         self.stubs.Set(self.compute, '_spawn',
                 exploding_spawn)
 
-        self.instance_uuid = self._create_fake_instance()['uuid']
+        self.fake_instance = jsonutils.to_primitive(
+                self._create_fake_instance())
+        self.instance_uuid = self.fake_instance['uuid']
 
     def test_exception_with_rescheduling_disabled(self):
         """Spawn fails and re-scheduling is disabled."""
         # this won't be re-scheduled:
         self.assertRaises(ThatsNoOrdinaryRabbitException,
-                self.compute._run_instance, self.context, self.instance_uuid,
-                None, {}, None, None, None, None)
+                self.compute._run_instance, self.context,
+                None, {}, None, None, None, None, self.fake_instance, None)
 
     def test_exception_with_rescheduling_enabled(self):
         """Spawn fails and re-scheduling is enabled.  Original exception
@@ -4519,8 +4504,9 @@ class ComputeReschedulingExceptionTestCase(BaseTestCase):
         filter_properties = dict(retry=retry)
         request_spec = dict(num_attempts=1)
         self.assertNotRaises(ThatsNoOrdinaryRabbitException,
-                self.compute._run_instance, self.context, self.instance_uuid,
-                filter_properties=filter_properties, request_spec=request_spec)
+                self.compute._run_instance, self.context,
+                filter_properties=filter_properties, request_spec=request_spec,
+                instance=self.fake_instance)
 
     def test_exception_context_cleared(self):
         """Test with no rescheduling and an additional exception occurs
@@ -4536,5 +4522,5 @@ class ComputeReschedulingExceptionTestCase(BaseTestCase):
 
         # the original exception should now be raised:
         self.assertRaises(ThatsNoOrdinaryRabbitException,
-                self.compute._run_instance, self.context, self.instance_uuid,
-                None, {}, None, None, None, None)
+                self.compute._run_instance, self.context,
+                None, {}, None, None, None, None, self.fake_instance, None)
diff --git a/nova/tests/compute/test_rpcapi.py b/nova/tests/compute/test_rpcapi.py
index 94b44b345..ef9064a39 100644
--- a/nova/tests/compute/test_rpcapi.py
+++ b/nova/tests/compute/test_rpcapi.py
@@ -280,6 +280,13 @@ class ComputeRpcAPITestCase(test.TestCase):
                 'cast', instance=self.fake_instance, host='host',
                 version='1.32')
 
+    def test_run_instance(self):
+        self._test_compute_api('run_instance', 'cast',
+                instance=self.fake_instance, host='fake_host',
+                request_spec='fake_spec', filter_properties={},
+                requested_networks='networks', injected_files='files',
+                admin_password='pw', is_first_time=True, version='1.39')
+
     def test_set_admin_password(self):
         self._test_compute_api('set_admin_password', 'call',
                 instance=self.fake_instance, new_pass='pw', version='1.33')
diff --git a/nova/tests/scheduler/test_chance_scheduler.py b/nova/tests/scheduler/test_chance_scheduler.py
index e7f06e4e1..663044ee8 100644
--- a/nova/tests/scheduler/test_chance_scheduler.py
+++ b/nova/tests/scheduler/test_chance_scheduler.py
@@ -22,6 +22,7 @@ import random
 
 import mox
 
+from nova.compute import rpcapi as compute_rpcapi
 from nova import context
 from nova import exception
 from nova.scheduler import chance
@@ -62,8 +63,6 @@ class ChanceSchedulerTestCase(test_scheduler.SchedulerTestCase):
         ctxt = context.RequestContext('fake', 'fake', False)
         ctxt_elevated = 'fake-context-elevated'
         fake_args = (1, 2, 3)
-        fake_kwargs = {'fake_kwarg1': 'fake_value1',
-                       'fake_kwarg2': 'fake_value2'}
         instance_opts = {'fake_opt1': 'meow'}
         request_spec = {'num_instances': 2,
                         'instance_properties': instance_opts}
@@ -85,8 +84,9 @@ class ChanceSchedulerTestCase(test_scheduler.SchedulerTestCase):
         self.mox.StubOutWithMock(self.driver, 'hosts_up')
         self.mox.StubOutWithMock(random, 'random')
         self.mox.StubOutWithMock(self.driver, 'create_instance_db_entry')
-        self.mox.StubOutWithMock(driver, 'cast_to_compute_host')
         self.mox.StubOutWithMock(driver, 'encode_instance')
+        self.mox.StubOutWithMock(driver, 'instance_update_db')
+        self.mox.StubOutWithMock(compute_rpcapi.ComputeAPI, 'run_instance')
 
         ctxt.elevated().AndReturn(ctxt_elevated)
         # instance 1
@@ -96,8 +96,10 @@ class ChanceSchedulerTestCase(test_scheduler.SchedulerTestCase):
         self.driver.create_instance_db_entry(ctxt, request_spec,
                 reservations).WithSideEffects(_add_uuid1).AndReturn(
                 instance1)
-        driver.cast_to_compute_host(ctxt, 'host3', 'run_instance',
-                instance_uuid=instance1['uuid'], requested_networks=None,
+        driver.instance_update_db(ctxt, instance1['uuid'],
+                'host3').AndReturn(instance1)
+        compute_rpcapi.ComputeAPI.run_instance(ctxt, host='host3',
+                instance=instance1, requested_networks=None,
                 injected_files=None, admin_password=None, is_first_time=None,
                 request_spec=request_spec, filter_properties={})
 
@@ -110,8 +112,10 @@ class ChanceSchedulerTestCase(test_scheduler.SchedulerTestCase):
         self.driver.create_instance_db_entry(ctxt, request_spec,
                 reservations).WithSideEffects(_add_uuid2).AndReturn(
                 instance2)
-        driver.cast_to_compute_host(ctxt, 'host1', 'run_instance',
-                instance_uuid=instance2['uuid'], requested_networks=None,
+        driver.instance_update_db(ctxt, instance2['uuid'],
+                'host1').AndReturn(instance2)
+        compute_rpcapi.ComputeAPI.run_instance(ctxt, host='host1',
+                instance=instance2, requested_networks=None,
                 injected_files=None, admin_password=None, is_first_time=None,
                 request_spec=request_spec, filter_properties={})
 
@@ -124,7 +128,7 @@ class ChanceSchedulerTestCase(test_scheduler.SchedulerTestCase):
         self.assertEqual(result, expected)
 
     def test_scheduler_includes_launch_index(self):
-        ctxt = "fake-context"
+        ctxt = context.RequestContext('fake', 'fake', False)
         instance_opts = {'fake_opt1': 'meow'}
         request_spec = {'num_instances': 2,
                         'instance_properties': instance_opts}
@@ -152,16 +156,20 @@ class ChanceSchedulerTestCase(test_scheduler.SchedulerTestCase):
 
         self.mox.StubOutWithMock(self.driver, '_schedule')
         self.mox.StubOutWithMock(self.driver, 'create_instance_db_entry')
-        self.mox.StubOutWithMock(driver, 'cast_to_compute_host')
         self.mox.StubOutWithMock(driver, 'encode_instance')
+        self.mox.StubOutWithMock(driver, 'instance_update_db')
+        self.mox.StubOutWithMock(compute_rpcapi.ComputeAPI, 'run_instance')
+
         # instance 1
         self.driver._schedule(ctxt, 'compute', request_spec,
                               {}).AndReturn('host')
         self.driver.create_instance_db_entry(
             ctxt, mox.Func(_has_launch_index(0)), None
             ).WithSideEffects(_add_uuid(1)).AndReturn(instance1)
-        driver.cast_to_compute_host(ctxt, 'host', 'run_instance',
-                instance_uuid=instance1['uuid'], requested_networks=None,
+        driver.instance_update_db(ctxt, instance1['uuid'],
+                'host').AndReturn(instance1)
+        compute_rpcapi.ComputeAPI.run_instance(ctxt, host='host',
+                instance=instance1, requested_networks=None,
                 injected_files=None, admin_password=None, is_first_time=None,
                 request_spec=request_spec, filter_properties={})
         driver.encode_instance(instance1).AndReturn(instance1)
@@ -171,8 +179,10 @@ class ChanceSchedulerTestCase(test_scheduler.SchedulerTestCase):
         self.driver.create_instance_db_entry(
             ctxt, mox.Func(_has_launch_index(1)), None
             ).WithSideEffects(_add_uuid(2)).AndReturn(instance2)
-        driver.cast_to_compute_host(ctxt, 'host', 'run_instance',
-                instance_uuid=instance2['uuid'], requested_networks=None,
+        driver.instance_update_db(ctxt, instance2['uuid'],
+                'host').AndReturn(instance2)
+        compute_rpcapi.ComputeAPI.run_instance(ctxt, host='host',
+                instance=instance2, requested_networks=None,
                 injected_files=None, admin_password=None, is_first_time=None,
                 request_spec=request_spec, filter_properties={})
         driver.encode_instance(instance2).AndReturn(instance2)
@@ -185,8 +195,6 @@ class ChanceSchedulerTestCase(test_scheduler.SchedulerTestCase):
         ctxt = context.RequestContext('fake', 'fake', False)
         ctxt_elevated = 'fake-context-elevated'
         fake_args = (1, 2, 3)
-        fake_kwargs = {'fake_kwarg1': 'fake_value1',
-                       'fake_kwarg2': 'fake_value2'}
         instance_opts = 'fake_instance_opts'
         request_spec = {'num_instances': 2,
                         'instance_properties': instance_opts}
diff --git a/nova/virt/fake.py b/nova/virt/fake.py
index d775cf6eb..f87e78af4 100644
--- a/nova/virt/fake.py
+++ b/nova/virt/fake.py
@@ -42,6 +42,9 @@ class FakeInstance(object):
         self.name = name
         self.state = state
 
+    def __getitem__(self, key):
+        return getattr(self, key)
+
 
 class FakeDriver(driver.ComputeDriver):
     """Fake hypervisor driver"""
@@ -81,7 +84,7 @@ class FakeDriver(driver.ComputeDriver):
 
     def spawn(self, context, instance, image_meta,
               network_info=None, block_device_info=None):
-        name = instance.name
+        name = instance['name']
         state = power_state.RUNNING
         fake_instance = FakeInstance(name, state)
         self.instances[name] = fake_instance