Add v3 of compute rpc API

Add support for the 3.0 compute rpc API.  This commit retains compatibility
with the older 2.X API to allow continuous deployment without any downtime.

The v3 rev of this API was determined primarily by copying the current API
in nova.compute.rpcapi.  That class always reflects the latest rev of the
API that is actually being used.

UpgradeImpact - Deployments doing continuous deployment should follow this
process to upgrade without any downtime with the consoleauth service:

1) Set [upgrade_levels] compute=havana in your config.

2) Upgrade to this commit.

3) Once everything has been upgraded, remove the entry in
[upgrade_levels] so that all rpc clients to the nova-compute service
start sending the new 3.0 messages.

Part of blueprint rpc-major-version-updates-icehouse

Change-Id: I5d303445ded2342a54d8319b79df172ce50fa716

nova/compute/manager.py

@@ -451,6 +451,12 @@ class ComputeManager(manager.SchedulerDependentManager):
         self.use_legacy_block_device_info = \
                             self.driver.need_legacy_block_device_info
 
+    def create_rpc_dispatcher(self, backdoor_port=None, additional_apis=None):
+        additional_apis = additional_apis or []
+        additional_apis.append(_ComputeV3Proxy(self))
+        return super(ComputeManager, self).create_rpc_dispatcher(
+                backdoor_port, additional_apis)
+
     def _get_resource_tracker(self, nodename):
         rt = self._resource_tracker_dict.get(nodename)
         if not rt:
@@ -2091,28 +2097,6 @@ class ComputeManager(manager.SchedulerDependentManager):
                 task_state=None)
         self._notify_about_instance_usage(context, instance, "restore.end")
 
-    # NOTE(johannes): In the folsom release, power_off_instance was poorly
-    # named. It was the main entry point to soft delete an instance. That
-    # has been changed to soft_delete_instance now, but power_off_instance
-    # will need to stick around for compatibility in grizzly.
-    @wrap_exception()
-    @reverts_task_state
-    @wrap_instance_fault
-    def power_off_instance(self, context, instance):
-        """Power off an instance on this host."""
-        self.soft_delete_instance(context, instance)
-
-    # NOTE(johannes): In the folsom release, power_on_instance was poorly
-    # named. It was the main entry point to restore a soft deleted instance.
-    # That has been changed to restore_instance now, but power_on_instance
-    # will need to stick around for compatibility in grizzly.
-    @wrap_exception()
-    @reverts_task_state
-    @wrap_instance_fault
-    def power_on_instance(self, context, instance):
-        """Power on an instance on this host."""
-        self.restore_instance(context, instance)
-
     @wrap_exception()
     @reverts_task_state
     @wrap_instance_event
@@ -5240,3 +5224,267 @@ class ComputeManager(manager.SchedulerDependentManager):
                     instance.cleaned = True
                 with utils.temporary_mutation(context, read_deleted='yes'):
                     instance.save(context)
