def wait_for_status(self, res_id, get_status, wait_status, timeout=60,
stop_statuses=None):
LOG.debug("Waiting for status change")
delay = 1
stop_statuses = [s.lower() for s in (stop_statuses or [])]
if 'error' not in stop_statuses:
stop_statuses.append('error')
while delay < timeout:
actual_status = get_status(res_id).lower()
LOG.debug("Expected status is '%s', actual - '%s', "
"stop statuses - %s",
wait_status, actual_status, stop_statuses)
if actual_status in stop_statuses:
LOG.debug("Stop status reached, exit")
raise exception.TimeoutException(
get_status(res_id).lower(),
wait_status, "Timed out waiting for state change")
elif actual_status == wait_status.lower():
LOG.debug("Expected status reached, exit")
break
LOG.debug("Expected status NOT reached, waiting")
time.sleep(delay)
delay *= 2
else:
LOG.debug("Timed out waiting for state change")
raise exception.TimeoutException(
get_status(res_id).lower(),
wait_status, "Timed out waiting for state change")
def test_tries_to_boot_vm_on_all_nodes(self, associate_floatingip,
prepare_networks):
compute_hosts = ['host1', 'host2', 'host3']
num_computes = len(compute_hosts)
instance_body = {
'availability_zone': 'somezone',
'name': 'vm1',
'id': 'some-id'
}
one_instance = {
utils.INSTANCES_TYPE: {
'some_id': {
utils.INSTANCE_BODY: instance_body,
}
}
}
dst_compute = mock.Mock()
dst_compute.get_compute_hosts.return_value = compute_hosts
dst_compute.deploy.side_effect = exception.TimeoutException(
None, None, None)
dst_cloud = mock.Mock()
dst_cloud.resources = {
utils.COMPUTE_RESOURCE: dst_compute,
utils.NETWORK_RESOURCE: mock.Mock(),
utils.IDENTITY_RESOURCE: mock.Mock(),
}
tr_inst = transport_instance.TransportInstance(mock.MagicMock())
tr_inst.cfg = mock.MagicMock()
tr_inst.cfg.migrate.keep_ip = True
tr_inst.cfg.migrate.keep_floatingip = True
tr_inst.dst_cloud = dst_cloud
self.assertRaises(transport_instance.DestinationCloudNotOperational,
tr_inst.deploy_instance_on_random_host, one_instance,
'somezone')
self.assertEqual(associate_floatingip.call_count, num_computes)
self.assertEqual(prepare_networks.call_count, num_computes)
self.assertEqual(dst_compute.deploy.call_count, num_computes)
def wait_for_condition(condition_fn, *args, **kwargs):
"""
Periodically calls condition_fn function passing args as positional
arguments and kwargs as keyword arguments and terminate when this function
will return True.
If after timeout seconds function didn't terminate, TimeoutException is
raised.
:param condition_fn: predicate function
:param timeout: for how many seconds to wait for condition_fn to return
True before raising TimeoutException
:raise TimeoutException: when function didn't terminate after timeout
seconds
"""
timeout = kwargs.pop('timeout', 60)
delay = 1
while delay <= timeout:
if condition_fn(*args, **kwargs):
break
time.sleep(delay)
delay *= 2
else:
raise exception.TimeoutException(None, None, "Timeout exp")