From 6ac1a84614dc6611591cb1f1ec8cce737972d069 Mon Sep 17 00:00:00 2001 From: Mark McLoughlin Date: Tue, 28 Aug 2012 17:58:41 +0100 Subject: Add version 2.0 of compute RPC API RPC API versioning is helpful because (a) it gives useful error messages if there is a version mismatch and (b) it allows you to update to a new version of the API on the server side before updating the client side. However, we still regularly encounter DB changes which force the client and server side to be updated together. This will not be resolved until no-db-compute is fully implemented. It's safe to say that RPC API clients using version 1.0 will not work with a version 1.44 compute manager (because of DB schema changes). The issue, then, is that continuing to support 1.0 clients in the Folsom release seems pointless and the alternative of removing legacy RPC API support would mean a lot less cruft code in the release. Before removing version 1.x of the compute RPC API, we add version 2.0 while still retaining 1.x support. This gives users the option of upgrading all compute RPC API users to use version 2.0 before version 1.x support is removed from compute nodes. Change-Id: I1c74b36a84d770b0af5ca33062e069a545537ee2 --- nova/compute/api.py | 6 - nova/compute/manager.py | 413 +++++++++++++++++++++++++++++++++ nova/compute/rpcapi.py | 148 ++++-------- nova/tests/compute/test_compute.py | 24 +- nova/tests/compute/test_rpcapi.py | 97 ++++---- nova/tests/scheduler/test_scheduler.py | 2 +- 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 39d6bfe41..db5e36c7a 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.""" @@ -3068,3 +3078,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, -- cgit