openstack
/
nova
Code Issues Proposed changes

Compute RPC client bump to 5.0 

This adds the usual compatibility logic for allowing 5.0 and 4.x for a
version-spanning release. This also adds a queens version alias.

Change-Id: I98dc2a588ee9ddfe0c4d8ce1d7fe59f1fc9e9fa8
This commit is contained in:
Dan Smith 2018-02-05 14:10:53 -08:00
parent 00341ff6e0
commit eae37a27ca
5 changed files with 247 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

283
nova/compute/rpcapi.py
View File

@ -341,6 +341,13 @@ class ComputeAPI(object):
* 4.21 - prep_resize() now gets a 'host_list' parameter representing * 4.21 - prep_resize() now gets a 'host_list' parameter representing
potential alternate hosts for retries within a cell. potential alternate hosts for retries within a cell.
* 4.22 - Add request_spec to rebuild_instance() * 4.22 - Add request_spec to rebuild_instance()
... Version 5.0 is functionally equivalent to 4.22, aside from
removing deprecated parameters. Queens sends 5.0 by default,
can accept 4.x calls from Pike nodes, and can be pinned to 4.x
for Pike compatibility. All new changes should go against 5.x.
* 5.0 - Remove 4.x compatibility
''' '''
VERSION_ALIASES = { VERSION_ALIASES = {
@ -352,11 +359,12 @@ class ComputeAPI(object):
'newton': '4.13', 'newton': '4.13',
'ocata': '4.13', 'ocata': '4.13',
'pike': '4.18', 'pike': '4.18',
'queens': '5.0',
} }
def __init__(self): def __init__(self):
super(ComputeAPI, self).__init__() super(ComputeAPI, self).__init__()
target = messaging.Target(topic=RPC_TOPIC, version='4.0') target = messaging.Target(topic=RPC_TOPIC, version='5.0')
upgrade_level = CONF.upgrade_levels.compute upgrade_level = CONF.upgrade_levels.compute
if upgrade_level == 'auto': if upgrade_level == 'auto':
version_cap = self._determine_version_cap(target) version_cap = self._determine_version_cap(target)
@ -367,6 +375,24 @@ class ComputeAPI(object):
default_client = self.get_client(target, version_cap, serializer) default_client = self.get_client(target, version_cap, serializer)
self.router = rpc.ClientRouter(default_client) self.router = rpc.ClientRouter(default_client)
def _ver(self, ctxt, old):
"""Determine compatibility version.
This is to be used when we could send either the current major or
a revision of the previous major when they are equivalent. This
should only be used by calls that are the exact same in the current
and previous major versions. Returns either old, or the current major
version.
:param old: The version under the previous major version that should
be sent if we're pinned to it.
"""
client = self.router.client(ctxt)
if client.can_send_version('5.0'):
return '5.0'
else:
return old
def _determine_version_cap(self, target): def _determine_version_cap(self, target):
global LAST_VERSION global LAST_VERSION
if LAST_VERSION: if LAST_VERSION:
@ -422,7 +448,7 @@ class ComputeAPI(object):
parameter for the remote method. parameter for the remote method.
:param host: This is the host to send the message to. :param host: This is the host to send the message to.
''' '''
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=host, version=version) server=host, version=version)
cctxt.cast(ctxt, 'add_aggregate_host', cctxt.cast(ctxt, 'add_aggregate_host',
@ -430,7 +456,7 @@ class ComputeAPI(object):
slave_info=slave_info) slave_info=slave_info)
def add_fixed_ip_to_instance(self, ctxt, instance, network_id): def add_fixed_ip_to_instance(self, ctxt, instance, network_id):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'add_fixed_ip_to_instance', cctxt.cast(ctxt, 'add_fixed_ip_to_instance',
@ -441,7 +467,7 @@ class ComputeAPI(object):
kw = {'instance': instance, 'network_id': network_id, kw = {'instance': instance, 'network_id': network_id,
'port_id': port_id, 'requested_ip': requested_ip, 'port_id': port_id, 'requested_ip': requested_ip,
'tag': tag} 'tag': tag}
version = '4.16' version = self._ver(ctxt, '4.16')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
@ -459,13 +485,13 @@ class ComputeAPI(object):
return cctxt.call(ctxt, 'attach_interface', **kw) return cctxt.call(ctxt, 'attach_interface', **kw)
def attach_volume(self, ctxt, instance, bdm): def attach_volume(self, ctxt, instance, bdm):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'attach_volume', instance=instance, bdm=bdm) cctxt.cast(ctxt, 'attach_volume', instance=instance, bdm=bdm)
def change_instance_metadata(self, ctxt, instance, diff): def change_instance_metadata(self, ctxt, instance, diff):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'change_instance_metadata', cctxt.cast(ctxt, 'change_instance_metadata',
@ -473,7 +499,7 @@ class ComputeAPI(object):
def check_can_live_migrate_destination(self, ctxt, instance, destination, def check_can_live_migrate_destination(self, ctxt, instance, destination,
block_migration, disk_over_commit): block_migration, disk_over_commit):
version = '4.11' version = self._ver(ctxt, '4.11')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
# NOTE(eliqiao): This is a new feature that is only available # NOTE(eliqiao): This is a new feature that is only available
@ -501,7 +527,7 @@ class ComputeAPI(object):
def check_can_live_migrate_source(self, ctxt, instance, dest_check_data): def check_can_live_migrate_source(self, ctxt, instance, dest_check_data):
dest_check_data_obj = dest_check_data dest_check_data_obj = dest_check_data
version = '4.8' version = self._ver(ctxt, '4.8')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
version = '4.0' version = '4.0'
@ -521,27 +547,32 @@ class ComputeAPI(object):
return result return result
def check_instance_shared_storage(self, ctxt, instance, data, host=None): def check_instance_shared_storage(self, ctxt, instance, data, host=None):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(host, instance), version=version) server=_compute_host(host, instance), version=version)
return cctxt.call(ctxt, 'check_instance_shared_storage', return cctxt.call(ctxt, 'check_instance_shared_storage',
instance=instance, instance=instance,
data=data) data=data)
# TODO(melwitt): Remove the reservations parameter in version 5.0 of the
# RPC API.
def confirm_resize(self, ctxt, instance, migration, host, def confirm_resize(self, ctxt, instance, migration, host,
reservations=None, cast=True): cast=True):
version = '4.0' client = self.router.client(ctxt)
cctxt = self.router.client(ctxt).prepare( # NOTE(danms): We had a deprecation in 5.0, which means we need to
# try to send that, as 4.max is not equivalent for us
version = '5.0'
msg_args = {}
if not client.can_send_version(version):
version = '4.0'
msg_args['reservations'] = None
cctxt = client.prepare(
server=_compute_host(host, instance), version=version) server=_compute_host(host, instance), version=version)
rpc_method = cctxt.cast if cast else cctxt.call rpc_method = cctxt.cast if cast else cctxt.call
return rpc_method(ctxt, 'confirm_resize', return rpc_method(ctxt, 'confirm_resize',
instance=instance, migration=migration, instance=instance, migration=migration,
reservations=reservations) **msg_args)
def detach_interface(self, ctxt, instance, port_id): def detach_interface(self, ctxt, instance, port_id):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'detach_interface', cctxt.cast(ctxt, 'detach_interface',
@ -549,7 +580,7 @@ class ComputeAPI(object):
def detach_volume(self, ctxt, instance, volume_id, attachment_id=None): def detach_volume(self, ctxt, instance, volume_id, attachment_id=None):
extra = {'attachment_id': attachment_id} extra = {'attachment_id': attachment_id}
version = '4.7' version = self._ver(ctxt, '4.7')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
version = '4.0' version = '4.0'
@ -559,56 +590,64 @@ class ComputeAPI(object):
cctxt.cast(ctxt, 'detach_volume', cctxt.cast(ctxt, 'detach_volume',
instance=instance, volume_id=volume_id, **extra) instance=instance, volume_id=volume_id, **extra)
# TODO(melwitt): Remove the reservations parameter in version 5.0 of the def finish_resize(self, ctxt, instance, migration, image, disk_info, host):
# RPC API. client = self.router.client(ctxt)
def finish_resize(self, ctxt, instance, migration, image, disk_info, # NOTE(danms): We had a deprecation in 5.0, which means we need to
host, reservations=None): # try to send that, as 4.max is not equivalent for us
version = '4.0' version = '5.0'
cctxt = self.router.client(ctxt).prepare( msg_args = {}
if not client.can_send_version(version):
version = '4.0'
msg_args['reservations'] = None
cctxt = client.prepare(
server=host, version=version) server=host, version=version)
cctxt.cast(ctxt, 'finish_resize', cctxt.cast(ctxt, 'finish_resize',
instance=instance, migration=migration, instance=instance, migration=migration,
image=image, disk_info=disk_info, reservations=reservations) image=image, disk_info=disk_info, **msg_args)
# TODO(melwitt): Remove the reservations parameter in version 5.0 of the def finish_revert_resize(self, ctxt, instance, migration, host):
# RPC API. client = self.router.client(ctxt)
def finish_revert_resize(self, ctxt, instance, migration, host, # NOTE(danms): We had a deprecation in 5.0, which means we need to
reservations=None): # try to send that, as 4.max is not equivalent for us
version = '4.0' version = '5.0'
cctxt = self.router.client(ctxt).prepare( msg_args = {}
if not client.can_send_version(version):
version = '4.0'
msg_args['reservations'] = None
cctxt = client.prepare(
server=host, version=version) server=host, version=version)
cctxt.cast(ctxt, 'finish_revert_resize', cctxt.cast(ctxt, 'finish_revert_resize',
instance=instance, migration=migration, instance=instance, migration=migration,
reservations=reservations) **msg_args)
def get_console_output(self, ctxt, instance, tail_length): def get_console_output(self, ctxt, instance, tail_length):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_console_output', return cctxt.call(ctxt, 'get_console_output',
instance=instance, tail_length=tail_length) instance=instance, tail_length=tail_length)
def get_console_pool_info(self, ctxt, host, console_type): def get_console_pool_info(self, ctxt, host, console_type):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=host, version=version) server=host, version=version)
return cctxt.call(ctxt, 'get_console_pool_info', return cctxt.call(ctxt, 'get_console_pool_info',
console_type=console_type) console_type=console_type)
def get_console_topic(self, ctxt, host): def get_console_topic(self, ctxt, host):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=host, version=version) server=host, version=version)
return cctxt.call(ctxt, 'get_console_topic') return cctxt.call(ctxt, 'get_console_topic')
def get_diagnostics(self, ctxt, instance): def get_diagnostics(self, ctxt, instance):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_diagnostics', instance=instance) return cctxt.call(ctxt, 'get_diagnostics', instance=instance)
def get_instance_diagnostics(self, ctxt, instance): def get_instance_diagnostics(self, ctxt, instance):
version = '4.14' version = self._ver(ctxt, '4.14')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
# NOTE(snikitin): Since version 4.14 method # NOTE(snikitin): Since version 4.14 method
@ -622,42 +661,42 @@ class ComputeAPI(object):
return cctxt.call(ctxt, 'get_instance_diagnostics', instance=instance) return cctxt.call(ctxt, 'get_instance_diagnostics', instance=instance)
def get_vnc_console(self, ctxt, instance, console_type): def get_vnc_console(self, ctxt, instance, console_type):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_vnc_console', return cctxt.call(ctxt, 'get_vnc_console',
instance=instance, console_type=console_type) instance=instance, console_type=console_type)
def get_spice_console(self, ctxt, instance, console_type): def get_spice_console(self, ctxt, instance, console_type):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_spice_console', return cctxt.call(ctxt, 'get_spice_console',
instance=instance, console_type=console_type) instance=instance, console_type=console_type)
def get_rdp_console(self, ctxt, instance, console_type): def get_rdp_console(self, ctxt, instance, console_type):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_rdp_console', return cctxt.call(ctxt, 'get_rdp_console',
instance=instance, console_type=console_type) instance=instance, console_type=console_type)
def get_mks_console(self, ctxt, instance, console_type): def get_mks_console(self, ctxt, instance, console_type):
version = '4.3' version = self._ver(ctxt, '4.3')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_mks_console', return cctxt.call(ctxt, 'get_mks_console',
instance=instance, console_type=console_type) instance=instance, console_type=console_type)
def get_serial_console(self, ctxt, instance, console_type): def get_serial_console(self, ctxt, instance, console_type):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'get_serial_console', return cctxt.call(ctxt, 'get_serial_console',
instance=instance, console_type=console_type) instance=instance, console_type=console_type)
def validate_console_port(self, ctxt, instance, port, console_type): def validate_console_port(self, ctxt, instance, port, console_type):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'validate_console_port', return cctxt.call(ctxt, 'validate_console_port',
@ -673,20 +712,20 @@ class ComputeAPI(object):
:param mode: :param mode:
:param host: This is the host to send the message to. :param host: This is the host to send the message to.
''' '''
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=host, version=version) server=host, version=version)
return cctxt.call(ctxt, 'host_maintenance_mode', return cctxt.call(ctxt, 'host_maintenance_mode',
host=host_param, mode=mode) host=host_param, mode=mode)
def host_power_action(self, ctxt, host, action): def host_power_action(self, ctxt, host, action):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=host, version=version) server=host, version=version)
return cctxt.call(ctxt, 'host_power_action', action=action) return cctxt.call(ctxt, 'host_power_action', action=action)
def inject_network_info(self, ctxt, instance): def inject_network_info(self, ctxt, instance):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'inject_network_info', instance=instance) cctxt.cast(ctxt, 'inject_network_info', instance=instance)
@ -694,7 +733,7 @@ class ComputeAPI(object):
def live_migration(self, ctxt, instance, dest, block_migration, host, def live_migration(self, ctxt, instance, dest, block_migration, host,
migration, migrate_data=None): migration, migrate_data=None):
args = {'migration': migration} args = {'migration': migration}
version = '4.8' version = self._ver(ctxt, '4.8')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
version = '4.2' version = '4.2'
@ -710,7 +749,7 @@ class ComputeAPI(object):
migrate_data=migrate_data, **args) migrate_data=migrate_data, **args)
def live_migration_force_complete(self, ctxt, instance, migration): def live_migration_force_complete(self, ctxt, instance, migration):
version = '4.12' version = self._ver(ctxt, '4.12')
kwargs = {} kwargs = {}
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
@ -723,21 +762,21 @@ class ComputeAPI(object):
**kwargs) **kwargs)
def live_migration_abort(self, ctxt, instance, migration_id): def live_migration_abort(self, ctxt, instance, migration_id):
version = '4.10' version = self._ver(ctxt, '4.10')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'live_migration_abort', instance=instance, cctxt.cast(ctxt, 'live_migration_abort', instance=instance,
migration_id=migration_id) migration_id=migration_id)
def pause_instance(self, ctxt, instance): def pause_instance(self, ctxt, instance):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'pause_instance', instance=instance) cctxt.cast(ctxt, 'pause_instance', instance=instance)
def post_live_migration_at_destination(self, ctxt, instance, def post_live_migration_at_destination(self, ctxt, instance,
block_migration, host): block_migration, host):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=host, version=version) server=host, version=version)
return cctxt.call(ctxt, 'post_live_migration_at_destination', return cctxt.call(ctxt, 'post_live_migration_at_destination',
@ -746,7 +785,7 @@ class ComputeAPI(object):
def pre_live_migration(self, ctxt, instance, block_migration, disk, def pre_live_migration(self, ctxt, instance, block_migration, disk,
host, migrate_data=None): host, migrate_data=None):
migrate_data_orig = migrate_data migrate_data_orig = migrate_data
version = '4.8' version = self._ver(ctxt, '4.8')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
version = '4.0' version = '4.0'
@ -766,17 +805,14 @@ class ComputeAPI(object):
else: else:
return result return result
# TODO(melwitt): Remove the reservations parameter in version 5.0 of the
# RPC API.
def prep_resize(self, ctxt, instance, image, instance_type, host, def prep_resize(self, ctxt, instance, image, instance_type, host,
migration, reservations=None, request_spec=None, migration, request_spec=None,
filter_properties=None, node=None, filter_properties=None, node=None,
clean_shutdown=True, host_list=None): clean_shutdown=True, host_list=None):
image_p = jsonutils.to_primitive(image) image_p = jsonutils.to_primitive(image)
msg_args = {'instance': instance, msg_args = {'instance': instance,
'instance_type': instance_type, 'instance_type': instance_type,
'image': image_p, 'image': image_p,
'reservations': reservations,
'request_spec': request_spec, 'request_spec': request_spec,
'filter_properties': filter_properties, 'filter_properties': filter_properties,
'node': node, 'node': node,
@ -784,7 +820,12 @@ class ComputeAPI(object):
'clean_shutdown': clean_shutdown, 'clean_shutdown': clean_shutdown,
'host_list': host_list} 'host_list': host_list}
client = self.router.client(ctxt) client = self.router.client(ctxt)
version = '4.21' # NOTE(danms): We had a deprecation in 5.0, which means we need to
# try to send that, as 4.max is not equivalent for us
version = '5.0'
if not client.can_send_version(version):
version = '4.21'
msg_args['reservations'] = None
if not client.can_send_version(version): if not client.can_send_version(version):
version = '4.18' version = '4.18'
del msg_args['host_list'] del msg_args['host_list']
@ -800,7 +841,7 @@ class ComputeAPI(object):
def reboot_instance(self, ctxt, instance, block_device_info, def reboot_instance(self, ctxt, instance, block_device_info,
reboot_type): reboot_type):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'reboot_instance', cctxt.cast(ctxt, 'reboot_instance',
@ -823,7 +864,7 @@ class ComputeAPI(object):
'scheduled_node': node, 'scheduled_node': node,
'limits': limits, 'limits': limits,
'request_spec': request_spec} 'request_spec': request_spec}
version = '4.22' version = self._ver(ctxt, '4.22')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
version = '4.5' version = '4.5'
@ -853,7 +894,7 @@ class ComputeAPI(object):
parameter for the remote method. parameter for the remote method.
:param host: This is the host to send the message to. :param host: This is the host to send the message to.
''' '''
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=host, version=version) server=host, version=version)
cctxt.cast(ctxt, 'remove_aggregate_host', cctxt.cast(ctxt, 'remove_aggregate_host',
@ -861,14 +902,14 @@ class ComputeAPI(object):
slave_info=slave_info) slave_info=slave_info)
def remove_fixed_ip_from_instance(self, ctxt, instance, address): def remove_fixed_ip_from_instance(self, ctxt, instance, address):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'remove_fixed_ip_from_instance', cctxt.cast(ctxt, 'remove_fixed_ip_from_instance',
instance=instance, address=address) instance=instance, address=address)
def remove_volume_connection(self, ctxt, instance, volume_id, host): def remove_volume_connection(self, ctxt, instance, volume_id, host):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=host, version=version) server=host, version=version)
return cctxt.call(ctxt, 'remove_volume_connection', return cctxt.call(ctxt, 'remove_volume_connection',
@ -876,7 +917,7 @@ class ComputeAPI(object):
def rescue_instance(self, ctxt, instance, rescue_password, def rescue_instance(self, ctxt, instance, rescue_password,
rescue_image_ref=None, clean_shutdown=True): rescue_image_ref=None, clean_shutdown=True):
version = '4.0' version = self._ver(ctxt, '4.0')
msg_args = {'rescue_password': rescue_password, msg_args = {'rescue_password': rescue_password,
'clean_shutdown': clean_shutdown, 'clean_shutdown': clean_shutdown,
'rescue_image_ref': rescue_image_ref, 'rescue_image_ref': rescue_image_ref,
@ -887,22 +928,25 @@ class ComputeAPI(object):
cctxt.cast(ctxt, 'rescue_instance', **msg_args) cctxt.cast(ctxt, 'rescue_instance', **msg_args)
def reset_network(self, ctxt, instance): def reset_network(self, ctxt, instance):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'reset_network', instance=instance) cctxt.cast(ctxt, 'reset_network', instance=instance)
# TODO(melwitt): Remove the reservations parameter in version 5.0 of the
# RPC API.
def resize_instance(self, ctxt, instance, migration, image, instance_type, def resize_instance(self, ctxt, instance, migration, image, instance_type,
reservations=None, clean_shutdown=True): clean_shutdown=True):
msg_args = {'instance': instance, 'migration': migration, msg_args = {'instance': instance, 'migration': migration,
'image': image, 'reservations': reservations, 'image': image,
'instance_type': instance_type, 'instance_type': instance_type,
'clean_shutdown': clean_shutdown, 'clean_shutdown': clean_shutdown,
} }
version = '4.1' # NOTE(danms): We had a deprecation in 5.0, which means we need to
# try to send that, as 4.max is not equivalent for us
version = '5.0'
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version):
version = '4.1'
msg_args['reservations'] = None
if not client.can_send_version(version): if not client.can_send_version(version):
msg_args['instance_type'] = objects_base.obj_to_primitive( msg_args['instance_type'] = objects_base.obj_to_primitive(
instance_type) instance_type)
@ -912,24 +956,30 @@ class ComputeAPI(object):
cctxt.cast(ctxt, 'resize_instance', **msg_args) cctxt.cast(ctxt, 'resize_instance', **msg_args)
def resume_instance(self, ctxt, instance): def resume_instance(self, ctxt, instance):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'resume_instance', instance=instance) cctxt.cast(ctxt, 'resume_instance', instance=instance)
def revert_resize(self, ctxt, instance, migration, host, def revert_resize(self, ctxt, instance, migration, host):
reservations=None): client = self.router.client(ctxt)
version = '4.0' # NOTE(danms): We had a deprecation in 5.0, which means we need to
cctxt = self.router.client(ctxt).prepare( # try to send that, as 4.max is not equivalent for us
version = '5.0'
msg_args = {}
if not client.can_send_version(version):
version = '4.0'
msg_args['reservations'] = None
cctxt = client.prepare(
server=_compute_host(host, instance), version=version) server=_compute_host(host, instance), version=version)
cctxt.cast(ctxt, 'revert_resize', cctxt.cast(ctxt, 'revert_resize',
instance=instance, migration=migration, instance=instance, migration=migration,
reservations=reservations) **msg_args)
def rollback_live_migration_at_destination(self, ctxt, instance, host, def rollback_live_migration_at_destination(self, ctxt, instance, host,
destroy_disks=True, destroy_disks=True,
migrate_data=None): migrate_data=None):
version = '4.8' version = self._ver(ctxt, '4.8')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
version = '4.0' version = '4.0'
@ -943,21 +993,21 @@ class ComputeAPI(object):
instance=instance, **extra) instance=instance, **extra)
def set_admin_password(self, ctxt, instance, new_pass): def set_admin_password(self, ctxt, instance, new_pass):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'set_admin_password', return cctxt.call(ctxt, 'set_admin_password',
instance=instance, new_pass=new_pass) instance=instance, new_pass=new_pass)
def set_host_enabled(self, ctxt, host, enabled): def set_host_enabled(self, ctxt, host, enabled):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=host, version=version) server=host, version=version)
return cctxt.call(ctxt, 'set_host_enabled', enabled=enabled) return cctxt.call(ctxt, 'set_host_enabled', enabled=enabled)
def swap_volume(self, ctxt, instance, old_volume_id, new_volume_id, def swap_volume(self, ctxt, instance, old_volume_id, new_volume_id,
new_attachment_id=None): new_attachment_id=None):
version = '4.17' version = self._ver(ctxt, '4.17')
client = self.router.client(ctxt) client = self.router.client(ctxt)
kwargs = dict(instance=instance, kwargs = dict(instance=instance,
old_volume_id=old_volume_id, old_volume_id=old_volume_id,
@ -971,7 +1021,7 @@ class ComputeAPI(object):
cctxt.cast(ctxt, 'swap_volume', **kwargs) cctxt.cast(ctxt, 'swap_volume', **kwargs)
def get_host_uptime(self, ctxt, host): def get_host_uptime(self, ctxt, host):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=host, version=version) server=host, version=version)
return cctxt.call(ctxt, 'get_host_uptime') return cctxt.call(ctxt, 'get_host_uptime')
@ -983,7 +1033,7 @@ class ComputeAPI(object):
'volume_id': volume_id, 'disk_bus': disk_bus, 'volume_id': volume_id, 'disk_bus': disk_bus,
'device_type': device_type, 'tag': tag, 'device_type': device_type, 'tag': tag,
'multiattach': multiattach} 'multiattach': multiattach}
version = '4.20' version = self._ver(ctxt, '4.20')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
@ -1011,7 +1061,7 @@ class ComputeAPI(object):
def backup_instance(self, ctxt, instance, image_id, backup_type, def backup_instance(self, ctxt, instance, image_id, backup_type,
rotation): rotation):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'backup_instance', cctxt.cast(ctxt, 'backup_instance',
@ -1021,7 +1071,7 @@ class ComputeAPI(object):
rotation=rotation) rotation=rotation)
def snapshot_instance(self, ctxt, instance, image_id): def snapshot_instance(self, ctxt, instance, image_id):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'snapshot_instance', cctxt.cast(ctxt, 'snapshot_instance',
@ -1029,7 +1079,7 @@ class ComputeAPI(object):
image_id=image_id) image_id=image_id)
def start_instance(self, ctxt, instance): def start_instance(self, ctxt, instance):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'start_instance', instance=instance) cctxt.cast(ctxt, 'start_instance', instance=instance)
@ -1037,55 +1087,64 @@ class ComputeAPI(object):
def stop_instance(self, ctxt, instance, do_cast=True, clean_shutdown=True): def stop_instance(self, ctxt, instance, do_cast=True, clean_shutdown=True):
msg_args = {'instance': instance, msg_args = {'instance': instance,
'clean_shutdown': clean_shutdown} 'clean_shutdown': clean_shutdown}
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
rpc_method = cctxt.cast if do_cast else cctxt.call rpc_method = cctxt.cast if do_cast else cctxt.call
return rpc_method(ctxt, 'stop_instance', **msg_args) return rpc_method(ctxt, 'stop_instance', **msg_args)
def suspend_instance(self, ctxt, instance): def suspend_instance(self, ctxt, instance):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'suspend_instance', instance=instance) cctxt.cast(ctxt, 'suspend_instance', instance=instance)
# TODO(melwitt): Remove the reservations parameter in version 5.0 of the def terminate_instance(self, ctxt, instance, bdms, delete_type=None):
# RPC API.
def terminate_instance(self, ctxt, instance, bdms, reservations=None,
delete_type=None):
# NOTE(rajesht): The `delete_type` parameter is passed because # NOTE(rajesht): The `delete_type` parameter is passed because
# the method signature has to match with `terminate_instance()` # the method signature has to match with `terminate_instance()`
# method of cells rpcapi. # method of cells rpcapi.
version = '4.0' client = self.router.client(ctxt)
cctxt = self.router.client(ctxt).prepare( # NOTE(danms): We had a deprecation in 5.0, which means we need to
# try to send that, as 4.max is not equivalent for us
version = '5.0'
msg_args = {}
if not client.can_send_version(version):
version = '4.0'
msg_args['reservations'] = None
cctxt = client.prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'terminate_instance', cctxt.cast(ctxt, 'terminate_instance',
instance=instance, bdms=bdms, instance=instance, bdms=bdms,
reservations=reservations) **msg_args)
def unpause_instance(self, ctxt, instance): def unpause_instance(self, ctxt, instance):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'unpause_instance', instance=instance) cctxt.cast(ctxt, 'unpause_instance', instance=instance)
def unrescue_instance(self, ctxt, instance): def unrescue_instance(self, ctxt, instance):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'unrescue_instance', instance=instance) cctxt.cast(ctxt, 'unrescue_instance', instance=instance)
# TODO(melwitt): Remove the reservations parameter in version 5.0 of the def soft_delete_instance(self, ctxt, instance):
# RPC API. client = self.router.client(ctxt)
def soft_delete_instance(self, ctxt, instance, reservations=None): # NOTE(danms): We had a deprecation in 5.0, which means we need to
version = '4.0' # try to send that, as 4.max is not equivalent for us
cctxt = self.router.client(ctxt).prepare( version = '5.0'
msg_args = {}
if not client.can_send_version(version):
version = '4.0'
msg_args['reservations'] = None
cctxt = client.prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'soft_delete_instance', cctxt.cast(ctxt, 'soft_delete_instance',
instance=instance, reservations=reservations) instance=instance, **msg_args)
def restore_instance(self, ctxt, instance): def restore_instance(self, ctxt, instance):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'restore_instance', instance=instance) cctxt.cast(ctxt, 'restore_instance', instance=instance)
@ -1094,7 +1153,7 @@ class ComputeAPI(object):
clean_shutdown=True): clean_shutdown=True):
msg_args = {'instance': instance, 'image_id': image_id, msg_args = {'instance': instance, 'image_id': image_id,
'clean_shutdown': clean_shutdown} 'clean_shutdown': clean_shutdown}
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'shelve_instance', **msg_args) cctxt.cast(ctxt, 'shelve_instance', **msg_args)
@ -1102,14 +1161,14 @@ class ComputeAPI(object):
def shelve_offload_instance(self, ctxt, instance, def shelve_offload_instance(self, ctxt, instance,
clean_shutdown=True): clean_shutdown=True):
msg_args = {'instance': instance, 'clean_shutdown': clean_shutdown} msg_args = {'instance': instance, 'clean_shutdown': clean_shutdown}
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'shelve_offload_instance', **msg_args) cctxt.cast(ctxt, 'shelve_offload_instance', **msg_args)
def unshelve_instance(self, ctxt, instance, host, image=None, def unshelve_instance(self, ctxt, instance, host, image=None,
filter_properties=None, node=None): filter_properties=None, node=None):
version = '4.0' version = self._ver(ctxt, '4.0')
msg_kwargs = { msg_kwargs = {
'instance': instance, 'instance': instance,
'image': image, 'image': image,
@ -1122,7 +1181,7 @@ class ComputeAPI(object):
def volume_snapshot_create(self, ctxt, instance, volume_id, def volume_snapshot_create(self, ctxt, instance, volume_id,
create_info): create_info):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'volume_snapshot_create', instance=instance, cctxt.cast(ctxt, 'volume_snapshot_create', instance=instance,
@ -1130,7 +1189,7 @@ class ComputeAPI(object):
def volume_snapshot_delete(self, ctxt, instance, volume_id, snapshot_id, def volume_snapshot_delete(self, ctxt, instance, volume_id, snapshot_id,
delete_info): delete_info):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'volume_snapshot_delete', instance=instance, cctxt.cast(ctxt, 'volume_snapshot_delete', instance=instance,
@ -1141,7 +1200,7 @@ class ComputeAPI(object):
instance = instances[0] instance = instances[0]
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(host, instance), server=_compute_host(host, instance),
version='4.0') version=self._ver(ctxt, '4.0'))
cctxt.cast(ctxt, 'external_instance_event', instances=instances, cctxt.cast(ctxt, 'external_instance_event', instances=instances,
events=events) events=events)
@ -1167,7 +1226,7 @@ class ComputeAPI(object):
"host_list": host_list, "host_list": host_list,
} }
client = self.router.client(ctxt) client = self.router.client(ctxt)
version = '4.19' version = self._ver(ctxt, '4.19')
if not client.can_send_version(version): if not client.can_send_version(version):
version = '4.0' version = '4.0'
kwargs.pop("host_list") kwargs.pop("host_list")
@ -1175,20 +1234,20 @@ class ComputeAPI(object):
cctxt.cast(ctxt, 'build_and_run_instance', **kwargs) cctxt.cast(ctxt, 'build_and_run_instance', **kwargs)
def quiesce_instance(self, ctxt, instance): def quiesce_instance(self, ctxt, instance):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
return cctxt.call(ctxt, 'quiesce_instance', instance=instance) return cctxt.call(ctxt, 'quiesce_instance', instance=instance)
def unquiesce_instance(self, ctxt, instance, mapping=None): def unquiesce_instance(self, ctxt, instance, mapping=None):
version = '4.0' version = self._ver(ctxt, '4.0')
cctxt = self.router.client(ctxt).prepare( cctxt = self.router.client(ctxt).prepare(
server=_compute_host(None, instance), version=version) server=_compute_host(None, instance), version=version)
cctxt.cast(ctxt, 'unquiesce_instance', instance=instance, cctxt.cast(ctxt, 'unquiesce_instance', instance=instance,
mapping=mapping) mapping=mapping)
def refresh_instance_security_rules(self, ctxt, instance, host): def refresh_instance_security_rules(self, ctxt, instance, host):
version = '4.4' version = self._ver(ctxt, '4.4')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):
version = '4.0' version = '4.0'
@ -1199,7 +1258,7 @@ class ComputeAPI(object):
instance=instance) instance=instance)
def trigger_crash_dump(self, ctxt, instance): def trigger_crash_dump(self, ctxt, instance):
version = '4.6' version = self._ver(ctxt, '4.6')
client = self.router.client(ctxt) client = self.router.client(ctxt)
if not client.can_send_version(version): if not client.can_send_version(version):