+
+
+class _ComputeV3Proxy(object):
+
+    RPC_API_VERSION = '3.0'
+
+    def __init__(self, manager):
+        self.manager = manager
+
+    def add_aggregate_host(self, ctxt, aggregate, host, slave_info):
+        return self.manager.add_aggregate_host(ctxt, aggregate=aggregate,
+                host=host, slave_info=slave_info)
+
+    def add_fixed_ip_to_instance(self, ctxt, network_id, instance):
+        return self.manager.add_fixed_ip_to_instance(ctxt, network_id,
+                instance)
+
+    def attach_interface(self, ctxt, instance, network_id, port_id,
+                         requested_ip):
+        return self.manager.attach_interface(ctxt, instance, network_id,
+                port_id, requested_ip)
+
+    def attach_volume(self, ctxt, volume_id, mountpoint, instance):
+        return self.manager.attach_volume(ctxt, volume_id, mountpoint,
+                instance)
+
+    def change_instance_metadata(self, ctxt, diff, instance):
+        return self.manager.change_instance_metadata(ctxt, diff, instance)
+
+    def check_can_live_migrate_destination(self, ctxt,
+             instance, block_migration, disk_over_commit):
+        return self.manager.check_can_live_migrate_destination(ctxt, instance,
+                block_migration, disk_over_commit)
+
+    def check_can_live_migrate_source(self, ctxt, instance, dest_check_data):
+        return self.manager.check_can_live_migrate_source(ctxt, instance,
+                dest_check_data)
+
+    def check_instance_shared_storage(self, ctxt, instance, data):
+        return self.manager.check_instance_shared_storage(ctxt, instance, data)
+
+    def confirm_resize(self, ctxt, instance, reservations, migration):
+        return self.manager.confirm_resize(ctxt, instance=instance,
+                reservations=reservations, migration=migration)
+
+    def detach_interface(self, ctxt, instance, port_id):
+        return self.manager.detach_interface(ctxt, instance, port_id)
+
+    def detach_volume(self, ctxt, volume_id, instance):
+        return self.manager.detach_volume(ctxt, volume_id, instance)
+
+    def finish_resize(self, ctxt, instance, migration, image, disk_info,
+            reservations):
+        return self.manager.finish_resize(ctxt, instance=instance,
+                migration=migration, image=image,
+                disk_info=disk_info, reservations=reservations)
+
+    def finish_revert_resize(self, ctxt, instance, migration, reservations):
+        return self.manager.finish_revert_resize(ctxt, instance=instance,
+                migration=migration, reservations=reservations)
+
+    def get_console_output(self, ctxt, instance, tail_length):
+        return self.manager.get_console_output(ctxt, instance, tail_length)
+
+    def get_console_pool_info(self, ctxt, console_type):
+        return self.manager.get_console_pool_info(ctxt, console_type)
+
+    def get_console_topic(self, ctxt):
+        return self.manager.get_console_topic(ctxt)
+
+    def get_diagnostics(self, ctxt, instance):
+        return self.manager.get_diagnostics(ctxt, instance)
+
+    def get_vnc_console(self, ctxt, console_type, instance):
+        return self.manager.get_vnc_console(ctxt, console_type, instance)
+
+    def get_spice_console(self, ctxt, console_type, instance):
+        return self.manager.get_spice_console(ctxt, console_type, instance)
+
+    def validate_console_port(self, ctxt, instance, port, console_type):
+        return self.manager.validate_console_port(ctxt, instance, port,
+                console_type)
+
+    def host_maintenance_mode(self, ctxt, host, mode):
+        return self.manager.host_maintenance_mode(ctxt, host, mode)
+
+    def host_power_action(self, ctxt, action):
+        return self.manager.host_power_action(ctxt, None, action)
+
+    def inject_file(self, ctxt, instance, path, file_contents):
+        return self.manager.inject_file(ctxt, instance, path, file_contents)
+
+    def inject_network_info(self, ctxt, instance):
+        return self.manager.inject_network_info(ctxt, instance)
+
+    def live_migration(self, ctxt, instance, dest, block_migration,
+                       migrate_data):
+        return self.manager.live_migration(ctxt, instance, dest,
+                block_migration, migrate_data)
+
+    def pause_instance(self, ctxt, instance):
+        return self.manager.pause_instance(ctxt, instance)
+
+    def post_live_migration_at_destination(self, ctxt, instance,
+            block_migration):
+        return self.manager.post_live_migration_at_destination(ctxt, instance,
+                block_migration)
+
+    def pre_live_migration(self, ctxt, instance, block_migration, disk,
+            migrate_data):
+        return self.manager.pre_live_migration(ctxt, instance, block_migration,
+                disk, migrate_data)
+
+    def prep_resize(self, ctxt, image, instance, instance_type,
+                    reservations, request_spec,
+                    filter_properties, node):
+        return self.manager.prep_resize(ctxt, image=image,
+                instance=instance, instance_type=instance_type,
+                reservations=reservations, request_spec=request_spec,
+                filter_properties=filter_properties, node=node)
+
+    def reboot_instance(self, ctxt, instance, block_device_info,
+                        reboot_type):
+        return self.manager.reboot_instance(ctxt, instance=instance,
+                block_device_info=block_device_info, reboot_type=reboot_type)
+
+    def rebuild_instance(self, ctxt, instance, orig_image_ref, image_ref,
+            injected_files, new_pass, orig_sys_metadata, bdms, recreate,
+            on_shared_storage):
+        return self.manager.rebuild_instance(ctxt, instance,
+                orig_image_ref, image_ref, injected_files, new_pass,
+                orig_sys_metadata, bdms, recreate,
+                on_shared_storage)
+
+    def refresh_provider_fw_rules(self, ctxt):
+        return self.manager.refresh_provider_fw_rules(ctxt)
+
+    def remove_aggregate_host(self, ctxt, aggregate, host, slave_info):
+        return self.manager.remove_aggregate_host(ctxt, aggregate=aggregate,
+                host=host, slave_info=slave_info)
+
+    def remove_fixed_ip_from_instance(self, ctxt, address, instance):
+        return self.manager.remove_fixed_ip_from_instance(ctxt, address,
+                instance)
+
+    def remove_volume_connection(self, ctxt, instance, volume_id):
+        return self.manager.remove_volume_connection(ctxt, instance, volume_id)
+
+    def rescue_instance(self, ctxt, instance, rescue_password):
+        return self.manager.rescue_instance(ctxt, instance, rescue_password)
+
+    def reset_network(self, ctxt, instance):
+        return self.manager.reset_network(ctxt, instance)
+
+    def resize_instance(self, ctxt, instance, image, reservations, migration,
+            instance_type):
+        return self.manager.resize_instance(ctxt, instance=instance,
+                image=image, reservations=reservations, migration=migration,
+                instance_type=instance_type)
+
+    def resume_instance(self, ctxt, instance):
+        return self.manager.resume_instance(ctxt, instance)
+
+    def revert_resize(self, ctxt, instance, migration, reservations):
+        return self.manager.revert_resize(ctxt, instance=instance,
+                migration=migration, reservations=reservations)
+
+    def rollback_live_migration_at_destination(self, ctxt, instance):
+        return self.manager.rollback_live_migration_at_destination(ctxt,
+                instance)
+
+    def run_instance(self, ctxt, instance, request_spec,
+                     filter_properties, requested_networks,
+                     injected_files, admin_password,
+                     is_first_time, node, legacy_bdm_in_spec):
+        return self.manager.run_instance(ctxt, instance, request_spec,
+                filter_properties, requested_networks,
+                injected_files, admin_password,
+                is_first_time, node, legacy_bdm_in_spec)
+
+    def set_admin_password(self, ctxt, instance, new_pass):
+        return self.manager.set_admin_password(ctxt, instance, new_pass)
+
+    def set_host_enabled(self, ctxt, enabled):
+        return self.manager.set_host_enabled(ctxt, enabled=enabled)
+
+    def swap_volume(self, ctxt, instance, old_volume_id, new_volume_id):
+        return self.manager.swap_volume(ctxt, instance, old_volume_id,
+                new_volume_id)
+
+    def get_host_uptime(self, ctxt):
+        return self.manager.get_host_uptime(ctxt)
+
+    def reserve_block_device_name(self, ctxt, instance, device, volume_id):
+        return self.manager.reserve_block_device_name(ctxt, instance, device,
+                volume_id)
+
+    def live_snapshot_instance(self, ctxt, instance, image_id):
+        return self.manager.live_snapshot_instance(ctxt, instance, image_id)
+
+    def backup_instance(self, ctxt, image_id, instance, backup_type,
+                        rotation):
+        return self.manager.backup_instance(ctxt, image_id, instance,
+                backup_type, rotation)
+
+    def snapshot_instance(self, ctxt, instance, image_id):
+        return self.manager.snapshot_instance(ctxt, instance=instance,
+                image_id=image_id)
+
+    def start_instance(self, ctxt, instance):
+        return self.manager.start_instance(ctxt, instance)
+
+    def stop_instance(self, ctxt, instance):
+        return self.manager.stop_instance(ctxt, instance)
+
+    def suspend_instance(self, ctxt, instance):
+        return self.manager.suspend_instance(ctxt, instance)
+
+    def terminate_instance(self, ctxt, instance, bdms, reservations):
+        return self.manager.terminate_instance(ctxt, instance=instance,
+                bdms=bdms, reservations=reservations)
+
+    def unpause_instance(self, ctxt, instance):
+        return self.manager.unpause_instance(ctxt, instance)
+
+    def unrescue_instance(self, ctxt, instance):
+        return self.manager.unrescue_instance(ctxt, instance)
+
+    def soft_delete_instance(self, ctxt, instance, reservations):
+        return self.manager.soft_delete_instance(ctxt, instance=instance,
+                reservations=reservations)
+
+    def restore_instance(self, ctxt, instance):
+        return self.manager.restore_instance(ctxt, instance)
+
+    def shelve_instance(self, ctxt, instance, image_id):
+        return self.manager.shelve_instance(ctxt, instance, image_id)
+
+    def shelve_offload_instance(self, ctxt, instance):
+        return self.manager.shelve_offload_instance(ctxt, instance)
+
+    def unshelve_instance(self, ctxt, instance, image):
+        return self.manager.unshelve_instance(ctxt, instance, image)
+
+    def volume_snapshot_create(self, ctxt, instance, volume_id,
+                               create_info):
+        return self.manager.volume_snapshot_create(ctxt, instance, volume_id,
+                create_info)
+
+    def volume_snapshot_delete(self, ctxt, instance, volume_id, snapshot_id,
+                               delete_info):
+        return self.manager.volume_snapshot_delete(ctxt, instance, volume_id,
+                snapshot_id, delete_info)
+
+    def refresh_security_group_rules(self, ctxt, security_group_id):
+        return self.manager.refresh_security_group_rules(ctxt,
+                security_group_id)
+
+    def refresh_security_group_members(self, ctxt, security_group_id):
+        return self.manager.refresh_security_group_members(ctxt,
+                security_group_id)
+
+    def refresh_instance_security_rules(self, ctxt, instance):
+        return self.manager.refresh_instance_security_rules(ctxt, instance)

nova/compute/rpcapi.py

@@ -210,6 +210,8 @@ class ComputeAPI(rpcclient.RpcProxy):
         2.48 - Make add_aggregate_host() and remove_aggregate_host() take
                new-world objects
         ...  - Remove live_snapshot() that was never actually used
+
+        3.0 - Remove 2.x compatibility
     '''
 
     #
@@ -220,7 +222,7 @@ class ComputeAPI(rpcclient.RpcProxy):
     # about rpc API versioning, see the docs in
     # openstack/common/rpc/dispatcher.py.
     #
-    BASE_RPC_API_VERSION = '2.0'
+    BASE_RPC_API_VERSION = '3.0'
 
     VERSION_ALIASES = {
         'grizzly': '2.27',
@@ -237,6 +239,11 @@ class ComputeAPI(rpcclient.RpcProxy):
                 version_cap=version_cap)
         self.client = self.get_client()
 
+    def _get_compat_version(self, current, havana_compat):
+        if not self.can_send_version(current):
+            return havana_compat
+        return current
+
     def add_aggregate_host(self, ctxt, aggregate, host_param, host,
                            slave_info=None):
         '''Add aggregate host.
