Merge "Add version 2.0 of compute RPC API"

6 files changed, 520 insertions, 170 deletions

diff --git a/nova/compute/api.py b/nova/compute/api.py
index dcc6a7f06..c39e588f3 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -101,12 +101,6 @@ def check_instance_lock(function):
     def inner(self, context, instance, *args, **kwargs):
         if instance['locked'] and not context.is_admin:
             raise exception.InstanceIsLocked(instance_uuid=instance['uuid'])
-        # NOTE(danms): at this point, we have verified that either
-        # the instance is not locked, or the user is sufficiently endowed
-        # that it doesn't matter. While the following statement may be
-        # interpreted as the "the instance is not locked", it actually
-        # refers to the whole condition.
-        context.instance_lock_checked = True
         return function(self, context, instance, *args, **kwargs)
     return inner
 
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index cf3c6feec..0c2cd0a1c 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -68,6 +68,7 @@ from nova.openstack.common import log as logging
 from nova.openstack.common.notifier import api as notifier
 from nova.openstack.common import rpc
 from nova.openstack.common.rpc import common as rpc_common
+from nova.openstack.common.rpc import dispatcher as rpc_dispatcher
 from nova.openstack.common import timeutils
 from nova import quota
 from nova.scheduler import rpcapi as scheduler_rpcapi
@@ -282,6 +283,15 @@ class ComputeManager(manager.SchedulerDependentManager):
         self.resource_tracker = resource_tracker.ResourceTracker(self.host,
                 self.driver)
 
+    def create_rpc_dispatcher(self):
+        """Get the rpc dispatcher for this manager.
+
+        Return a dispatcher which can call out to either ComputeManager
+        or _V2ComputeManagerProxy depending on the RPC API version.
+        """
+        return rpc_dispatcher.RpcDispatcher([self,
+                                             _V2ComputeManagerProxy(self)])
+
     def _instance_update(self, context, instance_uuid, **kwargs):
         """Update an instance in the database using kwargs as value."""
 
@@ -3069,3 +3079,406 @@ class ComputeManager(manager.SchedulerDependentManager):
             self.driver.manage_image_cache(context)
         except NotImplementedError:
             pass