2
nova/conductor/tasks/migrate.py
View File

@ -297,7 +297,7 @@ class MigrationTask(base.TaskBase):
# RPC cast to the destination host to start the migration process. # RPC cast to the destination host to start the migration process.
self.compute_rpcapi.prep_resize( self.compute_rpcapi.prep_resize(
self.context, self.instance, legacy_spec['image'], self.context, self.instance, legacy_spec['image'],
self.flavor, host, migration, self.reservations, self.flavor, host, migration,
request_spec=legacy_spec, filter_properties=legacy_props, request_spec=legacy_spec, filter_properties=legacy_props,
node=node, clean_shutdown=self.clean_shutdown, node=node, clean_shutdown=self.clean_shutdown,
host_list=self.host_list) host_list=self.host_list)

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

@ -184,12 +184,12 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_add_fixed_ip_to_instance(self): def test_add_fixed_ip_to_instance(self):
self._test_compute_api('add_fixed_ip_to_instance', 'cast', self._test_compute_api('add_fixed_ip_to_instance', 'cast',
instance=self.fake_instance_obj, network_id='id', instance=self.fake_instance_obj, network_id='id',
version='4.0') version='5.0')
def test_attach_interface(self): def test_attach_interface(self):
self._test_compute_api('attach_interface', 'call', self._test_compute_api('attach_interface', 'call',
instance=self.fake_instance_obj, network_id='id', instance=self.fake_instance_obj, network_id='id',
port_id='id2', version='4.16', requested_ip='192.168.1.50', port_id='id2', version='5.0', requested_ip='192.168.1.50',
tag='foo') tag='foo')
def test_attach_interface_raises(self): def test_attach_interface_raises(self):
@ -212,7 +212,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
rpcapi.attach_interface, ctxt, instance, rpcapi.attach_interface, ctxt, instance,
'fake_network', 'fake_port', 'fake_requested_ip', 'fake_network', 'fake_port', 'fake_requested_ip',
tag='foo') tag='foo')
can_send_mock.assert_called_once_with('4.16') can_send_mock.assert_called_with('4.16')
def test_attach_interface_downgrades_version(self): def test_attach_interface_downgrades_version(self):
ctxt = context.RequestContext('fake_user', 'fake_project') ctxt = context.RequestContext('fake_user', 'fake_project')
@ -234,7 +234,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
rpcapi.attach_interface(ctxt, instance, 'fake_network', rpcapi.attach_interface(ctxt, instance, 'fake_network',
'fake_port', 'fake_requested_ip') 'fake_port', 'fake_requested_ip')
can_send_mock.assert_called_once_with('4.16') can_send_mock.assert_called_with('4.16')
prepare_mock.assert_called_once_with(server=instance['host'], prepare_mock.assert_called_once_with(server=instance['host'],
version='4.0') version='4.0')
call_mock.assert_called_once_with(ctxt, 'attach_interface', call_mock.assert_called_once_with(ctxt, 'attach_interface',
@ -246,36 +246,36 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_attach_volume(self): def test_attach_volume(self):
self._test_compute_api('attach_volume', 'cast', self._test_compute_api('attach_volume', 'cast',
instance=self.fake_instance_obj, bdm=self.fake_volume_bdm, instance=self.fake_instance_obj, bdm=self.fake_volume_bdm,
version='4.0') version='5.0')
def test_change_instance_metadata(self): def test_change_instance_metadata(self):
self._test_compute_api('change_instance_metadata', 'cast', self._test_compute_api('change_instance_metadata', 'cast',
instance=self.fake_instance_obj, diff={}, version='4.0') instance=self.fake_instance_obj, diff={}, version='5.0')
def test_check_instance_shared_storage(self): def test_check_instance_shared_storage(self):
self._test_compute_api('check_instance_shared_storage', 'call', self._test_compute_api('check_instance_shared_storage', 'call',
instance=self.fake_instance_obj, data='foo', instance=self.fake_instance_obj, data='foo',
version='4.0') version='5.0')
def test_confirm_resize_cast(self): def test_confirm_resize_cast(self):
self._test_compute_api('confirm_resize', 'cast', self._test_compute_api('confirm_resize', 'cast',
instance=self.fake_instance_obj, migration={'id': 'foo'}, instance=self.fake_instance_obj, migration={'id': 'foo'},
host='host', reservations=list('fake_res')) host='host')
def test_confirm_resize_call(self): def test_confirm_resize_call(self):
self._test_compute_api('confirm_resize', 'call', self._test_compute_api('confirm_resize', 'call',
instance=self.fake_instance_obj, migration={'id': 'foo'}, instance=self.fake_instance_obj, migration={'id': 'foo'},
host='host', reservations=list('fake_res')) host='host')
def test_detach_interface(self): def test_detach_interface(self):
self._test_compute_api('detach_interface', 'cast', self._test_compute_api('detach_interface', 'cast',
version='4.0', instance=self.fake_instance_obj, version='5.0', instance=self.fake_instance_obj,
port_id='fake_id') port_id='fake_id')
def test_detach_volume(self): def test_detach_volume(self):
self._test_compute_api('detach_volume', 'cast', self._test_compute_api('detach_volume', 'cast',
instance=self.fake_instance_obj, volume_id='id', instance=self.fake_instance_obj, volume_id='id',
attachment_id='fake_id', version='4.7') attachment_id='fake_id', version='5.0')
def test_detach_volume_no_attachment_id(self): def test_detach_volume_no_attachment_id(self):
ctxt = context.RequestContext('fake_user', 'fake_project') ctxt = context.RequestContext('fake_user', 'fake_project')
@ -297,7 +297,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
rpcapi.detach_volume(ctxt, instance=instance, rpcapi.detach_volume(ctxt, instance=instance,
volume_id='id', attachment_id='fake_id') volume_id='id', attachment_id='fake_id')
# assert our mocks were called as expected # assert our mocks were called as expected
can_send_mock.assert_called_once_with('4.7') can_send_mock.assert_called_with('4.7')
prepare_mock.assert_called_once_with(server=instance['host'], prepare_mock.assert_called_once_with(server=instance['host'],
version='4.0') version='4.0')
cast_mock.assert_called_once_with(ctxt, 'detach_volume', cast_mock.assert_called_once_with(ctxt, 'detach_volume',
@ -307,18 +307,17 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_finish_resize(self): def test_finish_resize(self):
self._test_compute_api('finish_resize', 'cast', self._test_compute_api('finish_resize', 'cast',
instance=self.fake_instance_obj, migration={'id': 'foo'}, instance=self.fake_instance_obj, migration={'id': 'foo'},
image='image', disk_info='disk_info', host='host', image='image', disk_info='disk_info', host='host')
reservations=list('fake_res'))
def test_finish_revert_resize(self): def test_finish_revert_resize(self):
self._test_compute_api('finish_revert_resize', 'cast', self._test_compute_api('finish_revert_resize', 'cast',
instance=self.fake_instance_obj, migration={'id': 'fake_id'}, instance=self.fake_instance_obj, migration={'id': 'fake_id'},
host='host', reservations=list('fake_res')) host='host')
def test_get_console_output(self): def test_get_console_output(self):
self._test_compute_api('get_console_output', 'call', self._test_compute_api('get_console_output', 'call',
instance=self.fake_instance_obj, tail_length='tl', instance=self.fake_instance_obj, tail_length='tl',
version='4.0') version='5.0')
def test_get_console_pool_info(self): def test_get_console_pool_info(self):
self._test_compute_api('get_console_pool_info', 'call', self._test_compute_api('get_console_pool_info', 'call',
@ -329,43 +328,43 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_get_diagnostics(self): def test_get_diagnostics(self):
self._test_compute_api('get_diagnostics', 'call', self._test_compute_api('get_diagnostics', 'call',
instance=self.fake_instance_obj, version='4.0') instance=self.fake_instance_obj, version='5.0')
def test_get_instance_diagnostics(self): def test_get_instance_diagnostics(self):
expected_args = {'instance': self.fake_instance_obj} expected_args = {'instance': self.fake_instance_obj}
self._test_compute_api('get_instance_diagnostics', 'call', self._test_compute_api('get_instance_diagnostics', 'call',
expected_args, instance=self.fake_instance_obj, expected_args, instance=self.fake_instance_obj,
version='4.14') version='5.0')
def test_get_vnc_console(self): def test_get_vnc_console(self):
self._test_compute_api('get_vnc_console', 'call', self._test_compute_api('get_vnc_console', 'call',
instance=self.fake_instance_obj, console_type='type', instance=self.fake_instance_obj, console_type='type',
version='4.0') version='5.0')
def test_get_spice_console(self): def test_get_spice_console(self):
self._test_compute_api('get_spice_console', 'call', self._test_compute_api('get_spice_console', 'call',
instance=self.fake_instance_obj, console_type='type', instance=self.fake_instance_obj, console_type='type',
version='4.0') version='5.0')
def test_get_rdp_console(self): def test_get_rdp_console(self):
self._test_compute_api('get_rdp_console', 'call', self._test_compute_api('get_rdp_console', 'call',
instance=self.fake_instance_obj, console_type='type', instance=self.fake_instance_obj, console_type='type',
version='4.0') version='5.0')
def test_get_serial_console(self): def test_get_serial_console(self):
self._test_compute_api('get_serial_console', 'call', self._test_compute_api('get_serial_console', 'call',
instance=self.fake_instance_obj, console_type='serial', instance=self.fake_instance_obj, console_type='serial',
version='4.0') version='5.0')
def test_get_mks_console(self): def test_get_mks_console(self):
self._test_compute_api('get_mks_console', 'call', self._test_compute_api('get_mks_console', 'call',
instance=self.fake_instance_obj, console_type='webmks', instance=self.fake_instance_obj, console_type='webmks',
version='4.3') version='5.0')
def test_validate_console_port(self): def test_validate_console_port(self):
self._test_compute_api('validate_console_port', 'call', self._test_compute_api('validate_console_port', 'call',
instance=self.fake_instance_obj, port="5900", instance=self.fake_instance_obj, port="5900",
console_type="novnc", version='4.0') console_type="novnc", version='5.0')
def test_host_maintenance_mode(self): def test_host_maintenance_mode(self):
self._test_compute_api('host_maintenance_mode', 'call', self._test_compute_api('host_maintenance_mode', 'call',
@ -384,14 +383,14 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
instance=self.fake_instance_obj, dest='dest', instance=self.fake_instance_obj, dest='dest',
block_migration='blockity_block', host='tsoh', block_migration='blockity_block', host='tsoh',
migration='migration', migration='migration',
migrate_data={}, version='4.8') migrate_data={}, version='5.0')
def test_live_migration_force_complete(self): def test_live_migration_force_complete(self):
migration = migration_obj.Migration() migration = migration_obj.Migration()
migration.id = 1 migration.id = 1
migration.source_compute = 'fake' migration.source_compute = 'fake'
ctxt = context.RequestContext('fake_user', 'fake_project') ctxt = context.RequestContext('fake_user', 'fake_project')
version = '4.12' version = '5.0'
rpcapi = compute_rpcapi.ComputeAPI() rpcapi = compute_rpcapi.ComputeAPI()
rpcapi.router.client = mock.Mock() rpcapi.router.client = mock.Mock()
mock_client = mock.MagicMock() mock_client = mock.MagicMock()
@ -432,12 +431,12 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_live_migration_abort(self): def test_live_migration_abort(self):
self._test_compute_api('live_migration_abort', 'cast', self._test_compute_api('live_migration_abort', 'cast',
instance=self.fake_instance_obj, instance=self.fake_instance_obj,
migration_id='1', version='4.10') migration_id='1', version='5.0')
def test_post_live_migration_at_destination(self): def test_post_live_migration_at_destination(self):
self._test_compute_api('post_live_migration_at_destination', 'call', self._test_compute_api('post_live_migration_at_destination', 'call',
instance=self.fake_instance_obj, instance=self.fake_instance_obj,
block_migration='block_migration', host='host', version='4.0') block_migration='block_migration', host='host', version='5.0')
def test_pause_instance(self): def test_pause_instance(self):
self._test_compute_api('pause_instance', 'cast', self._test_compute_api('pause_instance', 'cast',
@ -445,14 +444,13 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_soft_delete_instance(self): def test_soft_delete_instance(self):
self._test_compute_api('soft_delete_instance', 'cast', self._test_compute_api('soft_delete_instance', 'cast',
instance=self.fake_instance_obj, instance=self.fake_instance_obj)
reservations=['uuid1', 'uuid2'])
def test_swap_volume(self): def test_swap_volume(self):
self._test_compute_api('swap_volume', 'cast', self._test_compute_api('swap_volume', 'cast',
instance=self.fake_instance_obj, old_volume_id='oldid', instance=self.fake_instance_obj, old_volume_id='oldid',
new_volume_id='newid', new_attachment_id=uuids.attachment_id, new_volume_id='newid', new_attachment_id=uuids.attachment_id,
version='4.17') version='5.0')
def test_swap_volume_cannot_send_version_4_17(self): def test_swap_volume_cannot_send_version_4_17(self):
"""Tests that if the RPC client cannot send version 4.17 we drop back """Tests that if the RPC client cannot send version 4.17 we drop back
@ -477,13 +475,13 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_restore_instance(self): def test_restore_instance(self):
self._test_compute_api('restore_instance', 'cast', self._test_compute_api('restore_instance', 'cast',
instance=self.fake_instance_obj, version='4.0') instance=self.fake_instance_obj, version='5.0')
def test_pre_live_migration(self): def test_pre_live_migration(self):
self._test_compute_api('pre_live_migration', 'call', self._test_compute_api('pre_live_migration', 'call',
instance=self.fake_instance_obj, instance=self.fake_instance_obj,
block_migration='block_migration', disk='disk', host='host', block_migration='block_migration', disk='disk', host='host',
migrate_data=None, version='4.8') migrate_data=None, version='5.0')
def test_prep_resize(self): def test_prep_resize(self):
expected_args = {'migration': 'migration'} expected_args = {'migration': 'migration'}
@ -491,19 +489,18 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
instance=self.fake_instance_obj, instance=self.fake_instance_obj,
instance_type=self.fake_flavor_obj, instance_type=self.fake_flavor_obj,
image='fake_image', host='host', image='fake_image', host='host',
reservations=list('fake_res'),
request_spec='fake_spec', request_spec='fake_spec',
filter_properties={'fakeprop': 'fakeval'}, filter_properties={'fakeprop': 'fakeval'},
migration='migration', migration='migration',
node='node', clean_shutdown=True, host_list=None, node='node', clean_shutdown=True, host_list=None,
version='4.21') version='5.0')
self.flags(compute='4.0', group='upgrade_levels') self.flags(compute='4.0', group='upgrade_levels')
expected_args = {'instance_type': self.fake_flavor} expected_args = {'instance_type': self.fake_flavor,
'reservations': None}
self._test_compute_api('prep_resize', 'cast', expected_args, self._test_compute_api('prep_resize', 'cast', expected_args,
instance=self.fake_instance_obj, instance=self.fake_instance_obj,
instance_type=self.fake_flavor_obj, instance_type=self.fake_flavor_obj,
image='fake_image', host='host', image='fake_image', host='host',
reservations=list('fake_res'),
request_spec='fake_spec', request_spec='fake_spec',
filter_properties={'fakeprop': 'fakeval'}, filter_properties={'fakeprop': 'fakeval'},
migration='migration', migration='migration',
@ -522,7 +519,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
bdms=[], instance=self.fake_instance_obj, host='new_host', bdms=[], instance=self.fake_instance_obj, host='new_host',
orig_sys_metadata=None, recreate=True, on_shared_storage=True, orig_sys_metadata=None, recreate=True, on_shared_storage=True,
preserve_ephemeral=True, migration=None, node=None, preserve_ephemeral=True, migration=None, node=None,
limits=None, request_spec=None, version='4.22') limits=None, request_spec=None, version='5.0')
def test_rebuild_instance_remove_request_spec(self): def test_rebuild_instance_remove_request_spec(self):
self.flags(group='upgrade_levels', compute='4.21') self.flags(group='upgrade_levels', compute='4.21')
@ -545,7 +542,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
self._test_compute_api('reserve_block_device_name', 'call', self._test_compute_api('reserve_block_device_name', 'call',
instance=self.fake_instance_obj, device='device', instance=self.fake_instance_obj, device='device',
volume_id='id', disk_bus='ide', device_type='cdrom', volume_id='id', disk_bus='ide', device_type='cdrom',
tag='foo', multiattach=True, version='4.20', tag='foo', multiattach=True, version='5.0',
_return_value=objects_block_dev.BlockDeviceMapping()) _return_value=objects_block_dev.BlockDeviceMapping())
def test_reserve_block_device_name_raises(self): def test_reserve_block_device_name_raises(self):
@ -558,7 +555,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
rpcapi.router.client.return_value = mock_client rpcapi.router.client.return_value = mock_client
with test.nested( with test.nested(
mock.patch.object(mock_client, 'can_send_version', mock.patch.object(mock_client, 'can_send_version',
side_effect=[False, False]), side_effect=[False, False, False, False]),
mock.patch.object(mock_client, 'prepare', mock.patch.object(mock_client, 'prepare',
return_value=cctxt_mock) return_value=cctxt_mock)
) as ( ) as (
@ -567,7 +564,8 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
self.assertRaises(exception.TaggedAttachmentNotSupported, self.assertRaises(exception.TaggedAttachmentNotSupported,
rpcapi.reserve_block_device_name, ctxt, instance, rpcapi.reserve_block_device_name, ctxt, instance,
'fake_device', 'fake_volume_id', tag='foo') 'fake_device', 'fake_volume_id', tag='foo')
can_send_calls = [mock.call('4.20'), mock.call('4.15')] can_send_calls = [mock.call('5.0'), mock.call('4.20'),
mock.call('4.15')]
can_send_mock.assert_has_calls(can_send_calls) can_send_mock.assert_has_calls(can_send_calls)
def test_reserve_block_device_name_downgrades_version(self): def test_reserve_block_device_name_downgrades_version(self):
@ -581,7 +579,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
rpcapi.router.client.return_value = mock_client rpcapi.router.client.return_value = mock_client
with test.nested( with test.nested(
mock.patch.object(mock_client, 'can_send_version', mock.patch.object(mock_client, 'can_send_version',
side_effect=[False, False]), side_effect=[False, False, False, False]),
mock.patch.object(mock_client, 'prepare', mock.patch.object(mock_client, 'prepare',
return_value=cctxt_mock) return_value=cctxt_mock)
) as ( ) as (
@ -590,7 +588,8 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
rpcapi.reserve_block_device_name(ctxt, instance, 'fake_device', rpcapi.reserve_block_device_name(ctxt, instance, 'fake_device',
'fake_volume_id') 'fake_volume_id')
can_send_calls = [mock.call('4.20'), mock.call('4.15')] can_send_calls = [mock.call('5.0'), mock.call('4.20'),
mock.call('4.15')]
can_send_mock.assert_has_calls(can_send_calls) can_send_mock.assert_has_calls(can_send_calls)
prepare_mock.assert_called_once_with(server=instance['host'], prepare_mock.assert_called_once_with(server=instance['host'],
version='4.0') version='4.0')
@ -624,7 +623,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
rpcapi.reserve_block_device_name, ctxt, instance, rpcapi.reserve_block_device_name, ctxt, instance,
'fake_device', 'fake_volume_id', 'fake_device', 'fake_volume_id',
multiattach=True) multiattach=True)
can_send_mock.assert_called_once_with('4.20') can_send_mock.assert_has_calls([mock.call('5.0'), mock.call('4.20')])
def test_reserve_block_device_name_downgrades_version_multiattach(self): def test_reserve_block_device_name_downgrades_version_multiattach(self):
"""Tests that if multiattach=False and the compute service is too """Tests that if multiattach=False and the compute service is too
@ -640,7 +639,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
rpcapi.router.client.return_value = mock_client rpcapi.router.client.return_value = mock_client
with test.nested( with test.nested(
mock.patch.object(mock_client, 'can_send_version', mock.patch.object(mock_client, 'can_send_version',
side_effect=[False, True]), side_effect=[False, False, True]),
mock.patch.object(mock_client, 'prepare', mock.patch.object(mock_client, 'prepare',
return_value=cctxt_mock) return_value=cctxt_mock)
) as ( ) as (
@ -649,7 +648,8 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
rpcapi.reserve_block_device_name( rpcapi.reserve_block_device_name(
ctxt, instance, 'fake_device', 'fake_volume_id', tag='foo') ctxt, instance, 'fake_device', 'fake_volume_id', tag='foo')
can_send_calls = [mock.call('4.20'), mock.call('4.15')] can_send_calls = [mock.call('5.0'), mock.call('4.20'),
mock.call('4.15')]
can_send_mock.assert_has_calls(can_send_calls) can_send_mock.assert_has_calls(can_send_calls)
prepare_mock.assert_called_once_with(server=instance['host'], prepare_mock.assert_called_once_with(server=instance['host'],
version='4.15') version='4.15')
@ -662,7 +662,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
expected_args = {'instance': self.fake_instance_obj} expected_args = {'instance': self.fake_instance_obj}
self._test_compute_api('refresh_instance_security_rules', 'cast', self._test_compute_api('refresh_instance_security_rules', 'cast',
expected_args, host='fake_host', expected_args, host='fake_host',
instance=self.fake_instance_obj, version='4.4') instance=self.fake_instance_obj, version='5.0')
def test_remove_aggregate_host(self): def test_remove_aggregate_host(self):
self._test_compute_api('remove_aggregate_host', 'cast', self._test_compute_api('remove_aggregate_host', 'cast',
@ -672,18 +672,18 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_remove_fixed_ip_from_instance(self): def test_remove_fixed_ip_from_instance(self):
self._test_compute_api('remove_fixed_ip_from_instance', 'cast', self._test_compute_api('remove_fixed_ip_from_instance', 'cast',
instance=self.fake_instance_obj, address='addr', instance=self.fake_instance_obj, address='addr',
version='4.0') version='5.0')
def test_remove_volume_connection(self): def test_remove_volume_connection(self):
self._test_compute_api('remove_volume_connection', 'call', self._test_compute_api('remove_volume_connection', 'call',
instance=self.fake_instance_obj, volume_id='id', host='host', instance=self.fake_instance_obj, volume_id='id', host='host',
version='4.0') version='5.0')
def test_rescue_instance(self): def test_rescue_instance(self):
self._test_compute_api('rescue_instance', 'cast', self._test_compute_api('rescue_instance', 'cast',
instance=self.fake_instance_obj, rescue_password='pw', instance=self.fake_instance_obj, rescue_password='pw',
rescue_image_ref='fake_image_ref', rescue_image_ref='fake_image_ref',
clean_shutdown=True, version='4.0') clean_shutdown=True, version='5.0')
def test_reset_network(self): def test_reset_network(self):
self._test_compute_api('reset_network', 'cast', self._test_compute_api('reset_network', 'cast',
@ -693,14 +693,13 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
self._test_compute_api('resize_instance', 'cast', self._test_compute_api('resize_instance', 'cast',
instance=self.fake_instance_obj, migration={'id': 'fake_id'}, instance=self.fake_instance_obj, migration={'id': 'fake_id'},
image='image', instance_type=self.fake_flavor_obj, image='image', instance_type=self.fake_flavor_obj,
reservations=list('fake_res'), clean_shutdown=True, version='5.0')
clean_shutdown=True, version='4.1')
self.flags(compute='4.0', group='upgrade_levels') self.flags(compute='4.0', group='upgrade_levels')
expected_args = {'instance_type': self.fake_flavor} expected_args = {'instance_type': self.fake_flavor,
'reservations': None}
self._test_compute_api('resize_instance', 'cast', expected_args, self._test_compute_api('resize_instance', 'cast', expected_args,
instance=self.fake_instance_obj, migration={'id': 'fake_id'}, instance=self.fake_instance_obj, migration={'id': 'fake_id'},
image='image', instance_type=self.fake_flavor_obj, image='image', instance_type=self.fake_flavor_obj,
reservations=list('fake_res'),
clean_shutdown=True, version='4.0') clean_shutdown=True, version='4.0')
def test_resume_instance(self): def test_resume_instance(self):
@ -710,12 +709,12 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_revert_resize(self): def test_revert_resize(self):
self._test_compute_api('revert_resize', 'cast', self._test_compute_api('revert_resize', 'cast',
instance=self.fake_instance_obj, migration={'id': 'fake_id'}, instance=self.fake_instance_obj, migration={'id': 'fake_id'},
host='host', reservations=list('fake_res')) host='host')
def test_set_admin_password(self): def test_set_admin_password(self):
self._test_compute_api('set_admin_password', 'call', self._test_compute_api('set_admin_password', 'call',
instance=self.fake_instance_obj, new_pass='pw', instance=self.fake_instance_obj, new_pass='pw',
version='4.0') version='5.0')
def test_set_host_enabled(self): def test_set_host_enabled(self):
self._test_compute_api('set_host_enabled', 'call', self._test_compute_api('set_host_enabled', 'call',
@ -740,12 +739,12 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_stop_instance_cast(self): def test_stop_instance_cast(self):
self._test_compute_api('stop_instance', 'cast', self._test_compute_api('stop_instance', 'cast',
instance=self.fake_instance_obj, instance=self.fake_instance_obj,
clean_shutdown=True, version='4.0') clean_shutdown=True, version='5.0')
def test_stop_instance_call(self): def test_stop_instance_call(self):
self._test_compute_api('stop_instance', 'call', self._test_compute_api('stop_instance', 'call',
instance=self.fake_instance_obj, instance=self.fake_instance_obj,
clean_shutdown=True, version='4.0') clean_shutdown=True, version='5.0')
def test_suspend_instance(self): def test_suspend_instance(self):
self._test_compute_api('suspend_instance', 'cast', self._test_compute_api('suspend_instance', 'cast',
@ -754,7 +753,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_terminate_instance(self): def test_terminate_instance(self):
self._test_compute_api('terminate_instance', 'cast', self._test_compute_api('terminate_instance', 'cast',
instance=self.fake_instance_obj, bdms=[], instance=self.fake_instance_obj, bdms=[],
reservations=['uuid1', 'uuid2'], version='4.0') version='5.0')
def test_unpause_instance(self): def test_unpause_instance(self):
self._test_compute_api('unpause_instance', 'cast', self._test_compute_api('unpause_instance', 'cast',
@ -762,39 +761,39 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_unrescue_instance(self): def test_unrescue_instance(self):
self._test_compute_api('unrescue_instance', 'cast', self._test_compute_api('unrescue_instance', 'cast',
instance=self.fake_instance_obj, version='4.0') instance=self.fake_instance_obj, version='5.0')
def test_shelve_instance(self): def test_shelve_instance(self):
self._test_compute_api('shelve_instance', 'cast', self._test_compute_api('shelve_instance', 'cast',
instance=self.fake_instance_obj, image_id='image_id', instance=self.fake_instance_obj, image_id='image_id',
clean_shutdown=True, version='4.0') clean_shutdown=True, version='5.0')
def test_shelve_offload_instance(self): def test_shelve_offload_instance(self):
self._test_compute_api('shelve_offload_instance', 'cast', self._test_compute_api('shelve_offload_instance', 'cast',
instance=self.fake_instance_obj, instance=self.fake_instance_obj,
clean_shutdown=True, version='4.0') clean_shutdown=True, version='5.0')
def test_unshelve_instance(self): def test_unshelve_instance(self):
self._test_compute_api('unshelve_instance', 'cast', self._test_compute_api('unshelve_instance', 'cast',
instance=self.fake_instance_obj, host='host', image='image', instance=self.fake_instance_obj, host='host', image='image',
filter_properties={'fakeprop': 'fakeval'}, node='node', filter_properties={'fakeprop': 'fakeval'}, node='node',
version='4.0') version='5.0')
def test_volume_snapshot_create(self): def test_volume_snapshot_create(self):
self._test_compute_api('volume_snapshot_create', 'cast', self._test_compute_api('volume_snapshot_create', 'cast',
instance=self.fake_instance_obj, volume_id='fake_id', instance=self.fake_instance_obj, volume_id='fake_id',
create_info={}, version='4.0') create_info={}, version='5.0')
def test_volume_snapshot_delete(self): def test_volume_snapshot_delete(self):
self._test_compute_api('volume_snapshot_delete', 'cast', self._test_compute_api('volume_snapshot_delete', 'cast',
instance=self.fake_instance_obj, volume_id='fake_id', instance=self.fake_instance_obj, volume_id='fake_id',
snapshot_id='fake_id2', delete_info={}, version='4.0') snapshot_id='fake_id2', delete_info={}, version='5.0')
def test_external_instance_event(self): def test_external_instance_event(self):
self._test_compute_api('external_instance_event', 'cast', self._test_compute_api('external_instance_event', 'cast',
instances=[self.fake_instance_obj], instances=[self.fake_instance_obj],
events=['event'], events=['event'],
version='4.0') version='5.0')
def test_build_and_run_instance(self): def test_build_and_run_instance(self):
self._test_compute_api('build_and_run_instance', 'cast', self._test_compute_api('build_and_run_instance', 'cast',
@ -803,7 +802,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
admin_password='passwd', injected_files=None, admin_password='passwd', injected_files=None,
requested_networks=['network1'], security_groups=None, requested_networks=['network1'], security_groups=None,
block_device_mapping=None, node='node', limits=[], block_device_mapping=None, node='node', limits=[],
host_list=None, version='4.19') host_list=None, version='5.0')
def test_build_and_run_instance_4_18(self): def test_build_and_run_instance_4_18(self):
ctxt = context.RequestContext('fake_user', 'fake_project') ctxt = context.RequestContext('fake_user', 'fake_project')
@ -849,22 +848,22 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
def test_quiesce_instance(self): def test_quiesce_instance(self):
self._test_compute_api('quiesce_instance', 'call', self._test_compute_api('quiesce_instance', 'call',
instance=self.fake_instance_obj, version='4.0') instance=self.fake_instance_obj, version='5.0')
def test_unquiesce_instance(self): def test_unquiesce_instance(self):
self._test_compute_api('unquiesce_instance', 'cast', self._test_compute_api('unquiesce_instance', 'cast',
instance=self.fake_instance_obj, mapping=None, version='4.0') instance=self.fake_instance_obj, mapping=None, version='5.0')
def test_trigger_crash_dump(self): def test_trigger_crash_dump(self):
self._test_compute_api('trigger_crash_dump', 'cast', self._test_compute_api('trigger_crash_dump', 'cast',
instance=self.fake_instance_obj, version='4.6') instance=self.fake_instance_obj, version='5.0')
def test_trigger_crash_dump_incompatible(self): def test_trigger_crash_dump_incompatible(self):
self.flags(compute='4.0', group='upgrade_levels') self.flags(compute='4.0', group='upgrade_levels')
self.assertRaises(exception.TriggerCrashDumpNotSupported, self.assertRaises(exception.TriggerCrashDumpNotSupported,
self._test_compute_api, self._test_compute_api,
'trigger_crash_dump', 'cast', 'trigger_crash_dump', 'cast',
instance=self.fake_instance_obj, version='4.6') instance=self.fake_instance_obj, version='5.0')
def _test_simple_call(self, method, inargs, callargs, callret, def _test_simple_call(self, method, inargs, callargs, callret,
calltype='call', can_send=False): calltype='call', can_send=False):
@ -881,7 +880,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
ctxt = context.RequestContext() ctxt = context.RequestContext()
result = getattr(rpc, method)(ctxt, **inargs) result = getattr(rpc, method)(ctxt, **inargs)
call.assert_called_once_with(ctxt, method, **callargs) call.assert_called_once_with(ctxt, method, **callargs)
rpc.router.client.assert_called_once_with(ctxt) rpc.router.client.assert_called_with(ctxt)
return result return result
return _test() return _test()
@ -986,7 +985,7 @@ class ComputeRpcAPITestCase(test.NoDBTestCase):
calltype='cast') calltype='cast')
def test_check_can_live_migrate_destination_old_compute(self): def test_check_can_live_migrate_destination_old_compute(self):
self.flags(compute='4.10', group='upgrade_levels') self.flags(compute='4.0', group='upgrade_levels')
self.assertRaises(exception.LiveMigrationWithOldNovaNotSupported, self.assertRaises(exception.LiveMigrationWithOldNovaNotSupported,
self._test_compute_api, self._test_compute_api,
'check_can_live_migrate_destination', 'call', 'check_can_live_migrate_destination', 'call',

4
nova/tests/unit/conductor/tasks/test_migrate.py
View File

@ -81,7 +81,7 @@ class MigrationTaskTestCase(test.NoDBTestCase):
selection = self.host_lists[0][0] selection = self.host_lists[0][0]
prep_resize_mock.assert_called_once_with( prep_resize_mock.assert_called_once_with(
self.context, self.instance, legacy_request_spec['image'], self.context, self.instance, legacy_request_spec['image'],
self.flavor, selection.service_host, None, self.reservations, self.flavor, selection.service_host, None,
request_spec=legacy_request_spec, request_spec=legacy_request_spec,
filter_properties=self.filter_properties, node=selection.nodename, filter_properties=self.filter_properties, node=selection.nodename,
clean_shutdown=self.clean_shutdown, host_list=[]) clean_shutdown=self.clean_shutdown, host_list=[])
@ -139,7 +139,7 @@ class MigrationTaskTestCase(test.NoDBTestCase):
prep_resize_mock.assert_called_once_with( prep_resize_mock.assert_called_once_with(
self.context, self.instance, legacy_request_spec['image'], self.context, self.instance, legacy_request_spec['image'],
self.flavor, selection.service_host, task._migration, self.flavor, selection.service_host, task._migration,
self.reservations, request_spec=legacy_request_spec, request_spec=legacy_request_spec,
filter_properties=self.filter_properties, node=selection.nodename, filter_properties=self.filter_properties, node=selection.nodename,
clean_shutdown=self.clean_shutdown, host_list=[]) clean_shutdown=self.clean_shutdown, host_list=[])
az_mock.assert_called_once_with(self.context, 'host1') az_mock.assert_called_once_with(self.context, 'host1')

2
nova/tests/unit/conductor/test_conductor.py
View File

@ -2397,7 +2397,7 @@ class ConductorTaskTestCase(_BaseTaskTestCase, test_compute.BaseTestCase):
[inst_obj.uuid], return_objects=True, return_alternates=True) [inst_obj.uuid], return_objects=True, return_alternates=True)
prep_resize_mock.assert_called_once_with( prep_resize_mock.assert_called_once_with(
self.context, inst_obj, legacy_request_spec['image'], self.context, inst_obj, legacy_request_spec['image'],
flavor, hosts[0]['host'], None, [resvs], flavor, hosts[0]['host'], None,
request_spec=legacy_request_spec, request_spec=legacy_request_spec,
filter_properties=legacy_filter_props, filter_properties=legacy_filter_props,
node=hosts[0]['nodename'], clean_shutdown=True, host_list=[]) node=hosts[0]['nodename'], clean_shutdown=True, host_list=[])