@@ -247,53 +254,63 @@ class ComputeAPI(rpcclient.RpcProxy):
                            parameter for the remote method.
         :param host: This is the host to send the message to.
         '''
-
-        if self.client.can_send_version('2.48'):
+        if self.can_send_version('3.0'):
+            version = '3.0'
+        elif self.can_send_version('2.48'):
             version = '2.48'
         else:
+            # NOTE(russellb) Havana compat
             version = '2.14'
             aggregate = jsonutils.to_primitive(aggregate)
+
         cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'add_aggregate_host',
                    aggregate=aggregate, host=host_param,
                    slave_info=slave_info)
 
     def add_fixed_ip_to_instance(self, ctxt, instance, network_id):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         cctxt.cast(ctxt, 'add_fixed_ip_to_instance',
                    instance=instance_p, network_id=network_id)
 
     def attach_interface(self, ctxt, instance, network_id, port_id,
                          requested_ip):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.25')
         instance_p = jsonutils.to_primitive(instance)
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version='2.25')
+                version=version)
         return cctxt.call(ctxt, 'attach_interface',
                           instance=instance_p, network_id=network_id,
                           port_id=port_id, requested_ip=requested_ip)
 
     def attach_volume(self, ctxt, instance, volume_id, mountpoint):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         cctxt.cast(ctxt, 'attach_volume',
                    instance=instance_p, volume_id=volume_id,
                    mountpoint=mountpoint)
 
     def change_instance_metadata(self, ctxt, instance, diff):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         cctxt.cast(ctxt, 'change_instance_metadata',
                    instance=instance_p, diff=diff)
 
     def check_can_live_migrate_destination(self, ctxt, instance, destination,
                                            block_migration, disk_over_commit):
-        if self.client.can_send_version('2.38'):
-            version = '2.38'
-        else:
-            version = '2.0'
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.38')
         cctxt = self.client.prepare(server=destination, version=version)
         return cctxt.call(ctxt, 'check_can_live_migrate_destination',
                           instance=instance,
@@ -301,66 +318,57 @@ class ComputeAPI(rpcclient.RpcProxy):
                           disk_over_commit=disk_over_commit)
 
     def check_can_live_migrate_source(self, ctxt, instance, dest_check_data):
-        if self.client.can_send_version('2.38'):
-            version = '2.38'
-        else:
-            version = '2.0'
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.38')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         return cctxt.call(ctxt, 'check_can_live_migrate_source',
                           instance=instance,
                           dest_check_data=dest_check_data)
 
     def check_instance_shared_storage(self, ctxt, instance, data):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.28')
         instance_p = jsonutils.to_primitive(instance)
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version='2.28')
+                version=version)
         return cctxt.call(ctxt, 'check_instance_shared_storage',
                           instance=instance_p,
                           data=data)
 
     def confirm_resize(self, ctxt, instance, migration, host,
             reservations=None, cast=True):
-        if self.client.can_send_version('2.39'):
-            version = '2.39'
-        else:
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
-            migration = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(migration))
-            version = '2.7'
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.39')
         cctxt = self.client.prepare(server=_compute_host(host, instance),
-                                    version=version)
+                version=version)
         rpc_method = cctxt.cast if cast else cctxt.call
         return rpc_method(ctxt, 'confirm_resize',
                           instance=instance, migration=migration,
                           reservations=reservations)
 
     def detach_interface(self, ctxt, instance, port_id):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.25')
         instance_p = jsonutils.to_primitive(instance)
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version='2.25')
+                version=version)
         cctxt.cast(ctxt, 'detach_interface',
                    instance=instance_p, port_id=port_id)
 
     def detach_volume(self, ctxt, instance, volume_id):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         cctxt.cast(ctxt, 'detach_volume',
                    instance=instance_p, volume_id=volume_id)
 
     def finish_resize(self, ctxt, instance, migration, image, disk_info,
             host, reservations=None):
-        if self.client.can_send_version('2.46'):
-            version = '2.46'
-        else:
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
-            migration = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(migration))
-            version = '2.8'
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.46')
         cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'finish_resize',
                    instance=instance, migration=migration,
@@ -368,57 +376,68 @@ class ComputeAPI(rpcclient.RpcProxy):
 
     def finish_revert_resize(self, ctxt, instance, migration, host,
                              reservations=None):
-        if self.client.can_send_version('2.47'):
-            version = '2.47'
-        else:
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
-            migration = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(migration))
-            version = '2.13'
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.47')
         cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'finish_revert_resize',
                    instance=instance, migration=migration,
                    reservations=reservations)
 
     def get_console_output(self, ctxt, instance, tail_length):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         return cctxt.call(ctxt, 'get_console_output',
                           instance=instance_p, tail_length=tail_length)
 
     def get_console_pool_info(self, ctxt, console_type, host):
-        cctxt = self.client.prepare(server=host)
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
+        cctxt = self.client.prepare(server=host, version=version)
         return cctxt.call(ctxt, 'get_console_pool_info',
                           console_type=console_type)
 
     def get_console_topic(self, ctxt, host):
-        cctxt = self.client.prepare(server=host)
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
+        cctxt = self.client.prepare(server=host, version=version)
         return cctxt.call(ctxt, 'get_console_topic')
 
     def get_diagnostics(self, ctxt, instance):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         return cctxt.call(ctxt, 'get_diagnostics',
                           instance=instance_p)
 
     def get_vnc_console(self, ctxt, instance, console_type):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         return cctxt.call(ctxt, 'get_vnc_console',
                           instance=instance_p, console_type=console_type)
 
     def get_spice_console(self, ctxt, instance, console_type):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.24')
         instance_p = jsonutils.to_primitive(instance)
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version='2.24')
+                version=version)
         return cctxt.call(ctxt, 'get_spice_console',
                           instance=instance_p, console_type=console_type)
 
     def validate_console_port(self, ctxt, instance, port, console_type):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.26')
         instance_p = jsonutils.to_primitive(instance)
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version='2.26')
+                version=version)
         return cctxt.call(ctxt, 'validate_console_port',
                           instance=instance_p, port=port,
                           console_type=console_type)
@@ -432,73 +451,68 @@ class ComputeAPI(rpcclient.RpcProxy):
         :param mode:
         :param host: This is the host to send the message to.
         '''
-        cctxt = self.client.prepare(server=host)
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
+        cctxt = self.client.prepare(server=host, version=version)
         return cctxt.call(ctxt, 'host_maintenance_mode',
                           host=host_param, mode=mode)
 
     def host_power_action(self, ctxt, action, host):
-        cctxt = self.client.prepare(server=host)
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
+        cctxt = self.client.prepare(server=host, version=version)
         return cctxt.call(ctxt, 'host_power_action', action=action)
 
     def inject_file(self, ctxt, instance, path, file_contents):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         cctxt.cast(ctxt, 'inject_file',
                    instance=instance_p, path=path,
                    file_contents=file_contents)
 
     def inject_network_info(self, ctxt, instance):
-        if self.client.can_send_version('2.41'):
-            version = '2.41'
-        else:
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
-            version = '2.0'
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.41')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'inject_network_info', instance=instance)
 
     def live_migration(self, ctxt, instance, dest, block_migration, host,
                        migrate_data=None):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=host)
