Merge changes I55bdc631,I57789eab,I5ed8707b,Iaae16e63

* changes:
  Send a full instance in revert_resize.
  Send a full instance in resume_instance.
  Send a full instance in resize_instance.
  Send a full instance in reset_network.

4 files changed, 96 insertions, 71 deletions

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 09c82035f..f1de42d61 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -272,7 +272,7 @@ def _get_image_meta(context, image_ref):
 class ComputeManager(manager.SchedulerDependentManager):
     """Manages the running instances from creation to destruction."""
 
-    RPC_API_VERSION = '1.27'
+    RPC_API_VERSION = '1.31'
 
     def __init__(self, compute_driver=None, *args, **kwargs):
         """Load configuration options and connect to the hypervisor."""
@@ -1413,7 +1413,8 @@ class ComputeManager(manager.SchedulerDependentManager):
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
     @wrap_instance_fault
-    def revert_resize(self, context, instance_uuid, migration_id):
+    def revert_resize(self, context, migration_id, instance=None,
+                      instance_uuid=None):
         """Destroys the new instance on the destination machine.
 
         Reverts the model changes, and powers on the old instance on the
@@ -1421,16 +1422,17 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         """
         migration_ref = self.db.migration_get(context, migration_id)
-        instance_ref = self.db.instance_get_by_uuid(context,
-                migration_ref.instance_uuid)
+        if not instance:
+            instance = self.db.instance_get_by_uuid(context,
+                    migration_ref.instance_uuid)
 
         # NOTE(tr3buchet): tear down networks on destination host
-        self.network_api.setup_networks_on_host(context, instance_ref,
-                                                         teardown=True)
+        self.network_api.setup_networks_on_host(context, instance,
+                                                teardown=True)
 
-        network_info = self._get_instance_nw_info(context, instance_ref)
-        self.driver.destroy(instance_ref, self._legacy_nw_info(network_info))
-        self.compute_rpcapi.finish_revert_resize(context, instance_ref,
+        network_info = self._get_instance_nw_info(context, instance)
+        self.driver.destroy(instance, self._legacy_nw_info(network_info))
+        self.compute_rpcapi.finish_revert_resize(context, instance,
                 migration_ref['id'], migration_ref['source_compute'])
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
@@ -1532,53 +1534,55 @@ class ComputeManager(manager.SchedulerDependentManager):
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
     @wrap_instance_fault
-    def resize_instance(self, context, instance_uuid, migration_id, image):
+    def resize_instance(self, context, migration_id, image, instance=None,
+                        instance_uuid=None):
         """Starts the migration of a running instance to another host."""
         migration_ref = self.db.migration_get(context, migration_id)
-        instance_ref = self.db.instance_get_by_uuid(context,
-                migration_ref.instance_uuid)
+        if not instance:
+            instance = self.db.instance_get_by_uuid(context,
+                    migration_ref.instance_uuid)
         instance_type_ref = self.db.instance_type_get(context,
                 migration_ref.new_instance_type_id)
 
         try:
-            network_info = self._get_instance_nw_info(context, instance_ref)
+            network_info = self._get_instance_nw_info(context, instance)
         except Exception, error:
             with excutils.save_and_reraise_exception():
                 msg = _('%s. Setting instance vm_state to ERROR')
                 LOG.error(msg % error)
-                self._set_instance_error_state(context, instance_uuid)
+                self._set_instance_error_state(context, instance['uuid'])
 
         self.db.migration_update(context,
                                  migration_id,
                                  {'status': 'migrating'})
 
-        self._instance_update(context, instance_uuid,
+        self._instance_update(context, instance['uuid'],
                               task_state=task_states.RESIZE_MIGRATING)
 
         self._notify_about_instance_usage(
-            context, instance_ref, "resize.start", network_info=network_info)
+            context, instance, "resize.start", network_info=network_info)
 
         try:
             disk_info = self.driver.migrate_disk_and_power_off(
-                    context, instance_ref, migration_ref['dest_host'],
+                    context, instance, migration_ref['dest_host'],
                     instance_type_ref, self._legacy_nw_info(network_info))
         except Exception, error:
             with excutils.save_and_reraise_exception():
                 LOG.error(_('%s. Setting instance vm_state to ERROR') % error,
-                          instance=instance_ref)
-                self._set_instance_error_state(context, instance_uuid)
+                          instance=instance)
+                self._set_instance_error_state(context, instance['uuid'])
 
         self.db.migration_update(context,
                                  migration_id,
                                  {'status': 'post-migrating'})
 