+
+
+def instance_lock_checked(function):
+    """Set instance_lock_checked in context.
+
+    Version 2.0 clients are required to do the lock checking on the client
+    side. This decorator sets the instance_lock_checked property on the
+    request context so that @checks_instance_lock does the right thing with
+    such clients
+    """
+
+    @functools.wraps(function)
+    def decorated_function(self, context, *args, **kwargs):
+        context.instance_lock_checked = True
+        return function(self, context, *args, **kwargs)
+
+    return decorated_function
+
+
+class _V2ComputeManagerProxy(object):
+
+    RPC_API_VERSION = '2.0'
+
+    # Notes:
+    # - can remove checks_instance_lock()
+    # - lock/unlock_instance() removed
+    # - get_instance_disk_info() removed
+    # - compare_cpu() removed
+    # - create/check/cleanup_shared_storage_test_file() removed
+    # - make rollback_live_migration() private
+
+    def __init__(self, manager):
+        self.manager = manager
+
+    # remove kwargs
+    def add_aggregate_host(self, context, aggregate_id, host):
+        return self.manager.add_aggregate_host(context,
+                                               aggregate_id=aggregate_id,
+                                               host=host)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def add_fixed_ip_to_instance(self, context, network_id, instance):
+        return self.manager.add_fixed_ip_to_instance(context,
+                                                     network_id=network_id,
+                                                     instance=instance,
+                                                     instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def attach_volume(self, context, volume_id, mountpoint, instance):
+        return self.manager.attach_volume(context,
+                                          volume_id=volume_id,
+                                          mountpoint=mountpoint,
+                                          instance=instance,
+                                          instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def change_instance_metadata(self, context, diff, instance):
+        return self.manager.change_instance_metadata(context,
+                                                     diff=diff,
+                                                     instance=instance,
+                                                     instance_uuid=None)
+
+    # require instance, remove instance_id
+    def check_can_live_migrate_destination(self, ctxt, instance,
+                                           block_migration=False,
+                                           disk_over_commit=False):
+        return self.manager.check_can_live_migrate_destination(
+            ctxt, block_migration=block_migration,
+            disk_over_commit=disk_over_commit,
+            instance=instance, instance_id=None)
+
+    # require instance, remove instance_id
+    def check_can_live_migrate_source(self, ctxt, instance, dest_check_data):
+        return self.manager.check_can_live_migrate_source(
+            ctxt, dest_check_data=dest_check_data,
+            instance=instance, instance_id=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def confirm_resize(self, context, migration_id,
+                       instance, reservations=None):
+        return self.manager.confirm_resize(context,
+                                           migration_id=migration_id,
+                                           instance=instance,
+                                           instance_uuid=None,
+                                           reservations=reservations)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def detach_volume(self, context, volume_id, instance):
+        return self.manager.detach_volume(context,
+                                          volume_id=volume_id,
+                                          instance=instance,
+                                          instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def finish_resize(self, context, migration_id, disk_info, image,
+                      instance, reservations=None):
+        return self.manager.finish_resize(context,
+                                          migration_id=migration_id,
+                                          disk_info=disk_info,
+                                          image=image,
+                                          instance=instance,
+                                          instance_uuid=None,
+                                          reservations=reservations)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def finish_revert_resize(self, context, migration_id,
+                             instance, reservations=None):
+        return self.manager.finish_revert_resize(context,
+                                                 migration_id=migration_id,
+                                                 instance=instance,
+                                                 instance_uuid=None,
+                                                 reservations=reservations)
+
+    # require instance, remove instance_uuid
+    def get_console_output(self, context, instance, tail_length=None):
+        return self.manager.get_console_output(context,
+                                               instance=instance,
+                                               instance_uuid=None,
+                                               tail_length=tail_length)
+
+    def get_console_pool_info(self, context, console_type):
+        return self.manager.get_console_pool_info(context,
+                                                  console_type=console_type)
+
+    # remove kwargs
+    def get_console_topic(self, context):
+        return self.manager.get_console_topic(context)
+
+    # require instance, remove instance_uuid
+    def get_diagnostics(self, context, instance):
+        return self.manager.get_diagnostics(context,
+                                            instance=instance,
+                                            instance_uuid=None)
+
+    def get_host_uptime(self, context, host):
+        return self.manager.get_host_uptime(context, host=host)
+
+    # require instance, remove instance_uuid
+    def get_vnc_console(self, context, console_type, instance):
+        return self.manager.get_vnc_console(context,
+                                            console_type=console_type,
+                                            instance=instance,
+                                            instance_uuid=None)
+
+    def host_maintenance_mode(self, context, host, mode):
+        return self.manager.host_maintenance_mode(context,
+                                                  host=host,
+                                                  mode=mode)
+
+    def host_power_action(self, context, host=None, action=None):
+        return self.manager.host_power_action(context,
+                                              host=host,
+                                              action=action)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def inject_file(self, context, path, file_contents, instance):
+        return self.manager.inject_file(context,
+                                        path=path,
+                                        file_contents=file_contents,
+                                        instance=instance,
+                                        instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def inject_network_info(self, context, instance):
+        return self.manager.inject_network_info(context, instance=instance,
+                                                instance_uuid=None)
+
+    # require instance, remove instance_id
+    def live_migration(self, context, dest, instance,
+                       block_migration=False, migrate_data=None):
+        return self.manager.live_migration(context, dest=dest,
+                                           block_migration=block_migration,
+                                           instance=instance, instance_id=None,
+                                           migrate_data=migrate_data)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def pause_instance(self, context, instance):
+        return self.manager.pause_instance(context, instance=instance,
+                                           instance_uuid=None)
+
+    # require instance, remove instance_id
+    def post_live_migration_at_destination(self, context, instance,
+                                           block_migration=False):
+        return self.manager.post_live_migration_at_destination(
+            context, instance=instance, instance_id=None,
+            block_migration=block_migration)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def power_off_instance(self, context, instance,
+                           final_state=vm_states.SOFT_DELETED):
+        return self.manager.power_off_instance(
+            context, instance=instance, instance_uuid=None,
+            final_state=final_state)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def power_on_instance(self, context, instance):
+        return self.manager.power_on_instance(context, instance=instance,
+                                              instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    def pre_live_migration(self, context, instance,
+                           block_migration=False, disk=None):
+        return self.manager.pre_live_migration(context, instance=instance,
+                                               instance_id=None,
+                                               block_migration=block_migration,
+                                               disk=disk)
+
+    # require instance, remove instance_uuid
+    # require instance_type, remove instance_type_id
+    @instance_lock_checked
+    def prep_resize(self, context, image, instance, instance_type,
+                    reservations=None):
+        return self.manager.prep_resize(context, image=image,
+                                        instance=instance,
+                                        instance_type=instance_type,
+                                        instance_uuid=None,
+                                        instance_type_id=None,
+                                        reservations=reservations)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def reboot_instance(self, context, instance, reboot_type="SOFT"):
+        return self.manager.reboot_instance(context, instance=instance,
+                                            instance_uuid=None,
+                                            reboot_type=reboot_type)
+
+    # require instance, remove instance_uuid
+    # remove kwargs
+    # add new_pass and injected_files
+    @instance_lock_checked
+    def rebuild_instance(self, context, orig_image_ref, image_ref,
+                         instance, new_pass, injected_files):
+        return self.manager.rebuild_instance(context,
+                                             orig_image_ref=orig_image_ref,
+                                             image_ref=image_ref,
+                                             instance=instance,
+                                             instance_uuid=None,
+                                             new_pass=new_pass,
+                                             injected_files=injected_files)
+
+    # require instance, remove instance_uuid
+    def refresh_instance_security_rules(self, context, instance):
+        return self.manager.refresh_instance_security_rules(context,
+                                                            instance=instance)
+
+    # remove kwargs
+    def refresh_provider_fw_rules(self, context):
+        return self.manager.refresh_provider_fw_rules(context)
+
+    # remove kwargs
+    def refresh_security_group_members(self, context, security_group_id):
+        return self.manager.refresh_security_group_members(
+            context, security_group_id=security_group_id)
+
+    # remove kwargs
+    def refresh_security_group_rules(self, context, security_group_id):
+        return self.manager.refresh_security_group_rules(
+            context, security_group_id=security_group_id)
+
+    # remove kwargs
+    def remove_aggregate_host(self, context, aggregate_id, host):
+        return self.manager.remove_aggregate_host(
+            context, aggregate_id=aggregate_id, host=host)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def remove_fixed_ip_from_instance(self, context, address, instance):
+        return self.manager.remove_fixed_ip_from_instance(
+            context, address=address, instance=instance, instance_uuid=None)
+
+    # require instance, remove instance_id
+    def remove_volume_connection(self, context, volume_id, instance):
+        return self.manager.remove_volume_connection(
+            context, volume_id=volume_id, instance=instance, instance_id=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def rescue_instance(self, context, instance, rescue_password=None):
+        return self.manager.rescue_instance(
+            context, instance=instance, instance_uuid=None,
+            rescue_password=rescue_password)
+
+    def reserve_block_device_name(self, context, instance, device):
+        return self.manager.reserve_block_device_name(
+            context, instance=instance, device=device)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def reset_network(self, context, instance):
+        return self.manager.reset_network(
+            context, instance=instance, instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def resize_instance(self, context, migration_id, image,
+                        instance, reservations=None):
+        return self.manager.resize_instance(
+            context, migration_id=migration_id, image=image,
+            instance=instance, instance_uuid=None,
+            reservations=reservations)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def resume_instance(self, context, instance):
+        return self.manager.resume_instance(context,
+                                            instance=instance,
+                                            instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def revert_resize(self, context,
+                      migration_id, instance, reservations=None):
+        return self.manager.revert_resize(context,
+                                          migration_id=migration_id,
+                                          instance=instance,
+                                          instance_uuid=None,
+                                          reservations=reservations)
+
+    # require instance, remove instance_id
+    def rollback_live_migration_at_destination(self, context, instance):
+        return self.manager.rollback_live_migration_at_destination(
+            context, instance=instance, instance_id=None)
+
+    # require instance, remove instance_uuid
+    def run_instance(self, context, instance, request_spec=None,
+                     filter_properties=None, requested_networks=None,
+                     injected_files=None, admin_password=None,
+                     is_first_time=False):
+        return self.manager.run_instance(
+            context, instance=instance, 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,
+            instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def set_admin_password(self, context, instance, new_pass=None):
+        return self.manager.set_admin_password(
+            context, instance=instance, instance_uuid=None, new_pass=new_pass)
+
+    def set_host_enabled(self, context, host=None, enabled=None):
+        return self.manager.set_host_enabled(
+            context, host=host, enabled=enabled)
+
+    # require instance, remove instance_uuid
+    def snapshot_instance(self, context, image_id, instance,
+                          image_type='snapshot', backup_type=None,
+                          rotation=None):
+        return self.manager.snapshot_instance(
+            context, image_id=image_id, instance=instance,
+            image_type=image_type, backup_type=backup_type,
+            rotation=rotation, instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def start_instance(self, context, instance):
+        return self.manager.start_instance(
+            context, instance=instance, instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def stop_instance(self, context, instance):
+        return self.manager.stop_instance(
+            context, instance=instance, instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def suspend_instance(self, context, instance):
+        return self.manager.suspend_instance(
+            context, instance=instance, instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def terminate_instance(self, context, instance):
+        return self.manager.terminate_instance(
+            context, instance=instance, instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def unpause_instance(self, context, instance):
+        return self.manager.unpause_instance(
+            context, instance=instance, instance_uuid=None)
+
+    # require instance, remove instance_uuid
+    @instance_lock_checked
+    def unrescue_instance(self, context, instance):
+        return self.manager.unrescue_instance(
+            context, instance=instance, instance_uuid=None)
diff --git a/nova/compute/rpcapi.py b/nova/compute/rpcapi.py
index 584335754..328351c35 100644
--- a/nova/compute/rpcapi.py
+++ b/nova/compute/rpcapi.py
@@ -125,9 +125,11 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
                finish_revert_resize()
         1.43 - Add migrate_data to live_migration()
         1.44 - Adds reserve_block_device_name()
+
+        2.0 - Remove 1.x backwards compat
     '''
 
-    BASE_RPC_API_VERSION = '1.0'
+    BASE_RPC_API_VERSION = '2.0'
 
     def __init__(self):
         super(ComputeAPI, self).__init__(
@@ -151,23 +153,20 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('add_fixed_ip_to_instance',
                 instance=instance_p, network_id=network_id),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.8')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def attach_volume(self, ctxt, instance, volume_id, mountpoint):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('attach_volume',
                 instance=instance_p, volume_id=volume_id,
                 mountpoint=mountpoint),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.9')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def change_instance_metadata(self, ctxt, instance, diff):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('change_instance_metadata',
                   instance=instance_p, diff=diff),
-                  topic=_compute_topic(self.topic, ctxt, None, instance),
-                  version='1.36')
+                  topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def check_can_live_migrate_destination(self, ctxt, instance, destination,
                                            block_migration, disk_over_commit):
@@ -178,16 +177,14 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
                                        block_migration=block_migration,
                                        disk_over_commit=disk_over_commit),
                          topic=_compute_topic(self.topic,
-                                              ctxt, destination, None),
-                         version='1.10')
+                                              ctxt, destination, None))
 
     def check_can_live_migrate_source(self, ctxt, instance, dest_check_data):
         instance_p = jsonutils.to_primitive(instance)
         self.call(ctxt, self.make_msg('check_can_live_migrate_source',
                            instance=instance_p,
                            dest_check_data=dest_check_data),
-                  topic=_compute_topic(self.topic, ctxt, None, instance),
-                  version='1.11')
+                  topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def confirm_resize(self, ctxt, instance, migration_id, host,
             reservations=None, cast=True):
@@ -196,15 +193,13 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         return rpc_method(ctxt, self.make_msg('confirm_resize',
                 instance=instance_p, migration_id=migration_id,
                 reservations=reservations),
-                topic=_compute_topic(self.topic, ctxt, host, instance),
-                version='1.42')
+                topic=_compute_topic(self.topic, ctxt, host, instance))
 
     def detach_volume(self, ctxt, instance, volume_id):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('detach_volume',
                 instance=instance_p, volume_id=volume_id),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.13')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def finish_resize(self, ctxt, instance, migration_id, image, disk_info,
             host, reservations=None):
@@ -212,8 +207,7 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         self.cast(ctxt, self.make_msg('finish_resize',
                 instance=instance_p, migration_id=migration_id,
                 image=image, disk_info=disk_info, reservations=reservations),
-                topic=_compute_topic(self.topic, ctxt, host, None),
-                version='1.42')
+                topic=_compute_topic(self.topic, ctxt, host, None))
 
     def finish_revert_resize(self, ctxt, instance, migration_id, host,
                              reservations=None):
@@ -221,15 +215,13 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         self.cast(ctxt, self.make_msg('finish_revert_resize',
                 instance=instance_p, migration_id=migration_id,
                 reservations=reservations),
-                topic=_compute_topic(self.topic, ctxt, host, None),
-                version='1.42')
+                topic=_compute_topic(self.topic, ctxt, host, None))
 
     def get_console_output(self, ctxt, instance, tail_length):
         instance_p = jsonutils.to_primitive(instance)
         return self.call(ctxt, self.make_msg('get_console_output',
                 instance=instance_p, tail_length=tail_length),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.7')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def get_console_pool_info(self, ctxt, console_type, host):
         return self.call(ctxt, self.make_msg('get_console_pool_info',
@@ -244,15 +236,13 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         instance_p = jsonutils.to_primitive(instance)
         return self.call(ctxt, self.make_msg('get_diagnostics',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.16')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def get_vnc_console(self, ctxt, instance, console_type):
         instance_p = jsonutils.to_primitive(instance)
         return self.call(ctxt, self.make_msg('get_vnc_console',
                 instance=instance_p, console_type=console_type),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.17')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def host_maintenance_mode(self, ctxt, host_param, mode, host):
         '''Set host maintenance mode
@@ -277,15 +267,13 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         self.cast(ctxt, self.make_msg('inject_file',
                 instance=instance_p, path=path,
                 file_contents=file_contents),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.18')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def inject_network_info(self, ctxt, instance):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('inject_network_info',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.19')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def live_migration(self, ctxt, instance, dest, block_migration, host,
                        migrate_data=None):
@@ -293,15 +281,13 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         self.cast(ctxt, self.make_msg('live_migration', instance=instance_p,
                 dest=dest, block_migration=block_migration,
                 migrate_data=migrate_data),
-                topic=_compute_topic(self.topic, ctxt, host, None),
-                version='1.43')
+                topic=_compute_topic(self.topic, ctxt, host, None))
 
     def pause_instance(self, ctxt, instance):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('pause_instance',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.5')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def post_live_migration_at_destination(self, ctxt, instance,
             block_migration, host):
@@ -309,30 +295,26 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         return self.call(ctxt,
                 self.make_msg('post_live_migration_at_destination',
                 instance=instance_p, block_migration=block_migration),
-                _compute_topic(self.topic, ctxt, host, None),
-                version='1.20')
+                _compute_topic(self.topic, ctxt, host, None))
 
     def power_off_instance(self, ctxt, instance):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('power_off_instance',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.21')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def power_on_instance(self, ctxt, instance):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('power_on_instance',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.22')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def pre_live_migration(self, ctxt, instance, block_migration, disk,
             host):
         instance_p = jsonutils.to_primitive(instance)
         return self.call(ctxt, self.make_msg('pre_live_migration',
                 instance=instance_p, block_migration=block_migration,
-                disk=disk), _compute_topic(self.topic, ctxt, host, None),
-                version='1.23')
+                disk=disk), _compute_topic(self.topic, ctxt, host, None))
 
     def prep_resize(self, ctxt, image, instance, instance_type, host,
                     reservations=None):
@@ -341,15 +323,13 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         self.cast(ctxt, self.make_msg('prep_resize',
                 instance=instance_p, instance_type=instance_type_p,
                 image=image, reservations=reservations),
-                _compute_topic(self.topic, ctxt, host, None),
-                version='1.42')
+                _compute_topic(self.topic, ctxt, host, None))
 
     def reboot_instance(self, ctxt, instance, reboot_type):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('reboot_instance',
                 instance=instance_p, reboot_type=reboot_type),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.4')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def rebuild_instance(self, ctxt, instance, new_pass, injected_files,
             image_ref, orig_image_ref):
@@ -358,24 +338,12 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
                 instance=instance_p, new_pass=new_pass,
                 injected_files=injected_files, image_ref=image_ref,
                 orig_image_ref=orig_image_ref),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.24')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def refresh_provider_fw_rules(self, ctxt, host):
         self.cast(ctxt, self.make_msg('refresh_provider_fw_rules'),
                 _compute_topic(self.topic, ctxt, host, None))
 
-    def refresh_security_group_rules(self, ctxt, security_group_id, host):
-        self.cast(ctxt, self.make_msg('refresh_security_group_rules',
-                security_group_id=security_group_id),
-                topic=_compute_topic(self.topic, ctxt, host, None))
-
-    def refresh_security_group_members(self, ctxt, security_group_id,
-            host):
-        self.cast(ctxt, self.make_msg('refresh_security_group_members',
-                security_group_id=security_group_id),
-                topic=_compute_topic(self.topic, ctxt, host, None))
-
     def remove_aggregate_host(self, ctxt, aggregate_id, host_param, host):
         '''Remove aggregate host.
 
@@ -393,30 +361,26 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('remove_fixed_ip_from_instance',
                 instance=instance_p, address=address),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.25')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def remove_volume_connection(self, ctxt, instance, volume_id, host):
         instance_p = jsonutils.to_primitive(instance)
         return self.call(ctxt, self.make_msg('remove_volume_connection',
                 instance=instance_p, volume_id=volume_id),
-                topic=_compute_topic(self.topic, ctxt, host, None),
-                version='1.26')
+                topic=_compute_topic(self.topic, ctxt, host, None))
 
     def rescue_instance(self, ctxt, instance, rescue_password):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('rescue_instance',
                 instance=instance_p,
                 rescue_password=rescue_password),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.27')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def reset_network(self, ctxt, instance):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('reset_network',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.28')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def resize_instance(self, ctxt, instance, migration_id, image,
                         reservations=None):
@@ -424,15 +388,13 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('resize_instance',
                 instance=instance_p, migration_id=migration_id,
-                image=image, reservations=reservations), topic,
-                version='1.42')
+                image=image, reservations=reservations), topic)
 
     def resume_instance(self, ctxt, instance):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('resume_instance',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.30')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def revert_resize(self, ctxt, instance, migration_id, host,
                       reservations=None):
@@ -440,15 +402,13 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         self.cast(ctxt, self.make_msg('revert_resize',
                 instance=instance_p, migration_id=migration_id,
                 reservations=reservations),
-                topic=_compute_topic(self.topic, ctxt, host, instance),
-                version='1.42')
+                topic=_compute_topic(self.topic, ctxt, host, instance))
 
     def rollback_live_migration_at_destination(self, ctxt, instance, host):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('rollback_live_migration_at_destination',
             instance=instance_p),
-            topic=_compute_topic(self.topic, ctxt, host, None),
-            version='1.32')
+            topic=_compute_topic(self.topic, ctxt, host, None))
 
     def run_instance(self, ctxt, instance, host, request_spec,
                      filter_properties, requested_networks,
@@ -460,15 +420,13 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
                 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')
+                topic=_compute_topic(self.topic, ctxt, host, None))
 
     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',
                 instance=instance_p, new_pass=new_pass),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.33')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def set_host_enabled(self, ctxt, enabled, host):
         topic = _compute_topic(self.topic, ctxt, host, None)
@@ -477,15 +435,13 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
 
     def get_host_uptime(self, ctxt, host):
         topic = _compute_topic(self.topic, ctxt, host, None)
-        return self.call(ctxt, self.make_msg('get_host_uptime'), topic,
-                version='1.1')
+        return self.call(ctxt, self.make_msg('get_host_uptime'), topic)
 
     def reserve_block_device_name(self, ctxt, instance, device):
         instance_p = jsonutils.to_primitive(instance)
         return self.call(ctxt, self.make_msg('reserve_block_device_name',
                 instance=instance_p, device=device),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.44')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def snapshot_instance(self, ctxt, instance, image_id, image_type,
             backup_type, rotation):
@@ -494,51 +450,44 @@ class ComputeAPI(nova.openstack.common.rpc.proxy.RpcProxy):
                 instance=instance_p, image_id=image_id,
                 image_type=image_type, backup_type=backup_type,
                 rotation=rotation),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.34')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def start_instance(self, ctxt, instance):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('start_instance',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.22')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def stop_instance(self, ctxt, instance, cast=True):
         rpc_method = self.cast if cast else self.call
         instance_p = jsonutils.to_primitive(instance)
         return rpc_method(ctxt, self.make_msg('stop_instance',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.21')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def suspend_instance(self, ctxt, instance):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('suspend_instance',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.6')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def terminate_instance(self, ctxt, instance):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('terminate_instance',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.37')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def unpause_instance(self, ctxt, instance):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('unpause_instance',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.5')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
     def unrescue_instance(self, ctxt, instance):
         instance_p = jsonutils.to_primitive(instance)
         self.cast(ctxt, self.make_msg('unrescue_instance',
                 instance=instance_p),
-                topic=_compute_topic(self.topic, ctxt, None, instance),
-                version='1.35')
+                topic=_compute_topic(self.topic, ctxt, None, instance))
 
 
 class SecurityGroupAPI(nova.openstack.common.rpc.proxy.RpcProxy):
@@ -548,9 +497,11 @@ class SecurityGroupAPI(nova.openstack.common.rpc.proxy.RpcProxy):
 
         1.0 - Initial version.
         1.41 - Adds refresh_instance_security_rules()
+
+        2.0 - Remove 1.x backwards compat
     '''
 
-    BASE_RPC_API_VERSION = '1.0'
+    BASE_RPC_API_VERSION = '2.0'
 
     def __init__(self):
         super(SecurityGroupAPI, self).__init__(
@@ -573,5 +524,4 @@ class SecurityGroupAPI(nova.openstack.common.rpc.proxy.RpcProxy):
         self.cast(ctxt, self.make_msg('refresh_instance_security_rules',
                 instance=instance_p),
                 topic=_compute_topic(self.topic, ctxt, instance['host'],
-                instance),
-                version='1.41')
+                instance))
diff --git a/nova/tests/compute/test_compute.py b/nova/tests/compute/test_compute.py
index 822c23e03..82e2df95f 100644
--- a/nova/tests/compute/test_compute.py
+++ b/nova/tests/compute/test_compute.py
@@ -1864,11 +1864,12 @@ class ComputeTestCase(BaseTestCase):
                 {"method": "remove_volume_connection",
                  "args": {'instance': rpcinst,
                           'volume_id': volume_id},
-                 "version": "1.26"}, None)
+                 "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION},
+                 None)
         rpc.cast(c, topic,
                 {"method": "rollback_live_migration_at_destination",
                  "args": {'instance': rpcinst},
-                 "version": "1.32"})
+                 "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION})
 
         # start test
         self.mox.ReplayAll()
@@ -1902,7 +1903,7 @@ class ComputeTestCase(BaseTestCase):
                  "args": {'instance': instance,
                           'block_migration': False,
                           'disk': None},
-                 "version": '1.23'},
+                 "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION},
                 None)
 
         # start test
@@ -1944,7 +1945,8 @@ class ComputeTestCase(BaseTestCase):
         rpc.call(c, rpc.queue_get_for(c, FLAGS.compute_topic, dest),
             {"method": "post_live_migration_at_destination",
              "args": {'instance': inst_ref, 'block_migration': False},
-             "version": "1.20"}, None)
+             "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION},
+            None)
         self.mox.StubOutWithMock(self.compute.driver, 'unplug_vifs')
         self.compute.driver.unplug_vifs(inst_ref, [])
         rpc.call(c, 'network', {'method': 'setup_networks_on_host',
@@ -4031,7 +4033,7 @@ class ComputeAPITestCase(BaseTestCase):
         rpc_msg1 = {'method': 'get_vnc_console',
                     'args': {'instance': fake_instance,
                              'console_type': fake_console_type},
-                   'version': '1.17'}
+                   'version': compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION}
         rpc_msg2 = {'method': 'authorize_console',
                     'args': fake_connect_info,
                     'version': '1.0'}
@@ -4067,7 +4069,7 @@ class ComputeAPITestCase(BaseTestCase):
         rpc_msg = {'method': 'get_console_output',
                    'args': {'instance': fake_instance,
                             'tail_length': fake_tail_length},
-                   'version': '1.7'}
+                   'version': compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION}
         rpc.call(self.context, 'compute.%s' % fake_instance['host'],
                 rpc_msg, None).AndReturn(fake_console_output)
 
@@ -4177,7 +4179,7 @@ class ComputeAPITestCase(BaseTestCase):
         rpc.cast(self.context, topic,
                 {"method": "refresh_instance_security_rules",
                  "args": {'instance': jsonutils.to_primitive(instance)},
-                 "version": '1.41'})
+                 "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION})
         self.mox.ReplayAll()
 
         self.security_group_api.trigger_members_refresh(self.context, [1])
@@ -4205,7 +4207,7 @@ class ComputeAPITestCase(BaseTestCase):
         rpc.cast(self.context, topic,
                 {"method": "refresh_instance_security_rules",
                  "args": {'instance': jsonutils.to_primitive(instance)},
-                 "version": '1.41'})
+                 "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION})
         self.mox.ReplayAll()
 
         self.security_group_api.trigger_members_refresh(self.context, [1, 2])
@@ -4245,7 +4247,7 @@ class ComputeAPITestCase(BaseTestCase):
         rpc.cast(self.context, topic,
                 {"method": "refresh_instance_security_rules",
                  "args": {'instance': jsonutils.to_primitive(instance)},
-                 "version": '1.41'})
+                 "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION})
         self.mox.ReplayAll()
 
         self.security_group_api.trigger_rules_refresh(self.context, [1])
@@ -4265,7 +4267,7 @@ class ComputeAPITestCase(BaseTestCase):
         rpc.cast(self.context, topic,
                 {"method": "refresh_instance_security_rules",
                  "args": {'instance': jsonutils.to_primitive(instance)},
-                 "version": '1.41'})
+                 "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION})
         self.mox.ReplayAll()
 
         self.security_group_api.trigger_rules_refresh(self.context, [1, 2])
@@ -4593,7 +4595,7 @@ class ComputeHostAPITestCase(BaseTestCase):
         self.assertEqual(call_info['msg'],
                 {'method': 'get_host_uptime',
                  'args': {},
-                 'version': '1.1'})
+                 'version': compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION})
 
     def test_host_power_action(self):
         ctxt = context.RequestContext('fake', 'fake')