+        cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'live_migration', instance=instance_p,
                    dest=dest, block_migration=block_migration,
                    migrate_data=migrate_data)
 
     def pause_instance(self, ctxt, instance):
-        if self.client.can_send_version('2.36'):
-            version = '2.36'
-        else:
-            version = '2.0'
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.36')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'pause_instance', instance=instance)
 
     def post_live_migration_at_destination(self, ctxt, instance,
             block_migration, host):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=host)
+        cctxt = self.client.prepare(server=host, version=version)
         return cctxt.call(ctxt,
                           'post_live_migration_at_destination',
                           instance=instance_p, block_migration=block_migration)
 
-    def power_off_instance(self, ctxt, instance):
-        instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
-        cctxt.cast(ctxt, 'power_off_instance', instance=instance_p)
-
-    def power_on_instance(self, ctxt, instance):
-        instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
-        cctxt.cast(ctxt, 'power_on_instance', instance=instance_p)
-
     def pre_live_migration(self, ctxt, instance, block_migration, disk,
             host, migrate_data=None):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.21')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=host, version='2.21')
+        cctxt = self.client.prepare(server=host, version=version)
         return cctxt.call(ctxt, 'pre_live_migration',
                           instance=instance_p,
                           block_migration=block_migration,
@@ -507,12 +521,8 @@ class ComputeAPI(rpcclient.RpcProxy):
     def prep_resize(self, ctxt, image, instance, instance_type, host,
                     reservations=None, request_spec=None,
                     filter_properties=None, node=None):
-        if self.client.can_send_version('2.43'):
-            version = '2.43'
-        else:
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
-            version = '2.20'
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.43')
         instance_type_p = jsonutils.to_primitive(instance_type)
         image_p = jsonutils.to_primitive(image)
         cctxt = self.client.prepare(server=host, version=version)
@@ -526,14 +536,10 @@ class ComputeAPI(rpcclient.RpcProxy):
 
     def reboot_instance(self, ctxt, instance, block_device_info,
                         reboot_type):
-        if not self.client.can_send_version('2.32'):
-            version = '2.23'
-            instance = jsonutils.to_primitive(
-                objects_base.obj_to_primitive(instance))
-        else:
-            version = '2.32'
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.32')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'reboot_instance',
                    instance=instance,
                    block_device_info=block_device_info,
@@ -542,10 +548,12 @@ class ComputeAPI(rpcclient.RpcProxy):
     def rebuild_instance(self, ctxt, instance, new_pass, injected_files,
             image_ref, orig_image_ref, orig_sys_metadata, bdms,
             recreate=False, on_shared_storage=False, host=None):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.22')
         instance_p = jsonutils.to_primitive(instance)
         bdms_p = jsonutils.to_primitive(bdms)
         cctxt = self.client.prepare(server=_compute_host(host, instance),
-                                    version='2.22')
+                version=version)
         cctxt.cast(ctxt, 'rebuild_instance',
                    instance=instance_p, new_pass=new_pass,
                    injected_files=injected_files, image_ref=image_ref,
@@ -554,7 +562,9 @@ class ComputeAPI(rpcclient.RpcProxy):
                    recreate=recreate, on_shared_storage=on_shared_storage)
 
     def refresh_provider_fw_rules(self, ctxt, host):