-        self._instance_update(context, instance_uuid,
+        self._instance_update(context, instance['uuid'],
                               task_state=task_states.RESIZE_MIGRATED)
 
-        self.compute_rpcapi.finish_resize(context, instance_ref, migration_id,
+        self.compute_rpcapi.finish_resize(context, instance, migration_id,
                 image, disk_info, migration_ref['dest_compute'])
 
-        self._notify_about_instance_usage(context, instance_ref, "resize.end",
+        self._notify_about_instance_usage(context, instance, "resize.end",
                                           network_info=network_info)
 
     def _finish_resize(self, context, instance, migration_ref, disk_info,
@@ -1676,7 +1680,7 @@ class ComputeManager(manager.SchedulerDependentManager):
                                                   network_id)
 
         network_info = self._inject_network_info(context, instance=instance)
-        self.reset_network(context, instance['uuid'])
+        self.reset_network(context, instance)
 
         self._notify_about_instance_usage(
             context, instance, "create_ip.end", network_info=network_info)
@@ -1701,7 +1705,7 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         network_info = self._inject_network_info(context,
                                                  instance=instance)
-        self.reset_network(context, instance['uuid'])
+        self.reset_network(context, instance)
 
         self._notify_about_instance_usage(
             context, instance, "delete_ip.end", network_info=network_info)
@@ -1802,22 +1806,23 @@ class ComputeManager(manager.SchedulerDependentManager):
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
     @wrap_instance_fault
-    def resume_instance(self, context, instance_uuid):
+    def resume_instance(self, context, instance=None, instance_uuid=None):
         """Resume the given suspended instance."""
         context = context.elevated()
-        instance_ref = self.db.instance_get_by_uuid(context, instance_uuid)
+        if not instance:
+            instance = self.db.instance_get_by_uuid(context, instance_uuid)
 
-        LOG.audit(_('Resuming'), context=context, instance=instance_ref)
-        self.driver.resume(instance_ref)
+        LOG.audit(_('Resuming'), context=context, instance=instance)
+        self.driver.resume(instance)
 
-        current_power_state = self._get_power_state(context, instance_ref)
+        current_power_state = self._get_power_state(context, instance)
         self._instance_update(context,
-                              instance_ref['uuid'],
+                              instance['uuid'],
                               power_state=current_power_state,
                               vm_state=vm_states.ACTIVE,
                               task_state=None)
 
-        self._notify_about_instance_usage(context, instance_ref, 'resume')
+        self._notify_about_instance_usage(context, instance, 'resume')
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @wrap_instance_fault
@@ -1860,9 +1865,10 @@ class ComputeManager(manager.SchedulerDependentManager):
 
     @checks_instance_lock
     @wrap_instance_fault
-    def reset_network(self, context, instance_uuid):
+    def reset_network(self, context, instance=None, instance_uuid=None):
         """Reset networking on the given instance."""
-        instance = self.db.instance_get_by_uuid(context, instance_uuid)
+        if not instance:
+            instance = self.db.instance_get_by_uuid(context, instance_uuid)
         LOG.debug(_('Reset network'), context=context, instance=instance)
         self.driver.reset_network(instance)
 
diff --git a/nova/compute/rpcapi.py b/nova/compute/rpcapi.py
index d79cb0bba..107bf4d8d 100644
--- a/nova/compute/rpcapi.py
+++ b/nova/compute/rpcapi.py
@@ -98,6 +98,10 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
                remove_volume_connection()
         1.27 - Remove instance_uuid, add instance argument to
                rescue_instance()
+        1.28 - Remove instance_uuid, add instance argument to reset_network()
+        1.29 - Remove instance_uuid, add instance argument to resize_instance()
+        1.30 - Remove instance_uuid, add instance argument to resume_instance()
+        1.31 - Remove instance_uuid, add instance argument to revert_resize()
     '''
 
     BASE_RPC_API_VERSION = '1.0'
@@ -354,25 +358,32 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
                 version='1.27')
 
     def reset_network(self, ctxt, instance):
+        instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('reset_network',
-                instance_uuid=instance['uuid']),
-                topic=_compute_topic(self.topic, ctxt, None, instance))
+                instance=instance_p),
+                topic=_compute_topic(self.topic, ctxt, None, instance),
+                version='1.28')
 
     def resize_instance(self, ctxt, instance, migration_id, image):
         topic = _compute_topic(self.topic, ctxt, None, instance)
+        instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('resize_instance',
-                instance_uuid=instance['uuid'], migration_id=migration_id,
-                image=image), topic)
+                instance=instance_p, migration_id=migration_id,
+                image=image), topic, version='1.29')
 
     def resume_instance(self, ctxt, instance):
+        instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('resume_instance',
-                instance_uuid=instance['uuid']),
-                topic=_compute_topic(self.topic, ctxt, None, instance))
+                instance=instance_p),
+                topic=_compute_topic(self.topic, ctxt, None, instance),
+                version='1.30')
 
     def revert_resize(self, ctxt, instance, migration_id, host):
+        instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('revert_resize',
-                instance_uuid=instance['uuid'], migration_id=migration_id),
-                topic=_compute_topic(self.topic, ctxt, host, instance))
+                instance=instance_p, migration_id=migration_id),
+                topic=_compute_topic(self.topic, ctxt, host, instance),
+                version='1.31')
 
     def rollback_live_migration_at_destination(self, ctxt, instance, host):
         self.cast(ctxt, self.make_msg('rollback_live_migration_at_destination',
diff --git a/nova/tests/compute/test_compute.py b/nova/tests/compute/test_compute.py
index de02a9d85..36d001966 100644
--- a/nova/tests/compute/test_compute.py
+++ b/nova/tests/compute/test_compute.py
@@ -499,12 +499,11 @@ class ComputeTestCase(BaseTestCase):
 
     def test_suspend(self):
         """ensure instance can be suspended and resumed"""
-        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.suspend_instance(self.context,
-                instance=jsonutils.to_primitive(instance))
-        self.compute.resume_instance(self.context, instance_uuid)
+        self.compute.suspend_instance(self.context, instance=instance)
+        self.compute.resume_instance(self.context, instance=instance)
         self.compute.terminate_instance(self.context, instance_uuid)
 
     def test_suspend_error(self):
@@ -707,19 +706,24 @@ class ComputeTestCase(BaseTestCase):
 
     def test_reset_network(self):
         """Ensure we can reset networking on an instance"""
-        called = {'reset': False}
+        called = {'count': 0}
 
         def fake_driver_reset_network(self, instance):
-            called['reset'] = True
+            called['count'] += 1
 
         self.stubs.Set(nova.virt.fake.FakeDriver, 'reset_network',
                        fake_driver_reset_network)
 
-        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.reset_network(self.context, instance_uuid)
-        self.assertTrue(called['reset'])
+
+        # Make sure it works with both an instance and instance_uuid
+        self.compute.reset_network(self.context, instance=instance)
+        self.compute.reset_network(self.context, instance_uuid=instance_uuid)
+
+        self.assertEqual(called['count'], 2)
+
         self.compute.terminate_instance(self.context, instance_uuid)
 
     def test_agent_update(self):
@@ -1201,8 +1205,8 @@ class ComputeTestCase(BaseTestCase):
         migration_ref = db.migration_get_by_instance_and_status(context,
                                                 instance['uuid'],
                                                 'pre-migrating')
-        self.compute.resize_instance(context, instance['uuid'],
-                                     migration_ref['id'], {})
+        self.compute.resize_instance(context, migration_ref['id'], {},
+                                     instance=instance)
         timeutils.set_time_override(cur_time)
         test_notifier.NOTIFICATIONS = []
 
@@ -1299,7 +1303,7 @@ class ComputeTestCase(BaseTestCase):
         self.stubs.Set(self.compute.driver, 'migrate_disk_and_power_off',
                        throw_up)
 
-        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'])
@@ -1311,7 +1315,7 @@ class ComputeTestCase(BaseTestCase):
 
         #verify
         self.assertRaises(test.TestingException, self.compute.resize_instance,
-                          context, instance['uuid'], migration_ref['id'], {})
+                          context, migration_ref['id'], {}, instance=instance)
         instance = db.instance_get_by_uuid(context, instance['uuid'])
         self.assertEqual(instance['vm_state'], vm_states.ERROR)
 
@@ -1319,7 +1323,7 @@ class ComputeTestCase(BaseTestCase):
 
     def test_resize_instance(self):
         """Ensure instance can be migrated/resized"""
-        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'])
@@ -1329,8 +1333,8 @@ class ComputeTestCase(BaseTestCase):
                                  filter_properties={})
         migration_ref = db.migration_get_by_instance_and_status(context,
                 instance['uuid'], 'pre-migrating')
-        self.compute.resize_instance(context, instance['uuid'],
-                migration_ref['id'], {})
+        self.compute.resize_instance(context, migration_ref['id'], {},
+                                     instance=instance)
         self.compute.terminate_instance(context, instance['uuid'])
 
     def test_finish_revert_resize(self):
@@ -1363,8 +1367,8 @@ class ComputeTestCase(BaseTestCase):
         migration_ref = db.migration_get_by_instance_and_status(context,
                 inst_ref['uuid'], 'pre-migrating')
 
-        self.compute.resize_instance(context, inst_ref['uuid'],
-                migration_ref['id'], {})
+        self.compute.resize_instance(context, migration_ref['id'], {},
+                instance=jsonutils.to_primitive(inst_ref))
         self.compute.finish_resize(context,
                     migration_id=int(migration_ref['id']), disk_info={},
                     image={}, instance=jsonutils.to_primitive(inst_ref))
@@ -1376,11 +1380,11 @@ class ComputeTestCase(BaseTestCase):
         self.assertEqual(instance_type_ref['flavorid'], '3')
 
         # Finally, revert and confirm the old flavor has been applied
-        self.compute.revert_resize(context, inst_ref['uuid'],
-                migration_ref['id'])
+        rpcinst = jsonutils.to_primitive(inst_ref)
+        self.compute.revert_resize(context,
+                migration_id=migration_ref['id'], instance=rpcinst)
         self.compute.finish_revert_resize(context,
-                migration_id=migration_ref['id'],
-                instance=jsonutils.to_primitive(inst_ref))
+                migration_id=migration_ref['id'], instance=rpcinst)
 
         instance = db.instance_get_by_uuid(context, instance['uuid'])
         self.assertEqual(instance['vm_state'], vm_states.ACTIVE)
@@ -1416,7 +1420,7 @@ class ComputeTestCase(BaseTestCase):
                 'migrate_disk_and_power_off',
                 raise_migration_failure)
 
-        inst_ref = self._create_fake_instance()
+        inst_ref = jsonutils.to_primitive(self._create_fake_instance())
         context = self.context.elevated()
 
         self.compute.run_instance(self.context, inst_ref['uuid'])
@@ -1426,7 +1430,7 @@ class ComputeTestCase(BaseTestCase):
         migration_ref = db.migration_get_by_instance_and_status(context,
                 inst_ref['uuid'], 'pre-migrating')
         self.assertRaises(test.TestingException, self.compute.resize_instance,
-                          context, inst_ref['uuid'], migration_ref['id'], {})
+                          context, migration_ref['id'], {}, instance=inst_ref)
         inst_ref = db.instance_get_by_uuid(context, inst_ref['uuid'])
         self.assertEqual(inst_ref['vm_state'], vm_states.ERROR)
         self.compute.terminate_instance(context, inst_ref['uuid'])
diff --git a/nova/tests/compute/test_rpcapi.py b/nova/tests/compute/test_rpcapi.py
index 27d379eed..7a1195fe0 100644
--- a/nova/tests/compute/test_rpcapi.py
+++ b/nova/tests/compute/test_rpcapi.py
@@ -58,8 +58,10 @@ class ComputeRpcAPITestCase(test.TestCase):
             'post_live_migration_at_destination', 'power_off_instance',
             'power_on_instance', 'pre_live_migration', 'reboot_instance',
             'rebuild_instance', 'remove_fixed_ip_from_instance',
-            'remove_volume_connection', 'rescue_instance', 'start_instance',
-            'stop_instance', 'suspend_instance', 'unpause_instance'
+            'remove_volume_connection', 'rescue_instance', 'reset_network',
+            'resize_instance', 'resume_instance', 'revert_resize',
+            'start_instance', 'stop_instance', 'suspend_instance',
+            'unpause_instance'
         ]
 
         if 'rpcapi_class' in kwargs:
@@ -271,19 +273,21 @@ class ComputeRpcAPITestCase(test.TestCase):
 
     def test_reset_network(self):
         self._test_compute_api('reset_network', 'cast',
-                instance=self.fake_instance)
+                instance=self.fake_instance, version='1.28')
 
     def test_resize_instance(self):
         self._test_compute_api('resize_instance', 'cast',
-                instance=self.fake_instance, migration_id='id', image='image')
+                instance=self.fake_instance, migration_id='id', image='image',
+                version='1.29')
 
     def test_resume_instance(self):
         self._test_compute_api('resume_instance', 'cast',
-                instance=self.fake_instance)
+                instance=self.fake_instance, version='1.30')
 
     def test_revert_resize(self):
         self._test_compute_api('revert_resize', 'cast',
-                instance=self.fake_instance, migration_id='id', host='host')
+                instance=self.fake_instance, migration_id='id', host='host',
+                version='1.31')
 
     def test_rollback_live_migration_at_destination(self):
         self._test_compute_api('rollback_live_migration_at_destination',