def wait_for_server_creation(self, server_id):
"""
@summary: Waits for a server to be created successfully
@param server_id: The uuid of the server
@type server_id: String
@return: A server object after it has been successfully built
@rtype: Server
"""
verifier = StatusProgressionVerifier(
'server', server_id, lambda id_: self.verify_entity(
self.servers_client.get_server(id_)).status, server_id)
verifier.set_global_state_properties(
timeout=self.config.server_build_timeout)
verifier.add_state(expected_statuses=[ServerStates.BUILD],
acceptable_statuses=[ServerStates.ACTIVE],
error_statuses=[ServerStates.ERROR],
poll_rate=self.config.server_status_interval)
verifier.add_state(expected_statuses=[ServerStates.ACTIVE],
error_statuses=[ServerStates.ERROR],
poll_rate=self.config.server_status_interval)
verifier.start()
response = self.servers_client.get_server(server_id)
return self.verify_entity(response)
def verify_volume_status_progression_during_attachment(
self, volume_id, state_list=None):
verifier = StatusProgressionVerifier(
'volume', volume_id, self._get_volume_status, volume_id)
verifier.set_global_state_properties(
timeout=self.config.attachment_timeout)
verifier.add_state(
expected_statuses=['available'],
acceptable_statuses=['attaching', 'in-use'],
error_statuses=['error', 'creating'],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
verifier.add_state(
expected_statuses=['attaching'],
acceptable_statuses=['in-use'],
error_statuses=['error', 'creating'],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
verifier.add_state(
expected_statuses=['in-use'],
error_statuses=['available', 'error', 'creating'],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
verifier.start()
def verify_server_snapshotting_progression(self, server_id):
# Wait while the server is imaging
verifier = StatusProgressionVerifier(
'server', server_id,
lambda id_: self.verify_entity(
self.servers_client.get_server(id_)).task_state,
server_id)
verifier.set_global_state_properties(
timeout=self.config.snapshot_timeout)
verifier.add_state(
expected_statuses=[ComputeTaskStates.IMAGE_SNAPSHOT],
acceptable_statuses=[ComputeTaskStates.IMAGE_PENDING_UPLOAD,
ComputeTaskStates.IMAGE_UPLOADING],
poll_rate=self.config.image_status_interval)
verifier.add_state(
expected_statuses=[ComputeTaskStates.IMAGE_PENDING_UPLOAD],
acceptable_statuses=[ComputeTaskStates.IMAGE_UPLOADING,
ComputeTaskStates.NONE],
poll_rate=self.config.image_status_interval)
verifier.add_state(
expected_statuses=[ComputeTaskStates.IMAGE_UPLOADING],
acceptable_statuses=[ComputeTaskStates.NONE],
poll_rate=self.config.image_status_interval)
verifier.add_state(
expected_statuses=[ComputeTaskStates.NONE],
poll_rate=self.config.image_status_interval)
verifier.start()
response = self.servers_client.get_server(server_id)
return self.verify_entity(response)
def verify_server_snapshotting_progression(self, server_id):
# Wait while the server is imaging
verifier = StatusProgressionVerifier(
'server', server_id, lambda id_: self.verify_entity(
self.servers_client.get_server(id_)).task_state, server_id)
verifier.set_global_state_properties(
timeout=self.config.snapshot_timeout)
verifier.add_state(
expected_statuses=[ComputeTaskStates.IMAGE_SNAPSHOT],
acceptable_statuses=[
ComputeTaskStates.IMAGE_PENDING_UPLOAD,
ComputeTaskStates.IMAGE_UPLOADING
],
poll_rate=self.config.image_status_interval)
verifier.add_state(
expected_statuses=[ComputeTaskStates.IMAGE_PENDING_UPLOAD],
acceptable_statuses=[ComputeTaskStates.IMAGE_UPLOADING],
error_statuses=[ComputeTaskStates.NONE],
poll_rate=self.config.image_status_interval)
verifier.add_state(
expected_statuses=[ComputeTaskStates.IMAGE_UPLOADING],
error_statuses=[ComputeTaskStates.NONE],
poll_rate=self.config.image_status_interval)
verifier.add_state(expected_statuses=[ComputeTaskStates.NONE],
poll_rate=self.config.image_status_interval)
verifier.start()
response = self.servers_client.get_server(server_id)
return self.verify_entity(response)
def verify_volume_status_progression_during_attachment(
self, volume_id, state_list=None):
verifier = StatusProgressionVerifier('volume', volume_id,
self._get_volume_status,
volume_id)
verifier.set_global_state_properties(
timeout=self.config.attachment_timeout)
verifier.add_state(expected_statuses=['available'],
acceptable_statuses=['attaching', 'in-use'],
error_statuses=['error', 'creating'],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
verifier.add_state(expected_statuses=['attaching'],
acceptable_statuses=['in-use'],
error_statuses=['error', 'creating'],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
verifier.add_state(expected_statuses=['in-use'],
error_statuses=['available', 'error', 'creating'],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
verifier.start()
def wait_for_server_creation(self, server_id):
"""
@summary: Waits for a server to be created successfully
@param server_id: The uuid of the server
@type server_id: String
@return: A server object after it has been successfully built
@rtype: Server
"""
verifier = StatusProgressionVerifier(
'server', server_id,
lambda id_: self.verify_entity(
self.servers_client.get_server(id_)).status,
server_id)
retry_limit = self.config.server_status_poll_failure_max_retries
verifier.set_global_state_properties(
timeout=self.config.server_build_timeout)
verifier.add_state(
expected_statuses=[ServerStates.BUILD],
acceptable_statuses=[ServerStates.ACTIVE],
error_statuses=[ServerStates.ERROR],
poll_rate=self.config.server_status_interval,
poll_failure_retry_limit=retry_limit)
verifier.add_state(
expected_statuses=[ServerStates.ACTIVE],
error_statuses=[ServerStates.ERROR],
poll_rate=self.config.server_status_interval,
poll_failure_retry_limit=retry_limit)
try:
verifier.start()
except (StatusProgressionError, StatusPollError) as e:
if not e.args:
e.args=('',)
e.args = (
'Failed to create server with instance '
'id {id}'.format(id=server_id),) + e.args
e.args = ('; '.join(e.args),)
raise
except Exception as e:
if not e.args:
e.args=('',)
e.args = (
'Unexpected error occurred while waiting for server {id}'
'to be created.'.format(id=server_id),) + e.args
e.args = ('; '.join(e.args),)
raise
response = self.servers_client.get_server(server_id)
return self.verify_entity(response)
def wait_for_snapshot_status(
self, snapshot_id, expected_status, timeout, poll_rate=None):
verifier = StatusProgressionVerifier(
'snapshot', snapshot_id, self.get_snapshot_status, snapshot_id)
verifier.set_global_state_properties(timeout)
verifier.add_state(
expected_statuses=[expected_status],
poll_rate=self.config.snapshot_status_poll_frequency,
poll_failure_retry_limit=
self.config.snapshot_status_poll_failure_max_retries)
verifier.start()
def wait_for_server_creation(self, server_id):
"""
@summary: Waits for a server to be created successfully
@param server_id: The uuid of the server
@type server_id: String
@return: A server object after it has been successfully built
@rtype: Server
"""
verifier = StatusProgressionVerifier(
'server', server_id, lambda id_: self.verify_entity(
self.servers_client.get_server(id_)).status, server_id)
retry_limit = self.config.server_status_poll_failure_max_retries
verifier.set_global_state_properties(
timeout=self.config.server_build_timeout)
verifier.add_state(expected_statuses=[ServerStates.BUILD],
acceptable_statuses=[ServerStates.ACTIVE],
error_statuses=[ServerStates.ERROR],
poll_rate=self.config.server_status_interval,
poll_failure_retry_limit=retry_limit)
verifier.add_state(expected_statuses=[ServerStates.ACTIVE],
error_statuses=[ServerStates.ERROR],
poll_rate=self.config.server_status_interval,
poll_failure_retry_limit=retry_limit)
try:
verifier.start()
except (StatusProgressionError, StatusPollError) as e:
if not e.args:
e.args = ('', )
e.args = ('Failed to create server with instance '
'id {id}'.format(id=server_id), ) + e.args
e.args = ('; '.join(e.args), )
raise
except Exception as e:
if not e.args:
e.args = ('', )
e.args = ('Unexpected error occurred while waiting for server {id}'
'to be created.'.format(id=server_id), ) + e.args
e.args = ('; '.join(e.args), )
raise
response = self.servers_client.get_server(server_id)
return self.verify_entity(response)
def verify_volume_status_progression_during_detachment(
self, volume_id, raise_on_error=True):
"""
Track the status progression of volume volume_id being detached.
Optionally fails silently if rais_on_error is set to False.
:param volume_id: the uuid of the volume being tracked
:returns: None
"""
verifier = StatusProgressionVerifier('volume', volume_id,
self._get_volume_status,
volume_id)
verifier.set_global_state_properties(
timeout=self.config.attachment_timeout)
verifier.add_state(
expected_statuses=['in-use'],
acceptable_statuses=['detaching', 'available'],
error_statuses=['error', 'attaching', 'creating', 'deleting'],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
verifier.add_state(
expected_statuses=['detaching'],
acceptable_statuses=['available'],
error_statuses=['error', 'attaching', 'creating', 'deleting'],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
verifier.add_state(expected_statuses=['available'],
error_statuses=[
'error', 'attaching', 'creating', 'deleting',
'in-use'
],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
try:
verifier.start()
except Exception as exception:
if raise_on_error:
raise exception
def verify_volume_status_progression_during_detachment(
self, volume_id, raise_on_error=True):
"""
Track the status progression of volume volume_id being detached.
Optionally fails silently if rais_on_error is set to False.
:param volume_id: the uuid of the volume being tracked
:returns: None
"""
verifier = StatusProgressionVerifier(
'volume', volume_id, self._get_volume_status, volume_id)
verifier.set_global_state_properties(
timeout=self.config.attachment_timeout)
verifier.add_state(
expected_statuses=['in-use'],
acceptable_statuses=['detaching', 'available'],
error_statuses=['error', 'attaching', 'creating', 'deleting'],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
verifier.add_state(
expected_statuses=['detaching'],
acceptable_statuses=['available'],
error_statuses=['error', 'attaching', 'creating', 'deleting'],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
verifier.add_state(
expected_statuses=['available'],
error_statuses=[
'error', 'attaching', 'creating', 'deleting', 'in-use'],
poll_rate=self.config.api_poll_rate,
poll_failure_retry_limit=3)
try:
verifier.start()
except Exception as exception:
if raise_on_error:
raise exception
def wait_for_snapshot_status(self,
snapshot_id,
expected_status,
timeout,
poll_rate=None):
""" This method can end up polling for the entire timeout if the
snapshot enters a permament unexpected state.
It's been included for backwards compatibility only and should
generally be avoided."""
verifier = StatusProgressionVerifier('snapshot', snapshot_id,
self.get_snapshot_status,
snapshot_id)
verifier.set_global_state_properties(timeout)
verifier.add_state(
expected_statuses=[expected_status],
poll_rate=self.config.snapshot_status_poll_frequency,
poll_failure_retry_limit=(
self.config.snapshot_status_poll_failure_max_retries))
verifier.start()
def verify_image_creation_progression(self, image_id):
verifier = StatusProgressionVerifier(
'image', image_id, lambda id_: self.verify_entity(
self.images_client.get_image(id_)).status, image_id)
verifier.set_global_state_properties(
timeout=self.config.snapshot_timeout)
verifier.add_state(
expected_statuses=[ImageStates.SAVING],
acceptable_statuses=[ImageStates.ACTIVE],
error_statuses=[ImageStates.ERROR, ImageStates.DELETED],
poll_rate=self.config.image_status_interval)
verifier.add_state(
expected_statuses=[ImageStates.ACTIVE],
error_statuses=[ImageStates.ERROR, ImageStates.DELETED],
poll_rate=self.config.image_status_interval)
verifier.start()
response = self.images_client.get_image(image_id)
return self.verify_entity(response)
def verify_volume_create_status_progresion(self, volume_id, timeout):
"""Raises an exception if the volume doesn't pass through
the normal expected series of states for a volume create.
"""
verifier = StatusProgressionVerifier(
'volume', volume_id, self.get_volume_status, volume_id)
verifier.set_global_state_properties(timeout)
verifier.add_state(
expected_statuses=[self.statuses.Volume.CREATING],
acceptable_statuses=[self.statuses.Volume.AVAILABLE],
error_statuses=[self.statuses.Volume.ERROR],
poll_rate=self.config.volume_status_poll_frequency,
poll_failure_retry_limit=
self.config.volume_status_poll_failure_max_retries)
verifier.add_state(
expected_statuses=[self.statuses.Volume.AVAILABLE],
error_statuses=[self.statuses.Volume.ERROR],
poll_rate=self.config.volume_status_poll_frequency,
poll_failure_retry_limit=
self.config.volume_status_poll_failure_max_retries)
verifier.start()
def verify_volume_create_status_progresion(self, volume_id, timeout):
"""Raises an exception if the volume doesn't pass through
the normal expected series of states for a volume create.
"""
verifier = StatusProgressionVerifier('volume', volume_id,
self.get_volume_status, volume_id)
verifier.set_global_state_properties(timeout)
verifier.add_state(
expected_statuses=[self.statuses.Volume.CREATING],
acceptable_statuses=[self.statuses.Volume.AVAILABLE],
error_statuses=[self.statuses.Volume.ERROR],
poll_rate=self.config.volume_status_poll_frequency,
poll_failure_retry_limit=(
self.config.volume_status_poll_failure_max_retries))
verifier.add_state(
expected_statuses=[self.statuses.Volume.AVAILABLE],
error_statuses=[self.statuses.Volume.ERROR],
poll_rate=self.config.volume_status_poll_frequency,
poll_failure_retry_limit=(
self.config.volume_status_poll_failure_max_retries))
verifier.start()
def verify_image_creation_progression(self, image_id):
verifier = StatusProgressionVerifier(
'image', image_id,
lambda id_: self.verify_entity(
self.images_client.get_image(id_)).status,
image_id)
verifier.set_global_state_properties(
timeout=self.config.snapshot_timeout)
verifier.add_state(
expected_statuses=[ImageStates.SAVING],
acceptable_statuses=[ImageStates.ACTIVE],
error_statuses=[ImageStates.ERROR, ImageStates.DELETED],
poll_rate=self.config.image_status_interval)
verifier.add_state(
expected_statuses=[ImageStates.ACTIVE],
error_statuses=[ImageStates.ERROR, ImageStates.DELETED],
poll_rate=self.config.image_status_interval)
verifier.start()
response = self.images_client.get_image(image_id)
return self.verify_entity(response)
def create_available_volume(
self, size, volume_type, name=None, description=None,
availability_zone=None, metadata=None, bootable=None,
image_ref=None, snapshot_id=None, source_volid=None, timeout=None):
"""Create a volume and wait for it to reach the 'available' status"""
metadata = metadata or {}
timeout = timeout or self.calculate_volume_create_timeout(size)
try:
if image_ref:
timeout = self.calculate_copy_image_to_volume_timeout(size)
self._log.info(
"Copy image to volume timeout calculated at {0} "
"seconds".format(timeout))
elif snapshot_id:
timeout = self.calculate_snapshot_restore_timeout(size)
self._log.info(
"Create volume from snapshot timeout calculated at {0} "
"seconds".format(timeout))
elif source_volid:
timeout = self.calculate_volume_clone_timeout(size)
self._log.info(
"Clone a volume timeout calculated at {0} "
"seconds".format(timeout))
except:
# Worst case if no config values are set.
# Use the default volume create timeout.
self._log.info(
"Unable to use create-method-specific timeout, "
"defaulting to normal volume create timeout of {0} "
"seconds".format(timeout))
self._log.info("create_available_volume() is creating a volume")
start_time = time()
resp = self.create_volume(
size, volume_type, name=name, description=description,
availability_zone=availability_zone, metadata=metadata,
bootable=bootable, image_ref=image_ref, snapshot_id=snapshot_id,
source_volid=source_volid)
timeout = timeout - (time() - start_time)
volume = self._verify_entity(resp)
# Verify volume progression from 'creating' to 'available'
verifier = StatusProgressionVerifier(
'volume', volume.id_, self.get_volume_status, volume.id_)
verifier.set_global_state_properties(timeout)
verifier.add_state(
expected_statuses=[self.statuses.Volume.CREATING],
acceptable_statuses=[self.statuses.Volume.AVAILABLE],
error_statuses=[self.statuses.Volume.ERROR],
poll_rate=self.config.volume_status_poll_frequency)
verifier.add_state(
expected_statuses=[self.statuses.Volume.AVAILABLE],
error_statuses=[self.statuses.Volume.ERROR],
poll_rate=self.config.volume_status_poll_frequency)
verifier.start()
# Return volume model
resp = self.client.get_volume_info(volume.id_)
volume = self._verify_entity(resp)
return volume
def create_available_volume(self,
size,
volume_type,
name=None,
description=None,
availability_zone=None,
metadata=None,
bootable=None,
image_ref=None,
snapshot_id=None,
source_volid=None,
timeout=None):
"""Create a volume and wait for it to reach the 'available' status"""
metadata = metadata or {}
timeout = timeout or self.calculate_volume_create_timeout(size)
try:
if image_ref:
timeout = self.calculate_copy_image_to_volume_timeout(size)
self._log.info(
"Copy image to volume timeout calculated at {0} "
"seconds".format(timeout))
elif snapshot_id:
timeout = self.calculate_snapshot_restore_timeout(size)
self._log.info(
"Create volume from snapshot timeout calculated at {0} "
"seconds".format(timeout))
elif source_volid:
timeout = self.calculate_volume_clone_timeout(size)
self._log.info("Clone a volume timeout calculated at {0} "
"seconds".format(timeout))
except:
# Worst case if no config values are set.
# Use the default volume create timeout.
self._log.info("Unable to use create-method-specific timeout, "
"defaulting to normal volume create timeout of {0} "
"seconds".format(timeout))
self._log.info("create_available_volume() is creating a volume")
start_time = time()
resp = self.create_volume(size,
volume_type,
name=name,
description=description,
availability_zone=availability_zone,
metadata=metadata,
bootable=bootable,
image_ref=image_ref,
snapshot_id=snapshot_id,
source_volid=source_volid)
timeout = timeout - (time() - start_time)
volume = self._verify_entity(resp)
# Verify volume progression from 'creating' to 'available'
verifier = StatusProgressionVerifier('volume', volume.id_,
self.get_volume_status,
volume.id_)
verifier.set_global_state_properties(timeout)
verifier.add_state(
expected_statuses=[self.statuses.Volume.CREATING],
acceptable_statuses=[self.statuses.Volume.AVAILABLE],
error_statuses=[self.statuses.Volume.ERROR],
poll_rate=self.config.volume_status_poll_frequency)
verifier.add_state(expected_statuses=[self.statuses.Volume.AVAILABLE],
error_statuses=[self.statuses.Volume.ERROR],
poll_rate=self.config.volume_status_poll_frequency)
verifier.start()
# Return volume model
resp = self.client.get_volume_info(volume.id_)
volume = self._verify_entity(resp)
return volume