-        cctxt = self.client.prepare(server=host)
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
+        cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'refresh_provider_fw_rules')
 
     def remove_aggregate_host(self, ctxt, aggregate, host_param, host,
@@ -567,95 +577,88 @@ class ComputeAPI(rpcclient.RpcProxy):
                            parameter for the remote method.
         :param host: This is the host to send the message to.
         '''
-
-        if self.client.can_send_version('2.48'):
+        if self.can_send_version('3.0'):
+            version = '3.0'
+        elif self.can_send_version('2.48'):
             version = '2.48'
         else:
+            # NOTE(russellb) Havana compat
             version = '2.15'
             aggregate = jsonutils.to_primitive(aggregate)
+
         cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'remove_aggregate_host',
                    aggregate=aggregate, host=host_param,
                    slave_info=slave_info)
 
     def remove_fixed_ip_from_instance(self, ctxt, instance, address):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         cctxt.cast(ctxt, 'remove_fixed_ip_from_instance',
                    instance=instance_p, address=address)
 
     def remove_volume_connection(self, ctxt, instance, volume_id, host):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=host)
+        cctxt = self.client.prepare(server=host, version=version)
         return cctxt.call(ctxt, 'remove_volume_connection',
                           instance=instance_p, volume_id=volume_id)
 
     def rescue_instance(self, ctxt, instance, rescue_password):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         cctxt.cast(ctxt, 'rescue_instance',
                    instance=instance_p,
                    rescue_password=rescue_password)
 
     def reset_network(self, ctxt, instance):
-        if self.client.can_send_version('2.40'):
-            version = '2.40'
-        else:
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
-            version = '2.0'
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.40')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'reset_network', instance=instance)
 
     def resize_instance(self, ctxt, instance, migration, image, instance_type,
                         reservations=None):
-        if self.client.can_send_version('2.45'):
-            version = '2.45'
-        else:
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
-            migration = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(migration))
-            version = '2.16'
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.45')
         instance_type_p = jsonutils.to_primitive(instance_type)
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'resize_instance',
                    instance=instance, migration=migration,
                    image=image, reservations=reservations,
                    instance_type=instance_type_p)
 
     def resume_instance(self, ctxt, instance):
-        if self.client.can_send_version('2.33'):
-            version = '2.33'
-        else:
-            version = '2.0'
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.33')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'resume_instance', instance=instance)
 
     def revert_resize(self, ctxt, instance, migration, host,
                       reservations=None):
-        if self.client.can_send_version('2.39'):
-            version = '2.39'
-        else:
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
-            migration = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(migration))
-            version = '2.12'
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.39')
         cctxt = self.client.prepare(server=_compute_host(host, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'revert_resize',
                    instance=instance, migration=migration,
                    reservations=reservations)
 
     def rollback_live_migration_at_destination(self, ctxt, instance, host):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=host)
+        cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'rollback_live_migration_at_destination',
                    instance=instance_p)
 
@@ -663,198 +666,183 @@ class ComputeAPI(rpcclient.RpcProxy):
                      filter_properties, requested_networks,
                      injected_files, admin_password,
                      is_first_time, node=None, legacy_bdm_in_spec=True):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.37')
         instance_p = jsonutils.to_primitive(instance)
         msg_kwargs = {'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, 'node': node}
+                      'is_first_time': is_first_time, 'node': node,
+                      'legacy_bdm_in_spec': legacy_bdm_in_spec}
 
-        if self.client.can_send_version('2.37'):
-            version = '2.37'
-            msg_kwargs['legacy_bdm_in_spec'] = legacy_bdm_in_spec
-        else:
-            version = '2.19'
         cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'run_instance', **msg_kwargs)
 
     def set_admin_password(self, ctxt, instance, new_pass):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         return cctxt.call(ctxt, 'set_admin_password',
                           instance=instance_p, new_pass=new_pass)
 
     def set_host_enabled(self, ctxt, enabled, host):
-        cctxt = self.client.prepare(server=host)
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
+        cctxt = self.client.prepare(server=host, version=version)
         return cctxt.call(ctxt, 'set_host_enabled', enabled=enabled)
 
     def swap_volume(self, ctxt, instance, old_volume_id, new_volume_id):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.34')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version='2.34')
+                version=version)
         cctxt.cast(ctxt, 'swap_volume',
                    instance=instance, old_volume_id=old_volume_id,
                    new_volume_id=new_volume_id)
 
     def get_host_uptime(self, ctxt, host):
-        cctxt = self.client.prepare(server=host)
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
+        cctxt = self.client.prepare(server=host, version=version)
         return cctxt.call(ctxt, 'get_host_uptime')
 
     def reserve_block_device_name(self, ctxt, instance, device, volume_id):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.3')
         instance_p = jsonutils.to_primitive(instance)
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version='2.3')
+                version=version)
         return cctxt.call(ctxt, 'reserve_block_device_name',
                           instance=instance_p, device=device,
                           volume_id=volume_id)
 
     def backup_instance(self, ctxt, instance, image_id, backup_type,
                         rotation):
-        if self.client.can_send_version('2.42'):
-            version = '2.42'
-            method = 'backup_instance'
-            extra_kwargs = dict()
-        else:
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
-            method = 'snapshot_instance'
-            extra_kwargs = dict(image_type='backup')
-            version = '2.0'
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.42')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
-        cctxt.cast(ctxt, method,
+                version=version)
+        cctxt.cast(ctxt, 'backup_instance',
                    instance=instance,
                    image_id=image_id,
                    backup_type=backup_type,
-                   rotation=rotation,
-                   **extra_kwargs)
+                   rotation=rotation)
 
     def snapshot_instance(self, ctxt, instance, image_id):
-        if self.client.can_send_version('2.42'):
-            version = '2.42'
-            extra_kwargs = dict()
-        else:
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
-            extra_kwargs = dict(image_type='snapshot',
-                                backup_type=None,
-                                rotation=None)
-            version = '2.0'
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.42')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'snapshot_instance',
                    instance=instance,
-                   image_id=image_id,
-                   **extra_kwargs)
+                   image_id=image_id)
 
     def start_instance(self, ctxt, instance):
-        if self.client.can_send_version('2.29'):
-            version = '2.29'
-        else:
-            version = '2.0'
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.29')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'start_instance', instance=instance)
 
     def stop_instance(self, ctxt, instance, do_cast=True):
-        if self.client.can_send_version('2.29'):
-            version = '2.29'
-        else:
-            version = '2.0'
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.29')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         rpc_method = cctxt.cast if do_cast else cctxt.call
         return rpc_method(ctxt, 'stop_instance', instance=instance)
 
     def suspend_instance(self, ctxt, instance):
-        if self.client.can_send_version('2.33'):
-            version = '2.33'
-        else:
-            version = '2.0'
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.33')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'suspend_instance', instance=instance)
 
     def terminate_instance(self, ctxt, instance, bdms, reservations=None):
-        if self.client.can_send_version('2.35'):
-            version = '2.35'
-        else:
-            version = '2.27'
-            instance = jsonutils.to_primitive(instance)
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.35')
         bdms_p = jsonutils.to_primitive(bdms)
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'terminate_instance',
                    instance=instance, bdms=bdms_p,
                    reservations=reservations)
 
     def unpause_instance(self, ctxt, instance):
-        if self.client.can_send_version('2.36'):
-            version = '2.36'
-        else:
-            version = '2.0'
-            instance = jsonutils.to_primitive(
-                    objects_base.obj_to_primitive(instance))
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.36')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'unpause_instance', instance=instance)
 
     def unrescue_instance(self, ctxt, instance):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         cctxt.cast(ctxt, 'unrescue_instance', instance=instance_p)
 
     def soft_delete_instance(self, ctxt, instance, reservations=None):
-        if self.client.can_send_version('2.35'):
-            version = '2.35'
-        else:
-            version = '2.27'
-            instance = jsonutils.to_primitive(instance)
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.35')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version=version)
+                version=version)
         cctxt.cast(ctxt, 'soft_delete_instance',
                    instance=instance, reservations=reservations)
 
     def restore_instance(self, ctxt, instance):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         cctxt.cast(ctxt, 'restore_instance', instance=instance_p)
 
     def shelve_instance(self, ctxt, instance, image_id=None):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.31')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version='2.31')
+                version=version)
         cctxt.cast(ctxt, 'shelve_instance',
                    instance=instance, image_id=image_id)
 
     def shelve_offload_instance(self, ctxt, instance):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.31')
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version='2.31')
+                version=version)
         cctxt.cast(ctxt, 'shelve_offload_instance', instance=instance)
 
     def unshelve_instance(self, ctxt, instance, host, image=None):
-        cctxt = self.client.prepare(server=host, version='2.31')
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.31')
+        cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'unshelve_instance',
                    instance=instance, image=image)
 
     def volume_snapshot_create(self, ctxt, instance, volume_id,
                                create_info):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.44')
         instance_p = jsonutils.to_primitive(instance)
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version='2.44')
+                version=version)
         cctxt.cast(ctxt, 'volume_snapshot_create', instance=instance_p,
                    volume_id=volume_id, create_info=create_info)
 
     def volume_snapshot_delete(self, ctxt, instance, volume_id, snapshot_id,
                                delete_info):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.44')
         instance_p = jsonutils.to_primitive(instance)
         cctxt = self.client.prepare(server=_compute_host(None, instance),
-                                    version='2.44')
+                version=version)
         cctxt.cast(ctxt, 'volume_snapshot_delete', instance=instance_p,
                    volume_id=volume_id, snapshot_id=snapshot_id,
                    delete_info=delete_info)
@@ -869,6 +857,9 @@ class SecurityGroupAPI(rpcclient.RpcProxy):
         1.41 - Adds refresh_instance_security_rules()
 
         2.0 - Remove 1.x backwards compat
+
+        3.0 - Identical to 2.x, but has to be bumped at the same time as the
+              compute API since it's all together on the server side.
     '''
 
     #
@@ -879,27 +870,42 @@ class SecurityGroupAPI(rpcclient.RpcProxy):
     # about rpc API versioning, see the docs in
     # openstack/common/rpc/dispatcher.py.
     #
-    BASE_RPC_API_VERSION = '2.0'
+    BASE_RPC_API_VERSION = '3.0'
 
     def __init__(self):
+        version_cap = ComputeAPI.VERSION_ALIASES.get(
+                CONF.upgrade_levels.compute, CONF.upgrade_levels.compute)
         super(SecurityGroupAPI, self).__init__(
                 topic=CONF.compute_topic,
-                default_version=self.BASE_RPC_API_VERSION)
+                default_version=self.BASE_RPC_API_VERSION,
+                version_cap=version_cap)
         self.client = self.get_client()
 
+    def _get_compat_version(self, current, havana_compat):
+        if not self.can_send_version(current):
+            return havana_compat
+        return current
+
     def refresh_security_group_rules(self, ctxt, security_group_id, host):
-        cctxt = self.client.prepare(server=host)
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
+        cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'refresh_security_group_rules',
                    security_group_id=security_group_id)
 
     def refresh_security_group_members(self, ctxt, security_group_id,
             host):
-        cctxt = self.client.prepare(server=host)
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
+        cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'refresh_security_group_members',
                    security_group_id=security_group_id)
 
     def refresh_instance_security_rules(self, ctxt, host, instance):
+        # NOTE(russellb) Havana compat
+        version = self._get_compat_version('3.0', '2.0')
         instance_p = jsonutils.to_primitive(instance)
-        cctxt = self.client.prepare(server=_compute_host(None, instance))
+        cctxt = self.client.prepare(server=_compute_host(None, instance),
+                version=version)
         cctxt.cast(ctxt, 'refresh_instance_security_rules',
                    instance=instance_p)