diff --git a/nova/tests/compute/test_rpcapi.py b/nova/tests/compute/test_rpcapi.py
index 38849d3ed..1dde75fbc 100644
--- a/nova/tests/compute/test_rpcapi.py
+++ b/nova/tests/compute/test_rpcapi.py
@@ -103,57 +103,55 @@ class ComputeRpcAPITestCase(test.TestCase):
 
     def test_add_fixed_ip_to_instance(self):
         self._test_compute_api('add_fixed_ip_to_instance', 'cast',
-                instance=self.fake_instance, network_id='id', version='1.8')
+                instance=self.fake_instance, network_id='id')
 
     def test_attach_volume(self):
         self._test_compute_api('attach_volume', 'cast',
-                instance=self.fake_instance, volume_id='id', mountpoint='mp',
-                version='1.9')
+                instance=self.fake_instance, volume_id='id', mountpoint='mp')
 
     def test_change_instance_metadata(self):
         self._test_compute_api('change_instance_metadata', 'cast',
-                instance=self.fake_instance, diff={},
-                version='1.36')
+                instance=self.fake_instance, diff={})
 
     def test_check_can_live_migrate_destination(self):
         self._test_compute_api('check_can_live_migrate_destination', 'call',
-                version='1.10', instance=self.fake_instance,
+                instance=self.fake_instance,
                 destination='dest', block_migration=True,
                 disk_over_commit=True)
 
     def test_check_can_live_migrate_source(self):
         self._test_compute_api('check_can_live_migrate_source', 'call',
-                version='1.11', instance=self.fake_instance,
+                instance=self.fake_instance,
                 dest_check_data={"test": "data"})
 
     def test_confirm_resize_cast(self):
         self._test_compute_api('confirm_resize', 'cast',
                 instance=self.fake_instance, migration_id='id', host='host',
-                reservations=list('fake_res'), version='1.42')
+                reservations=list('fake_res'))
 
     def test_confirm_resize_call(self):
         self._test_compute_api('confirm_resize', 'call',
                 instance=self.fake_instance, migration_id='id', host='host',
-                reservations=list('fake_res'), version='1.42')
+                reservations=list('fake_res'))
 
     def test_detach_volume(self):
         self._test_compute_api('detach_volume', 'cast',
-                instance=self.fake_instance, volume_id='id', version='1.13')
+                instance=self.fake_instance, volume_id='id')
 
     def test_finish_resize(self):
         self._test_compute_api('finish_resize', 'cast',
                 instance=self.fake_instance, migration_id='id',
                 image='image', disk_info='disk_info', host='host',
-                reservations=list('fake_res'), version='1.42')
+                reservations=list('fake_res'))
 
     def test_finish_revert_resize(self):
         self._test_compute_api('finish_revert_resize', 'cast',
                 instance=self.fake_instance, migration_id='id', host='host',
-                reservations=list('fake_res'), version='1.42')
+                reservations=list('fake_res'))
 
     def test_get_console_output(self):
         self._test_compute_api('get_console_output', 'call',
-                instance=self.fake_instance, tail_length='tl', version='1.7')
+                instance=self.fake_instance, tail_length='tl')
 
     def test_get_console_pool_info(self):
         self._test_compute_api('get_console_pool_info', 'call',
@@ -164,12 +162,11 @@ class ComputeRpcAPITestCase(test.TestCase):
 
     def test_get_diagnostics(self):
         self._test_compute_api('get_diagnostics', 'call',
-                instance=self.fake_instance, version='1.16')
+                instance=self.fake_instance)
 
     def test_get_vnc_console(self):
         self._test_compute_api('get_vnc_console', 'call',
-                instance=self.fake_instance, console_type='type',
-                version='1.17')
+                instance=self.fake_instance, console_type='type')
 
     def test_host_maintenance_mode(self):
         self._test_compute_api('host_maintenance_mode', 'call',
@@ -181,60 +178,59 @@ class ComputeRpcAPITestCase(test.TestCase):
 
     def test_inject_file(self):
         self._test_compute_api('inject_file', 'cast',
-                instance=self.fake_instance, path='path', file_contents='fc',
-                version='1.18')
+                instance=self.fake_instance, path='path', file_contents='fc')
 
     def test_inject_network_info(self):
         self._test_compute_api('inject_network_info', 'cast',
-                instance=self.fake_instance, version='1.19')
+                instance=self.fake_instance)
 
     def test_live_migration(self):
         self._test_compute_api('live_migration', 'cast',
                 instance=self.fake_instance, dest='dest',
-                block_migration='blockity_block', host='tsoh', version='1.43',
+                block_migration='blockity_block', host='tsoh',
                 migrate_data={})
 
     def test_post_live_migration_at_destination(self):
         self._test_compute_api('post_live_migration_at_destination', 'call',
                 instance=self.fake_instance, block_migration='block_migration',
-                host='host', version='1.20')
+                host='host')
 
     def test_pause_instance(self):
         self._test_compute_api('pause_instance', 'cast',
-                instance=self.fake_instance, version='1.5')
+                instance=self.fake_instance)
 
     def test_power_off_instance(self):
         self._test_compute_api('power_off_instance', 'cast',
-                instance=self.fake_instance, version='1.21')
+                instance=self.fake_instance)
 
     def test_power_on_instance(self):
         self._test_compute_api('power_on_instance', 'cast',
-                instance=self.fake_instance, version='1.22')
+                instance=self.fake_instance)
 
     def test_pre_live_migration(self):
         self._test_compute_api('pre_live_migration', 'call',
                 instance=self.fake_instance, block_migration='block_migration',
-                disk='disk', host='host', version='1.23')
+                disk='disk', host='host')
 
     def test_prep_resize(self):
         self._test_compute_api('prep_resize', 'cast',
                 instance=self.fake_instance, instance_type='fake_type',
                 image='fake_image', host='host',
-                reservations=list('fake_res'), version='1.42')
+                reservations=list('fake_res'))
 
     def test_reboot_instance(self):
         self._test_compute_api('reboot_instance', 'cast',
-                instance=self.fake_instance, reboot_type='type', version='1.4')
+                instance=self.fake_instance, reboot_type='type')
 
     def test_rebuild_instance(self):
         self._test_compute_api('rebuild_instance', 'cast',
                 instance=self.fake_instance, new_pass='pass',
                 injected_files='files', image_ref='ref',
-                orig_image_ref='orig_ref', version='1.24')
+                orig_image_ref='orig_ref')
 
     def test_reserve_block_device_name(self):
         self._test_compute_api('reserve_block_device_name', 'call',
-                instance=self.fake_instance, device='device', version='1.44')
+                instance=self.fake_instance, device='device')
 
     def refresh_provider_fw_rules(self):
         self._test_compute_api('refresh_provider_fw_rules', 'cast',
@@ -256,90 +252,85 @@ class ComputeRpcAPITestCase(test.TestCase):
 
     def test_remove_fixed_ip_from_instance(self):
         self._test_compute_api('remove_fixed_ip_from_instance', 'cast',
-                instance=self.fake_instance, address='addr', version='1.25')
+                instance=self.fake_instance, address='addr')
 
     def test_remove_volume_connection(self):
         self._test_compute_api('remove_volume_connection', 'call',
-                instance=self.fake_instance, volume_id='id', host='host',
-                version='1.26')
+                instance=self.fake_instance, volume_id='id', host='host')
 
     def test_rescue_instance(self):
         self._test_compute_api('rescue_instance', 'cast',
-                instance=self.fake_instance, rescue_password='pw',
-                version='1.27')
+                instance=self.fake_instance, rescue_password='pw')
 
     def test_reset_network(self):
         self._test_compute_api('reset_network', 'cast',
-                instance=self.fake_instance, version='1.28')
+                instance=self.fake_instance)
 
     def test_resize_instance(self):
         self._test_compute_api('resize_instance', 'cast',
                 instance=self.fake_instance, migration_id='id', image='image',
-                reservations=list('fake_res'), version='1.42')
+                reservations=list('fake_res'))
 
     def test_resume_instance(self):
         self._test_compute_api('resume_instance', 'cast',
-                instance=self.fake_instance, version='1.30')
+                instance=self.fake_instance)
 
     def test_revert_resize(self):
         self._test_compute_api('revert_resize', 'cast',
                 instance=self.fake_instance, migration_id='id', host='host',
-                reservations=list('fake_res'), version='1.42')
+                reservations=list('fake_res'))
 
     def test_rollback_live_migration_at_destination(self):
         self._test_compute_api('rollback_live_migration_at_destination',
-                'cast', instance=self.fake_instance, host='host',
-                version='1.32')
+                'cast', instance=self.fake_instance, host='host')
 
     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')
