openstack/nova
Code Issues Proposed changes

Merge "Clean up ClientRouter debt"

Browse Source
This commit is contained in:
Jenkins
2017-04-25 23:24:22 +00:00
committed by Gerrit Code Review
parent eeb1bfcec8 faa65728bb
commit 671eb66f3d
4 changed files with 84 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
nova/compute/rpcapi.py
View File

@@ -400,7 +400,7 @@ class ComputeAPI(object):
:param host: This is the host to send the message to.
'''
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
cctxt.cast(ctxt, 'add_aggregate_host',
aggregate=aggregate, host=host_param,
@@ -408,7 +408,7 @@ class ComputeAPI(object):
def add_fixed_ip_to_instance(self, ctxt, instance, network_id):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'add_fixed_ip_to_instance',
instance=instance, network_id=network_id)
@@ -416,7 +416,7 @@ class ComputeAPI(object):
def attach_interface(self, ctxt, instance, network_id, port_id,
requested_ip):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'attach_interface',
instance=instance, network_id=network_id,
@@ -424,13 +424,13 @@ class ComputeAPI(object):
def attach_volume(self, ctxt, instance, bdm):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'attach_volume', instance=instance, bdm=bdm)
def change_instance_metadata(self, ctxt, instance, diff):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'change_instance_metadata',
instance=instance, diff=diff)
@@ -438,7 +438,7 @@ class ComputeAPI(object):
def check_can_live_migrate_destination(self, ctxt, instance, destination,
block_migration, disk_over_commit):
version = '4.11'
client = self.router.by_host(ctxt, destination)
client = self.router.client(ctxt)
if not client.can_send_version(version):
# NOTE(eliqiao): This is a new feature that is only available
# once all compute nodes support at least version 4.11.
@@ -466,7 +466,7 @@ class ComputeAPI(object):
def check_can_live_migrate_source(self, ctxt, instance, dest_check_data):
dest_check_data_obj = dest_check_data
version = '4.8'
client = self.router.by_instance(ctxt, instance)
client = self.router.client(ctxt)
if not client.can_send_version(version):
version = '4.0'
if dest_check_data:
@@ -486,11 +486,7 @@ class ComputeAPI(object):
def check_instance_shared_storage(self, ctxt, instance, data, host=None):
version = '4.0'
if not host:
client = self.router.by_instance(ctxt, instance)
else:
client = self.router.by_host(ctxt, host)
cctxt = client.prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(host, instance), version=version)
return cctxt.call(ctxt, 'check_instance_shared_storage',
instance=instance,
@@ -499,11 +495,7 @@ class ComputeAPI(object):
def confirm_resize(self, ctxt, instance, migration, host,
reservations=None, cast=True):
version = '4.0'
if not host:
client = self.router.by_instance(ctxt, instance)
else:
client = self.router.by_host(ctxt, host)
cctxt = client.prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(host, instance), version=version)
rpc_method = cctxt.cast if cast else cctxt.call
return rpc_method(ctxt, 'confirm_resize',
@@ -512,7 +504,7 @@ class ComputeAPI(object):
def detach_interface(self, ctxt, instance, port_id):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'detach_interface',
instance=instance, port_id=port_id)
@@ -520,7 +512,7 @@ class ComputeAPI(object):
def detach_volume(self, ctxt, instance, volume_id, attachment_id=None):
extra = {'attachment_id': attachment_id}
version = '4.7'
client = self.router.by_instance(ctxt, instance)
client = self.router.client(ctxt)
if not client.can_send_version(version):
version = '4.0'
extra.pop('attachment_id')
@@ -532,7 +524,7 @@ class ComputeAPI(object):
def finish_resize(self, ctxt, instance, migration, image, disk_info,
host, reservations=None):
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
cctxt.cast(ctxt, 'finish_resize',
instance=instance, migration=migration,
@@ -541,7 +533,7 @@ class ComputeAPI(object):
def finish_revert_resize(self, ctxt, instance, migration, host,
reservations=None):
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
cctxt.cast(ctxt, 'finish_revert_resize',
instance=instance, migration=migration,
@@ -549,33 +541,33 @@ class ComputeAPI(object):
def get_console_output(self, ctxt, instance, tail_length):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_console_output',
instance=instance, tail_length=tail_length)
def get_console_pool_info(self, ctxt, host, console_type):
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
return cctxt.call(ctxt, 'get_console_pool_info',
console_type=console_type)
def get_console_topic(self, ctxt, host):
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
return cctxt.call(ctxt, 'get_console_topic')
def get_diagnostics(self, ctxt, instance):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_diagnostics', instance=instance)
def get_instance_diagnostics(self, ctxt, instance):
version = '4.13'
client = self.router.by_instance(ctxt, instance)
client = self.router.client(ctxt)
if not client.can_send_version(version):
version = '4.0'
instance = objects_base.obj_to_primitive(instance)
@@ -585,42 +577,42 @@ class ComputeAPI(object):
def get_vnc_console(self, ctxt, instance, console_type):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_vnc_console',
instance=instance, console_type=console_type)
def get_spice_console(self, ctxt, instance, console_type):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_spice_console',
instance=instance, console_type=console_type)
def get_rdp_console(self, ctxt, instance, console_type):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_rdp_console',
instance=instance, console_type=console_type)
def get_mks_console(self, ctxt, instance, console_type):
version = '4.3'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_mks_console',
instance=instance, console_type=console_type)
def get_serial_console(self, ctxt, instance, console_type):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_serial_console',
instance=instance, console_type=console_type)
def validate_console_port(self, ctxt, instance, port, console_type):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'validate_console_port',
instance=instance, port=port,
@@ -636,20 +628,20 @@ class ComputeAPI(object):
:param host: This is the host to send the message to.
'''
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
return cctxt.call(ctxt, 'host_maintenance_mode',
host=host_param, mode=mode)
def host_power_action(self, ctxt, host, action):
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
return cctxt.call(ctxt, 'host_power_action', action=action)
def inject_network_info(self, ctxt, instance):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'inject_network_info', instance=instance)
@@ -657,7 +649,7 @@ class ComputeAPI(object):
migration, migrate_data=None):
args = {'migration': migration}
version = '4.8'
client = self.router.by_host(ctxt, host)
client = self.router.client(ctxt)
if not client.can_send_version(version):
version = '4.2'
if migrate_data:
@@ -674,10 +666,7 @@ class ComputeAPI(object):
def live_migration_force_complete(self, ctxt, instance, migration):
version = '4.12'
kwargs = {}
if not migration.source_compute:
client = self.router.by_instance(ctxt, instance)
else:
client = self.router.by_host(ctxt, migration.source_compute)
client = self.router.client(ctxt)
if not client.can_send_version(version):
version = '4.9'
kwargs['migration_id'] = migration.id
@@ -689,21 +678,21 @@ class ComputeAPI(object):
def live_migration_abort(self, ctxt, instance, migration_id):
version = '4.10'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'live_migration_abort', instance=instance,
migration_id=migration_id)
def pause_instance(self, ctxt, instance):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'pause_instance', instance=instance)
def post_live_migration_at_destination(self, ctxt, instance,
block_migration, host):
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
return cctxt.call(ctxt, 'post_live_migration_at_destination',
instance=instance, block_migration=block_migration)
@@ -712,7 +701,7 @@ class ComputeAPI(object):
host, migrate_data=None):
migrate_data_orig = migrate_data
version = '4.8'
client = self.router.by_host(ctxt, host)
client = self.router.client(ctxt)
if not client.can_send_version(version):
version = '4.0'
if migrate_data:
@@ -745,7 +734,7 @@ class ComputeAPI(object):
'node': node,
'clean_shutdown': clean_shutdown}
version = '4.1'
client = self.router.by_host(ctxt, host)
client = self.router.client(ctxt)
if not client.can_send_version(version):
version = '4.0'
msg_args['instance_type'] = objects_base.obj_to_primitive(
@@ -756,7 +745,7 @@ class ComputeAPI(object):
def reboot_instance(self, ctxt, instance, block_device_info,
reboot_type):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'reboot_instance',
instance=instance,
@@ -775,10 +764,7 @@ class ComputeAPI(object):
'scheduled_node': node,
'limits': limits}
version = '4.5'
if not host:
client = self.router.by_instance(ctxt, instance)
else:
client = self.router.by_host(ctxt, host)
client = self.router.client(ctxt)
if not client.can_send_version(version):
version = '4.0'
extra.pop('migration')
@@ -805,7 +791,7 @@ class ComputeAPI(object):
:param host: This is the host to send the message to.
'''
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
cctxt.cast(ctxt, 'remove_aggregate_host',
aggregate=aggregate, host=host_param,
@@ -813,14 +799,14 @@ class ComputeAPI(object):
def remove_fixed_ip_from_instance(self, ctxt, instance, address):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'remove_fixed_ip_from_instance',
instance=instance, address=address)
def remove_volume_connection(self, ctxt, instance, volume_id, host):
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
return cctxt.call(ctxt, 'remove_volume_connection',
instance=instance, volume_id=volume_id)
@@ -833,13 +819,13 @@ class ComputeAPI(object):
'rescue_image_ref': rescue_image_ref,
'instance': instance,
}
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'rescue_instance', **msg_args)
def reset_network(self, ctxt, instance):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'reset_network', instance=instance)
@@ -851,7 +837,7 @@ class ComputeAPI(object):
'clean_shutdown': clean_shutdown,
}
version = '4.1'
client = self.router.by_instance(ctxt, instance)
client = self.router.client(ctxt)
if not client.can_send_version(version):
msg_args['instance_type'] = objects_base.obj_to_primitive(
instance_type)
@@ -862,18 +848,14 @@ class ComputeAPI(object):
def resume_instance(self, ctxt, instance):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'resume_instance', instance=instance)
def revert_resize(self, ctxt, instance, migration, host,
reservations=None):
version = '4.0'
if not host:
client = self.router.by_instance(ctxt, instance)
else:
client = self.router.by_host(ctxt, host)
cctxt = client.prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(host, instance), version=version)
cctxt.cast(ctxt, 'revert_resize',
instance=instance, migration=migration,
@@ -883,7 +865,7 @@ class ComputeAPI(object):
destroy_disks=True,
migrate_data=None):
version = '4.8'
client = self.router.by_host(ctxt, host)
client = self.router.client(ctxt)
if not client.can_send_version(version):
version = '4.0'
if migrate_data:
@@ -897,20 +879,20 @@ class ComputeAPI(object):
def set_admin_password(self, ctxt, instance, new_pass):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'set_admin_password',
instance=instance, new_pass=new_pass)
def set_host_enabled(self, ctxt, host, enabled):
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).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):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'swap_volume',
instance=instance, old_volume_id=old_volume_id,
@@ -918,7 +900,7 @@ class ComputeAPI(object):
def get_host_uptime(self, ctxt, host):
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
return cctxt.call(ctxt, 'get_host_uptime')
@@ -929,14 +911,14 @@ class ComputeAPI(object):
'device_type': device_type}
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'reserve_block_device_name', **kw)
def backup_instance(self, ctxt, instance, image_id, backup_type,
rotation):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'backup_instance',
instance=instance,
@@ -946,7 +928,7 @@ class ComputeAPI(object):
def snapshot_instance(self, ctxt, instance, image_id):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'snapshot_instance',
instance=instance,
@@ -954,7 +936,7 @@ class ComputeAPI(object):
def start_instance(self, ctxt, instance):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'start_instance', instance=instance)
@@ -962,14 +944,14 @@ class ComputeAPI(object):
msg_args = {'instance': instance,
'clean_shutdown': clean_shutdown}
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
rpc_method = cctxt.cast if do_cast else cctxt.call
return rpc_method(ctxt, 'stop_instance', **msg_args)
def suspend_instance(self, ctxt, instance):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'suspend_instance', instance=instance)
@@ -979,7 +961,7 @@ class ComputeAPI(object):
# the method signature has to match with `terminate_instance()`
# method of cells rpcapi.
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'terminate_instance',
instance=instance, bdms=bdms,
@@ -987,26 +969,26 @@ class ComputeAPI(object):
def unpause_instance(self, ctxt, instance):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'unpause_instance', instance=instance)
def unrescue_instance(self, ctxt, instance):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'unrescue_instance', instance=instance)
def soft_delete_instance(self, ctxt, instance, reservations=None):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'soft_delete_instance',
instance=instance, reservations=reservations)
def restore_instance(self, ctxt, instance):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'restore_instance', instance=instance)
@@ -1015,7 +997,7 @@ class ComputeAPI(object):
msg_args = {'instance': instance, 'image_id': image_id,
'clean_shutdown': clean_shutdown}
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'shelve_instance', **msg_args)
@@ -1023,7 +1005,7 @@ class ComputeAPI(object):
clean_shutdown=True):
msg_args = {'instance': instance, 'clean_shutdown': clean_shutdown}
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'shelve_offload_instance', **msg_args)
@@ -1036,14 +1018,14 @@ class ComputeAPI(object):
'filter_properties': filter_properties,
'node': node,
}
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
cctxt.cast(ctxt, 'unshelve_instance', **msg_kwargs)
def volume_snapshot_create(self, ctxt, instance, volume_id,
create_info):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'volume_snapshot_create', instance=instance,
volume_id=volume_id, create_info=create_info)
@@ -1051,7 +1033,7 @@ class ComputeAPI(object):
def volume_snapshot_delete(self, ctxt, instance, volume_id, snapshot_id,
delete_info):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'volume_snapshot_delete', instance=instance,
volume_id=volume_id, snapshot_id=snapshot_id,
@@ -1059,7 +1041,7 @@ class ComputeAPI(object):
def external_instance_event(self, ctxt, instances, events, host=None):
instance = instances[0]
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(host, instance),
version='4.0')
cctxt.cast(ctxt, 'external_instance_event', instances=instances,
@@ -1071,7 +1053,7 @@ class ComputeAPI(object):
block_device_mapping=None, node=None, limits=None):
version = '4.0'
cctxt = self.router.by_host(ctxt, host).prepare(
cctxt = self.router.client(ctxt).prepare(
server=host, version=version)
cctxt.cast(ctxt, 'build_and_run_instance', instance=instance,
image=image, request_spec=request_spec,
@@ -1085,20 +1067,20 @@ class ComputeAPI(object):
def quiesce_instance(self, ctxt, instance):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'quiesce_instance', instance=instance)
def unquiesce_instance(self, ctxt, instance, mapping=None):
version = '4.0'
cctxt = self.router.by_instance(ctxt, instance).prepare(
cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'unquiesce_instance', instance=instance,
mapping=mapping)
def refresh_instance_security_rules(self, ctxt, instance, host):
version = '4.4'
client = self.router.by_instance(ctxt, instance)
client = self.router.client(ctxt)
if not client.can_send_version(version):
version = '4.0'
instance = objects_base.obj_to_primitive(instance)
@@ -1109,7 +1091,7 @@ class ComputeAPI(object):
def trigger_crash_dump(self, ctxt, instance):
version = '4.6'
client = self.router.by_instance(ctxt, instance)
client = self.router.client(ctxt)
if not client.can_send_version(version):
raise exception.TriggerCrashDumpNotSupported()

17
nova/rpc.py
View File

@@ -410,24 +410,11 @@ class ClientRouter(periodic_task.PeriodicTasks):
# Prevent this empty context from overwriting the thread local copy
self.run_periodic_tasks(nova.context.RequestContext(overwrite=False))
def _client(self, context, transport=None):
def client(self, context):
transport = context.mq_connection
if transport:
return messaging.RPCClient(transport, self.target,
version_cap=self.version_cap,
serializer=self.serializer)
else:
return self.default_client
def by_instance(self, context, instance):
"""Deprecated."""
if context.mq_connection:
return self._client(context, transport=context.mq_connection)
else:
return self.default_client
def by_host(self, context, host):
"""Deprecated."""
if context.mq_connection:
return self._client(context, transport=context.mq_connection)
else:
return self.default_client

32
nova/tests/unit/compute/test_rpcapi.py
View File

@@ -225,9 +225,9 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
rpcapi = compute_rpcapi.ComputeAPI()
cast_mock = mock.Mock()
cctxt_mock = mock.Mock(cast=cast_mock)
rpcapi.router.by_instance = mock.Mock()
rpcapi.router.client = mock.Mock()
mock_client = mock.Mock()
rpcapi.router.by_instance.return_value = mock_client
rpcapi.router.client.return_value = mock_client
with test.nested(
mock.patch.object(mock_client, 'can_send_version',
return_value=False),
@@ -335,9 +335,9 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
ctxt = context.RequestContext('fake_user', 'fake_project')
version = '4.12'
rpcapi = compute_rpcapi.ComputeAPI()
rpcapi.router.by_host = mock.Mock()
rpcapi.router.client = mock.Mock()
mock_client = mock.MagicMock()
rpcapi.router.by_host.return_value = mock_client
rpcapi.router.client.return_value = mock_client
mock_client.can_send_version.return_value = True
mock_cctx = mock.MagicMock()
mock_client.prepare.return_value = mock_cctx
@@ -356,9 +356,9 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
version = '4.9'
ctxt = context.RequestContext('fake_user', 'fake_project')
rpcapi = compute_rpcapi.ComputeAPI()
rpcapi.router.by_host = mock.Mock()
rpcapi.router.client = mock.Mock()
mock_client = mock.MagicMock()
rpcapi.router.by_host.return_value = mock_client
rpcapi.router.client.return_value = mock_client
mock_client.can_send_version.return_value = False
mock_cctx = mock.MagicMock()
mock_client.prepare.return_value = mock_cctx
@@ -625,10 +625,8 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
calltype='call', can_send=False):
rpc = compute_rpcapi.ComputeAPI()
mock_client = mock.Mock()
rpc.router.by_instance = mock.Mock()
rpc.router.by_instance.return_value = mock_client
rpc.router.by_host = mock.Mock()
rpc.router.by_host.return_value = mock_client
rpc.router.client = mock.Mock()
rpc.router.client.return_value = mock_client
@mock.patch.object(compute_rpcapi, '_compute_host')
def _test(mock_ch):
@@ -638,19 +636,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
ctxt = context.RequestContext()
result = getattr(rpc, method)(ctxt, **inargs)
call.assert_called_once_with(ctxt, method, **callargs)
# Get the target of the prepare call: prepare(server=<target>, ...)
prepare_target = mock_client.prepare.call_args[1]['server']
# If _compute_host(None, instance) was called, then by_instance
# should have been called with the instance. Otherwise by_host
# should have been called with the same host as the prepare target.
if mock_ch.called and mock_ch.call_args[0][0] is None:
instance = mock_ch.call_args[0][1]
rpc.router.by_instance.assert_called_once_with(ctxt, instance)
rpc.router.by_host.assert_not_called()
else:
rpc.router.by_host.assert_called_once_with(ctxt,
prepare_target)
rpc.router.by_instance.assert_not_called()
rpc.router.client.assert_called_once_with(ctxt)
return result
return _test()

43
nova/tests/unit/test_rpc.py
View File

@@ -21,10 +21,8 @@ from oslo_serialization import jsonutils
import testtools
from nova import context
from nova import objects
from nova import rpc
from nova import test
from nova.tests import uuidsentinel as uuids
# Make a class that resets all of the global variables in nova.rpc
@@ -465,10 +463,9 @@ class TestClientRouter(test.NoDBTestCase):
mock_rpcclient.return_value = cell_client
ctxt = mock.Mock()
ctxt.mq_connection = mock.sentinel.transport
instance = objects.Instance(uuid=uuids.instance)
router = rpc.ClientRouter(default_client)
client = router.by_instance(ctxt, instance)
client = router.client(ctxt)
# verify a client was created by ClientRouter
mock_rpcclient.assert_called_once_with(
@@ -485,45 +482,9 @@ class TestClientRouter(test.NoDBTestCase):
mock_rpcclient.return_value = cell_client
ctxt = mock.Mock()
ctxt.mq_connection = None
instance = objects.Instance(uuid=uuids.instance)
router = rpc.ClientRouter(default_client)
client = router.by_instance(ctxt, instance)
self.assertEqual(router.default_client, client)
self.assertFalse(mock_rpcclient.called)
@mock.patch('oslo_messaging.RPCClient')
def test_by_host(self, mock_rpcclient):
default_client = mock.Mock()
cell_client = mock.Mock()
mock_rpcclient.return_value = cell_client
ctxt = mock.Mock()
ctxt.mq_connection = mock.sentinel.transport
host = 'fake-host'
router = rpc.ClientRouter(default_client)
client = router.by_host(ctxt, host)
# verify a client was created by ClientRouter
mock_rpcclient.assert_called_once_with(
mock.sentinel.transport, default_client.target,
version_cap=default_client.version_cap,
serializer=default_client.serializer)
# verify cell client was returned
self.assertEqual(cell_client, client)
@mock.patch('oslo_messaging.RPCClient')
def test_by_host_untargeted(self, mock_rpcclient):
default_client = mock.Mock()
cell_client = mock.Mock()
mock_rpcclient.return_value = cell_client
ctxt = mock.Mock()
ctxt.mq_connection = None
host = 'fake-host'
router = rpc.ClientRouter(default_client)
client = router.by_host(ctxt, host)
client = router.client(ctxt)
self.assertEqual(router.default_client, client)
self.assertFalse(mock_rpcclient.called)