nova/tests/compute/test_compute.py

@@ -3262,8 +3262,6 @@ class ComputeTestCase(BaseTestCase):
             ("stop_instance", task_states.POWERING_OFF),
             ("start_instance", task_states.POWERING_ON),
             ("terminate_instance", task_states.DELETING),
-            ("power_off_instance", task_states.POWERING_OFF),
-            ("power_on_instance", task_states.POWERING_ON),
             ("soft_delete_instance", task_states.SOFT_DELETING),
             ("restore_instance", task_states.RESTORING),
             ("rebuild_instance", task_states.REBUILDING,
@@ -7500,7 +7498,7 @@ class ComputeAPITestCase(BaseTestCase):
                     'namespace': None,
                     'args': {'instance': fake_instance,
                              'console_type': fake_console_type},
-                   'version': '2.24'}
+                   'version': '3.0'}
         rpc_msg2 = {'method': 'authorize_console',
                     'namespace': None,
                     'args': fake_connect_info,

nova/tests/compute/test_rpcapi.py

@@ -100,58 +100,146 @@ class ComputeRpcAPITestCase(test.TestCase):
     def test_add_aggregate_host(self):
         self._test_compute_api('add_aggregate_host', 'cast',
                 aggregate={'id': 'fake_id'}, host_param='host', host='host',
-                slave_info={}, version='2.48')
+                slave_info={})
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('add_aggregate_host', 'cast',
+                aggregate={'id': 'fake_id'}, host_param='host', host='host',
+                slave_info={}, version='2.14')
 
     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')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('add_fixed_ip_to_instance', 'cast',
+                instance=self.fake_instance, network_id='id', version='2.0')
+
+    def test_attach_interface(self):
+        self._test_compute_api('attach_interface', 'call',
+                instance=self.fake_instance, network_id='id', port_id='id2',
+                requested_ip='192.168.1.50')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('attach_interface', 'call',
+                instance=self.fake_instance, network_id='id', port_id='id2',
+                requested_ip='192.168.1.50', version='2.25')
+
     def test_attach_volume(self):
         self._test_compute_api('attach_volume', 'cast',
                 instance=self.fake_instance, volume_id='id', mountpoint='mp')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('attach_volume', 'cast',
+                instance=self.fake_instance, volume_id='id', mountpoint='mp',
+                version='2.0')
+
     def test_change_instance_metadata(self):
         self._test_compute_api('change_instance_metadata', 'cast',
                 instance=self.fake_instance, diff={})
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('change_instance_metadata', 'cast',
+                instance=self.fake_instance, diff={}, version='2.0')
+
     def test_check_can_live_migrate_destination(self):
         self._test_compute_api('check_can_live_migrate_destination', 'call',
                 instance=self.fake_instance,
                 destination='dest', block_migration=True,
-                disk_over_commit=True,
-                version='2.38')
+                disk_over_commit=True)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('check_can_live_migrate_destination', 'call',
+                instance=self.fake_instance,
+                destination='dest', block_migration=True,
+                disk_over_commit=True, version='2.38')
 
     def test_check_can_live_migrate_source(self):
         self._test_compute_api('check_can_live_migrate_source', 'call',
                 instance=self.fake_instance,
-                dest_check_data={"test": "data"},
-                version='2.38')
+                dest_check_data={"test": "data"})
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('check_can_live_migrate_source', 'call',
+                instance=self.fake_instance,
+                dest_check_data={"test": "data"}, version='2.38')
 
     def test_check_instance_shared_storage(self):
+        self._test_compute_api('check_instance_shared_storage', 'call',
+                instance=self.fake_instance, data='foo')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('check_instance_shared_storage', 'call',
                 instance=self.fake_instance, data='foo', version='2.28')
 
     def test_confirm_resize_cast(self):
+        self._test_compute_api('confirm_resize', 'cast',
+                instance=self.fake_instance, migration={'id': 'foo'},
+                host='host', reservations=list('fake_res'))
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('confirm_resize', 'cast',
                 instance=self.fake_instance, migration={'id': 'foo'},
                 host='host', reservations=list('fake_res'), version='2.39')
 
     def test_confirm_resize_call(self):
         self._test_compute_api('confirm_resize', 'call',
+                instance=self.fake_instance, migration={'id': 'foo'},
+                host='host', reservations=list('fake_res'))
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('confirm_resize', 'cast',
                 instance=self.fake_instance, migration={'id': 'foo'},
                 host='host', reservations=list('fake_res'), version='2.39')
 
+    def test_detach_interface(self):
+        self._test_compute_api('detach_interface', 'cast',
+                instance=self.fake_instance, port_id='fake_id')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('detach_interface', 'cast',
+                instance=self.fake_instance, port_id='fake_id', version='2.25')
+
     def test_detach_volume(self):
         self._test_compute_api('detach_volume', 'cast',
                 instance=self.fake_instance, volume_id='id')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('detach_volume', 'cast',
+                instance=self.fake_instance, volume_id='id', version='2.0')
+
     def test_finish_resize(self):
+        self._test_compute_api('finish_resize', 'cast',
+                instance=self.fake_instance, migration={'id': 'foo'},
+                image='image', disk_info='disk_info', host='host',
+                reservations=list('fake_res'))
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('finish_resize', 'cast',
                 instance=self.fake_instance, migration={'id': 'foo'},
                 image='image', disk_info='disk_info', host='host',
                 reservations=list('fake_res'), version='2.46')
 
     def test_finish_revert_resize(self):
+        self._test_compute_api('finish_revert_resize', 'cast',
+                instance=self.fake_instance, migration={'id': 'fake_id'},
+                host='host', reservations=list('fake_res'))
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('finish_revert_resize', 'cast',
                 instance=self.fake_instance, migration={'id': 'fake_id'},
                 host='host', reservations=list('fake_res'), version='2.47')
@@ -160,22 +248,53 @@ class ComputeRpcAPITestCase(test.TestCase):
         self._test_compute_api('get_console_output', 'call',
                 instance=self.fake_instance, tail_length='tl')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('get_console_output', 'call',
+                instance=self.fake_instance, tail_length='tl', version='2.0')
+
     def test_get_console_pool_info(self):
         self._test_compute_api('get_console_pool_info', 'call',
                 console_type='type', host='host')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('get_console_pool_info', 'call',
+                console_type='type', host='host', version='2.0')
+
     def test_get_console_topic(self):
         self._test_compute_api('get_console_topic', 'call', host='host')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('get_console_topic', 'call', host='host',
+                version='2.0')
+
     def test_get_diagnostics(self):
         self._test_compute_api('get_diagnostics', 'call',
                 instance=self.fake_instance)
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('get_diagnostics', 'call',
+                instance=self.fake_instance, version='2.0')
+
     def test_get_vnc_console(self):
         self._test_compute_api('get_vnc_console', 'call',
                 instance=self.fake_instance, console_type='type')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('get_vnc_console', 'call',
+                instance=self.fake_instance, console_type='type',
+                version='2.0')
+
     def test_get_spice_console(self):
+        self._test_compute_api('get_spice_console', 'call',
+                instance=self.fake_instance, console_type='type')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('get_spice_console', 'call',
                 instance=self.fake_instance, console_type='type',
                 version='2.24')