+                admin_password='pw', is_first_time=True)
 
     def test_set_admin_password(self):
         self._test_compute_api('set_admin_password', 'call',
-                instance=self.fake_instance, new_pass='pw', version='1.33')
+                instance=self.fake_instance, new_pass='pw')
 
     def test_set_host_enabled(self):
         self._test_compute_api('set_host_enabled', 'call',
                 enabled='enabled', host='host')
 
     def test_get_host_uptime(self):
-        self._test_compute_api('get_host_uptime', 'call', host='host',
-                version='1.1')
+        self._test_compute_api('get_host_uptime', 'call', host='host')
 
     def test_snapshot_instance(self):
         self._test_compute_api('snapshot_instance', 'cast',
                 instance=self.fake_instance, image_id='id', image_type='type',
-                backup_type='type', rotation='rotation',
-                version='1.34')
+                backup_type='type', rotation='rotation')
 
     def test_start_instance(self):
         self._test_compute_api('start_instance', 'cast',
-                instance=self.fake_instance, version='1.22')
+                instance=self.fake_instance)
 
     def test_stop_instance_cast(self):
         self._test_compute_api('stop_instance', 'cast',
-                instance=self.fake_instance, version='1.21')
+                instance=self.fake_instance)
 
     def test_stop_instance_call(self):
         self._test_compute_api('stop_instance', 'call',
-                instance=self.fake_instance, version='1.21')
+                instance=self.fake_instance)
 
     def test_suspend_instance(self):
         self._test_compute_api('suspend_instance', 'cast',
-                instance=self.fake_instance, version='1.6')
+                instance=self.fake_instance)
 
     def test_terminate_instance(self):
         self._test_compute_api('terminate_instance', 'cast',
-                instance=self.fake_instance, version='1.37')
+                instance=self.fake_instance)
 
     def test_unpause_instance(self):
         self._test_compute_api('unpause_instance', 'cast',
-                instance=self.fake_instance, version='1.5')
+                instance=self.fake_instance)
 
     def test_unrescue_instance(self):
         self._test_compute_api('unrescue_instance', 'cast',
-                instance=self.fake_instance, version='1.35')
+                instance=self.fake_instance)
diff --git a/nova/tests/scheduler/test_scheduler.py b/nova/tests/scheduler/test_scheduler.py
index 113b16b35..2c00c7983 100644
--- a/nova/tests/scheduler/test_scheduler.py
+++ b/nova/tests/scheduler/test_scheduler.py
@@ -495,7 +495,7 @@ class SchedulerTestCase(test.TestCase):
                     "args": {'instance': instance,
                              'block_migration': block_migration,
                              'disk_over_commit': disk_over_commit},
-                    "version": "1.10"},
+                    "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION},
                  None).AndReturn({})
 
         db.instance_update_and_get_original(self.context, instance_uuid,