@@ -183,25 +302,50 @@ class ComputeRpcAPITestCase(test.TestCase):
     def test_validate_console_port(self):
         self._test_compute_api('validate_console_port', 'call',
                 instance=self.fake_instance, port="5900",
-                console_type="novnc",
-                version="2.26")
+                console_type="novnc")
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('validate_console_port', 'call',
+                instance=self.fake_instance, port="5900",
+                console_type="novnc", version='2.26')
 
     def test_host_maintenance_mode(self):
         self._test_compute_api('host_maintenance_mode', 'call',
                 host_param='param', mode='mode', host='host')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('host_maintenance_mode', 'call',
+                host_param='param', mode='mode', host='host', version='2.0')
+
     def test_host_power_action(self):
         self._test_compute_api('host_power_action', 'call', action='action',
                 host='host')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('host_power_action', 'call', action='action',
+                host='host', version='2.0')
+
     def test_inject_file(self):
         self._test_compute_api('inject_file', 'cast',
                 instance=self.fake_instance, path='path', file_contents='fc')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('inject_file', 'cast',
+                instance=self.fake_instance, path='path', file_contents='fc',
+                version='2.0')
+
     def test_inject_network_info(self):
         self._test_compute_api('inject_network_info', 'cast',
-                instance=self.fake_instance,
-                version='2.41')
+                instance=self.fake_instance)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('inject_network_info', 'cast',
+                instance=self.fake_instance, version='2.41')
 
     def test_live_migration(self):
         self._test_compute_api('live_migration', 'cast',
@@ -209,44 +353,74 @@ class ComputeRpcAPITestCase(test.TestCase):
                 block_migration='blockity_block', host='tsoh',
                 migrate_data={})
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('live_migration', 'cast',
+                instance=self.fake_instance, dest='dest',
+                block_migration='blockity_block', host='tsoh',
+                migrate_data={}, version='2.0')
+
     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')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('post_live_migration_at_destination', 'call',
+                instance=self.fake_instance, block_migration='block_migration',
+                host='host', version='2.0')
+
     def test_pause_instance(self):
+        self._test_compute_api('pause_instance', 'cast',
+                               instance=self.fake_instance)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('pause_instance', 'cast',
                                instance=self.fake_instance, version='2.36')
 
-    def test_power_off_instance(self):
-        self._test_compute_api('power_off_instance', 'cast',
-                instance=self.fake_instance)
-
-    def test_power_on_instance(self):
-        self._test_compute_api('power_on_instance', 'cast',
-                instance=self.fake_instance)
-
     def test_soft_delete_instance(self):
         self._test_compute_api('soft_delete_instance', 'cast',
                 instance=self.fake_instance,
-                reservations=['uuid1', 'uuid2'],
-                version='2.35')
+                reservations=['uuid1', 'uuid2'])
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('soft_delete_instance', 'cast',
+                instance=self.fake_instance,
+                reservations=['uuid1', 'uuid2'], version='2.35')
 
     def test_swap_volume(self):
         self._test_compute_api('swap_volume', 'cast',
                 instance=self.fake_instance, old_volume_id='oldid',
-                new_volume_id='newid',
-                version='2.34')
+                new_volume_id='newid')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('swap_volume', 'cast',
+                instance=self.fake_instance, old_volume_id='oldid',
+                new_volume_id='newid', version='2.34')
 
     def test_restore_instance(self):
         self._test_compute_api('restore_instance', 'cast',
                 instance=self.fake_instance)
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('restore_instance', 'cast',
+                instance=self.fake_instance, version='2.0')
+
     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', migrate_data=None,
-                version='2.21')
+                disk='disk', host='host', migrate_data=None)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('pre_live_migration', 'call',
+                instance=self.fake_instance, block_migration='block_migration',
+                disk='disk', host='host', migrate_data=None, version='2.21')
 
     def test_prep_resize(self):
         self._test_compute_api('prep_resize', 'cast',
@@ -255,26 +429,40 @@ class ComputeRpcAPITestCase(test.TestCase):
                 reservations=list('fake_res'),
                 request_spec='fake_spec',
                 filter_properties={'fakeprop': 'fakeval'},
-                node='node',
-                version='2.43')
+                node='node')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('prep_resize', 'cast',
+                instance=self.fake_instance, instance_type='fake_type',
+                image='fake_image', host='host',
+                reservations=list('fake_res'),
+                request_spec='fake_spec',
+                filter_properties={'fakeprop': 'fakeval'},
+                node='node', version='2.43')
 
     def test_reboot_instance(self):
         self.maxDiff = None
         self._test_compute_api('reboot_instance', 'cast',
                 instance=self.fake_instance,
                 block_device_info={},
-                reboot_type='type',
-                version='2.32')
+                reboot_type='type')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('reboot_instance', 'cast',
+                instance=self.fake_instance,
+                block_device_info={},
+                reboot_type='type', version='2.32')
 
     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', bdms=[], recreate=False,
-                on_shared_storage=False, orig_sys_metadata='orig_sys_metadata',
-                version='2.22')
+        self._test_compute_api('rebuild_instance', 'cast', new_pass='None',
+                injected_files='None', image_ref='None', orig_image_ref='None',
+                bdms=[], instance=self.fake_instance, host='new_host',
+                orig_sys_metadata=None, recreate=True, on_shared_storage=True)
 
-    def test_rebuild_instance_with_shared(self):
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('rebuild_instance', 'cast', new_pass='None',
                 injected_files='None', image_ref='None', orig_image_ref='None',
                 bdms=[], instance=self.fake_instance, host='new_host',
@@ -282,6 +470,11 @@ class ComputeRpcAPITestCase(test.TestCase):
                 version='2.22')
 
     def test_reserve_block_device_name(self):
+        self._test_compute_api('reserve_block_device_name', 'call',
+                instance=self.fake_instance, device='device', volume_id='id')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('reserve_block_device_name', 'call',
                 instance=self.fake_instance, device='device', volume_id='id',
                 version='2.3')
@@ -290,39 +483,90 @@ class ComputeRpcAPITestCase(test.TestCase):
         self._test_compute_api('refresh_provider_fw_rules', 'cast',
                 host='host')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('refresh_provider_fw_rules', 'cast',
+                host='host', version='2.0')
+
     def test_refresh_security_group_rules(self):
         self._test_compute_api('refresh_security_group_rules', 'cast',
                 rpcapi_class=compute_rpcapi.SecurityGroupAPI,
                 security_group_id='id', host='host')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('refresh_security_group_rules', 'cast',
+                rpcapi_class=compute_rpcapi.SecurityGroupAPI,
+                security_group_id='id', host='host', version='2.0')
+
     def test_refresh_security_group_members(self):
         self._test_compute_api('refresh_security_group_members', 'cast',
                 rpcapi_class=compute_rpcapi.SecurityGroupAPI,
                 security_group_id='id', host='host')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('refresh_security_group_members', 'cast',
+                rpcapi_class=compute_rpcapi.SecurityGroupAPI,
+                security_group_id='id', host='host', version='2.0')
+
     def test_remove_aggregate_host(self):
         self._test_compute_api('remove_aggregate_host', 'cast',
                 aggregate={'id': 'fake_id'}, host_param='host', host='host',
-                slave_info={}, version='2.48')
+                slave_info={})
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('remove_aggregate_host', 'cast',
+                aggregate={'id': 'fake_id'}, host_param='host', host='host',
+                slave_info={}, version='2.15')
 
     def test_remove_fixed_ip_from_instance(self):
         self._test_compute_api('remove_fixed_ip_from_instance', 'cast',
                 instance=self.fake_instance, address='addr')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('remove_fixed_ip_from_instance', 'cast',
+                instance=self.fake_instance, address='addr', version='2.0')
+
     def test_remove_volume_connection(self):
         self._test_compute_api('remove_volume_connection', 'call',
                 instance=self.fake_instance, volume_id='id', host='host')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('remove_volume_connection', 'call',
+                instance=self.fake_instance, volume_id='id', host='host',
+                version='2.0')
+
     def test_rescue_instance(self):
         self._test_compute_api('rescue_instance', 'cast',
                 instance=self.fake_instance, rescue_password='pw')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('rescue_instance', 'cast',
+                instance=self.fake_instance, rescue_password='pw',
+                version='2.0')
+
     def test_reset_network(self):
         self._test_compute_api('reset_network', 'cast',
-                instance=self.fake_instance,
-                version='2.40')
+                instance=self.fake_instance)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('reset_network', 'cast',
+                instance=self.fake_instance, version='2.40')
 
     def test_resize_instance(self):
+        self._test_compute_api('resize_instance', 'cast',
+                instance=self.fake_instance, migration={'id': 'fake_id'},
+                image='image', instance_type={'id': 1},
+                reservations=list('fake_res'))
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('resize_instance', 'cast',
                 instance=self.fake_instance, migration={'id': 'fake_id'},
                 image='image', instance_type={'id': 1},
@@ -330,10 +574,20 @@ class ComputeRpcAPITestCase(test.TestCase):
 
     def test_resume_instance(self):
         self._test_compute_api('resume_instance', 'cast',
-                               instance=self.fake_instance,
-                               version='2.33')
+                               instance=self.fake_instance)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('resume_instance', 'cast',
+                               instance=self.fake_instance, version='2.33')
 
     def test_revert_resize(self):
+        self._test_compute_api('revert_resize', 'cast',
+                instance=self.fake_instance, migration={'id': 'fake_id'},
+                host='host', reservations=list('fake_res'))
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('revert_resize', 'cast',
                 instance=self.fake_instance, migration={'id': 'fake_id'},
                 host='host', reservations=list('fake_res'), version='2.39')
@@ -342,7 +596,22 @@ class ComputeRpcAPITestCase(test.TestCase):
         self._test_compute_api('rollback_live_migration_at_destination',
                 'cast', instance=self.fake_instance, host='host')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('rollback_live_migration_at_destination',
+                'cast', instance=self.fake_instance, host='host',
+                version='2.0')
+
     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, node='node',
+                legacy_bdm_in_spec=False)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('run_instance', 'cast',
                 instance=self.fake_instance, host='fake_host',
                 request_spec='fake_spec', filter_properties={},
@@ -354,76 +623,160 @@ class ComputeRpcAPITestCase(test.TestCase):
         self._test_compute_api('set_admin_password', 'call',
                 instance=self.fake_instance, new_pass='pw')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('set_admin_password', 'call',
+                instance=self.fake_instance, new_pass='pw', version='2.0')
+
     def test_set_host_enabled(self):
         self._test_compute_api('set_host_enabled', 'call',
                 enabled='enabled', host='host')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('set_host_enabled', 'call',
+                enabled='enabled', host='host', version='2.0')
+
     def test_get_host_uptime(self):
         self._test_compute_api('get_host_uptime', 'call', host='host')
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('get_host_uptime', 'call', host='host',
+                version='2.0')
+
     def test_backup_instance(self):
         self._test_compute_api('backup_instance', 'cast',
                 instance=self.fake_instance, image_id='id',
-                backup_type='type', rotation='rotation',
-                version='2.42')
+                backup_type='type', rotation='rotation')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('backup_instance', 'cast',
+                instance=self.fake_instance, image_id='id',
+                backup_type='type', rotation='rotation', version='2.42')
 
     def test_snapshot_instance(self):
         self._test_compute_api('snapshot_instance', 'cast',
-                instance=self.fake_instance, image_id='id',
-                version='2.42')
+                instance=self.fake_instance, image_id='id')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('snapshot_instance', 'cast',
+                instance=self.fake_instance, image_id='id', version='2.42')
 
     def test_start_instance(self):
+        self._test_compute_api('start_instance', 'cast',
+                instance=self.fake_instance)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('start_instance', 'cast',
                 instance=self.fake_instance, version='2.29')
 
     def test_stop_instance_cast(self):
+        self._test_compute_api('stop_instance', 'cast',
+                instance=self.fake_instance)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('stop_instance', 'cast',
                 instance=self.fake_instance, version='2.29')
 
     def test_stop_instance_call(self):
+        self._test_compute_api('stop_instance', 'call',
+                instance=self.fake_instance)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('stop_instance', 'call',
                 instance=self.fake_instance, version='2.29')
 
     def test_suspend_instance(self):
         self._test_compute_api('suspend_instance', 'cast',
-                               instance=self.fake_instance,
-                               version='2.33')
+                               instance=self.fake_instance)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('suspend_instance', 'cast',
+                               instance=self.fake_instance, version='2.33')
 
     def test_terminate_instance(self):
         self._test_compute_api('terminate_instance', 'cast',
                 instance=self.fake_instance, bdms=[],
-                reservations=['uuid1', 'uuid2'],
-                version='2.35')
+                reservations=['uuid1', 'uuid2'])
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('terminate_instance', 'cast',
+                instance=self.fake_instance, bdms=[],
+                reservations=['uuid1', 'uuid2'], version='2.35')
 
     def test_unpause_instance(self):
         self._test_compute_api('unpause_instance', 'cast',
-                               instance=self.fake_instance,
-                               version='2.36')
+                               instance=self.fake_instance)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('unpause_instance', 'cast',
+                               instance=self.fake_instance, version='2.36')
 
     def test_unrescue_instance(self):
         self._test_compute_api('unrescue_instance', 'cast',
                 instance=self.fake_instance)
 
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
+        self._test_compute_api('unrescue_instance', 'cast',
+                instance=self.fake_instance, version='2.0')
+
     def test_shelve_instance(self):
+        self._test_compute_api('shelve_instance', 'cast',
+                instance=self.fake_instance, image_id='image_id')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('shelve_instance', 'cast',
                 instance=self.fake_instance, image_id='image_id',
                 version='2.31')
 
     def test_shelve_offload_instance(self):
+        self._test_compute_api('shelve_offload_instance', 'cast',
+                instance=self.fake_instance)
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('shelve_offload_instance', 'cast',
                 instance=self.fake_instance, version='2.31')
 
     def test_unshelve_instance(self):
+        self._test_compute_api('unshelve_instance', 'cast',
+                instance=self.fake_instance, host='host', image='image')
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('unshelve_instance', 'cast',
                 instance=self.fake_instance, host='host', image='image',
                 version='2.31')
 
     def test_volume_snapshot_create(self):
+        self._test_compute_api('volume_snapshot_create', 'cast',
+                instance=self.fake_instance, volume_id='fake_id',
+                create_info={})
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('volume_snapshot_create', 'cast',
                 instance=self.fake_instance, volume_id='fake_id',
                 create_info={}, version='2.44')
 
     def test_volume_snapshot_delete(self):
+        self._test_compute_api('volume_snapshot_delete', 'cast',
+                instance=self.fake_instance, volume_id='fake_id',
+                snapshot_id='fake_id2', delete_info={})
+
+        # NOTE(russellb) Havana compat
+        self.flags(compute='havana', group='upgrade_levels')
         self._test_compute_api('volume_snapshot_delete', 'cast',
                 instance=self.fake_instance, volume_id='fake_id',
                 snapshot_id='fake_id2', delete_info={}, version='2.44')