def wait_for_image_to_be_deleted(self,
image_id,
interval_time=None,
timeout=None):
"""
@summary: Waits for an image to be deleted
@param image_id: The uuid of the image
@type image_id: String
@param interval_time: The amount of time in seconds to wait
between polling
@type interval_time: Integer
@param interval_time: The amount of time in seconds to wait
before aborting
@type interval_time: Integer
"""
interval_time = interval_time or self.config.image_status_interval
timeout = timeout or self.config.snapshot_timeout
end_time = time.time() + timeout
while time.time() < end_time:
try:
image = self.images_client.get_image(image_id).entity
except ItemNotFound:
break
# If GET on deleted images is enabled, check for DELETED status
if self.config.can_get_deleted_image and image.status == ImageStates.DELETED:
break
time.sleep(interval_time)
else:
raise TimeoutException(
"wait_for_image_to_be_deleted ran for {0} seconds "
"and did not observe the image reaching the "
"{1} status.".format(timeout, ImageStates.DELETED))
def wait_for_server_status(self,
server_id,
desired_status,
interval_time=None,
timeout=None):
interval_time = int(interval_time
or self.servers_api_config.server_status_interval)
timeout = int(timeout or self.servers_api_config.server_build_timeout)
end_time = time.time() + timeout
time.sleep(interval_time)
while time.time() < end_time:
resp = self.nova_cli_client.show_server(server_id)
server = resp.entity
if server.status.lower() == ServerStates.ERROR.lower():
raise BuildErrorException(
'Build failed. Server with uuid "{0} entered ERROR status.'
.format(server.id))
if server.status == desired_status:
break
time.sleep(interval_time)
else:
raise TimeoutException(
"wait_for_server_status ran for {0} seconds and did not "
"observe server {1} reach the {2} status.".format(
timeout, server_id, desired_status))
return resp
def wait_for_servers_to_be_active(self,
server_id_list,
interval_time=None,
timeout=None,
raise_exception=False):
"""
@summary: Waits for multiple servers to be ACTIVE
@param server_id_list: The uuids of the servers to wait for ACTIVE
@type server_id_list: List
@param interval_time: Seconds to wait between polling
@type interval_time: Integer
@param timeout: The amount of time in seconds to wait before aborting
@type timeout: Integer
"""
interval_time = (interval_time
or self.compute.servers.config.server_status_interval)
timeout = timeout or self.compute.servers.config.server_build_timeout
end_time = time.time() + timeout
while time.time() < end_time:
for server_id in server_id_list:
resp = self.compute.servers.client.get_server(server_id)
if (resp.status_code == ComputeResponseCodes.GET_SERVER
and resp.entity.status == ComputeStatus.ACTIVE
and server_id in server_id_list):
server_id_list.remove(server_id)
if not server_id_list:
break
time.sleep(interval_time)
else:
msg = ('wait_for_servers_to_be_active {0} seconds timeout waiting'
'for servers: {1}').format(timeout, server_id_list)
self._log.info(msg)
if raise_exception:
raise TimeoutException(msg)
def wait_for_server_to_be_deleted(self,
server_id,
interval_time=None,
timeout=None):
"""
@summary: Waits for a server to be deleted
@param server_id: The uuid of the server
@type server_id: String
@param interval_time: The amount of time in seconds to wait
between polling
@type interval_time: Integer
@param timeout: The amount of time in seconds to wait
before aborting
@type timeout: Integer
"""
interval_time = interval_time or self.config.server_status_interval
timeout = timeout or self.config.server_build_timeout
end_time = time.time() + timeout
while time.time() < end_time:
try:
resp = self.servers_client.get_server(server_id)
if resp.status_code == HTTPResponseCodes.NOT_FOUND:
break
except ItemNotFound:
break
time.sleep(interval_time)
else:
msg = ('wait_for_server_to_be_deleted {0} seconds timeout waiting'
'for the expected get server HTTP {1} status code').format(
timeout, HTTPResponseCodes.NOT_FOUND)
raise TimeoutException(msg)
def wait_for_server_to_be_deleted(self,
server_id,
interval_time=None,
timeout=None):
"""
@summary: Waits for a server to be deleted
@param server_id: The uuid of the server
@type server_id: String
@param interval_time: The amount of time in seconds to wait
between polling
@type interval_time: Integer
@param timeout: The amount of time in seconds to wait
before aborting
@type timeout: Integer
"""
interval_time = interval_time or self.config.server_status_interval
timeout = timeout or self.config.server_build_timeout
end_time = time.time() + timeout
while time.time() < end_time:
try:
self.servers_client.get_server(server_id)
except ItemNotFound:
break
time.sleep(interval_time)
else:
raise TimeoutException(
"wait_for_server_status ran for {0} seconds and did not "
"observe the server achieving the {1} status.".format(
timeout, 'DELETED'))
def ping_until_reachable(cls, ip, timeout, interval_time):
"""
@summary: Ping an IP address until it responds or a timeout
is reached
@param ip: The IP address to ping (either IPv4 or IPv6)
@type ip: string
@param timeout: The amount of time in seconds to wait before aborting.
@type timeout: int
@param interval_time: The length of time in seconds to wait between
pings.
@type interval_time: int
"""
end_time = time.time() + timeout
while time.time() < end_time:
if PingClient.ping(ip):
return
time.sleep(interval_time)
raise TimeoutException(
"ping_until_reachable ran for {timeout} seconds and did not "
"receive a ping response from {ip}".format(timeout=timeout, ip=ip))
def ping_until_unreachable(cls, ip, timeout, interval_time):
"""
@summary: Ping an IP address until it stops responding or a
timeout is reached
@param ip: The IP address to ping (either IPv4 or IPv6)
@type ip: string
@param timeout: The amount of time in seconds to wait before aborting.
@type timeout: int
@param interval_time: The length of time in seconds to wait between
pings.
@type interval_time: int
"""
end_time = time.time() + timeout
while time.time() < end_time:
if not PingClient.ping(ip):
return
time.sleep(interval_time)
raise TimeoutException(
"{ip} was expected to become unreachable, but was still pingable "
"after {timeout} seconds".format(timeout=timeout, ip=ip))
def confirm_server_deletion(self,
server_id,
response_code,
interval_time=None,
timeout=None):
"""
@summary: confirm server deletion based on response code.
@param server_id: The uuid of the server
@type server_id: String
@param: response code to wait for to confirm server deletion
@type: Integer
@param interval_time: The amount of time in seconds to wait
between polling
@type interval_time: Integer
@param timeout: The amount of time in seconds to wait
before aborting
@type timeout: Integer
"""
interval_time = interval_time or self.config.server_status_interval
timeout = timeout or self.config.server_build_timeout
end_time = time.time() + timeout
while time.time() < end_time:
resp = self.servers_client.get_server(server_id)
if resp.status_code == response_code:
return
time.sleep(interval_time)
raise TimeoutException(
"wait_for_server_status ran for {0} seconds and did not "
"observe the server achieving the {1} status based on "
"response code.".format(timeout, 'DELETED'))
def wait_for_task_status(self,
task_id,
desired_status,
interval_time=10,
timeout=1200,
response_entity_type=None):
"""
@summary: Waits for a task to reach a desired status and if the import
task is successful, adds the created image to the resource pool for
tear down
@param task_id: Task id to evaluate
@type task_id: UUID
@param desired_status: Expected final status of task
@type desired_status: String
@param interval_time: Amount of time in seconds to wait between polling
@type interval_time: Integer
@param timeout: Amount of time in seconds to wait before aborting
@type timeout: Integer
@param response_entity_type: Response entity type to be passed on to
python requests
@type response_entity_type: Type
@return: Task
@rtype: Object
"""
interval_time = interval_time or self.config.task_status_interval
timeout = timeout or self.config.task_timeout
end_time = time.time() + timeout
if not response_entity_type:
response_entity_type = Task
while time.time() < end_time:
resp = self.client.get_task_details(
task_id, response_entity_type=response_entity_type)
task = self.verify_resp(resp, 'get task details', task_id)
if ((task.status.lower() == TaskStatus.FAILURE
and desired_status != TaskStatus.FAILURE)
or (task.status.lower() == TaskStatus.SUCCESS
and desired_status != TaskStatus.SUCCESS)):
raise BuildErrorException(
'Task with the uuid {0} entered the {1} status. Task '
'responded with the message {2}'.format(
task.id_, task.status, task.message.replace('\\', '')))
if task.status == desired_status:
break
time.sleep(interval_time)
else:
raise TimeoutException(
'Task with the uuid {0} did not reach the {1} status within '
'{2} seconds.'.format(task_id, desired_status, timeout))
if (task is not None and task.type_ == TaskTypes.IMPORT
and task.status.lower() == TaskStatus.SUCCESS):
self.resources.add(task.result.image_id, self.client.delete_image)
return task
def wait_for_metadata_value(self,
server_id,
metadata_key,
potential_values,
timeout,
interval_time=None):
"""
@summary: Polls a server's metadata for a specific key until it
reaches one of the specified values or times out
@param server_id: The uuid of the server
@type server_id: String
@param metadata_key: Metadata key to poll for desired value
@type metadata_key: String
@param potential_values: A list of potential values that are
actionable. If the metadata key reaches any
of the values in this list, the method should
return that value and exit.
@type potential_values: List of Strings
@param interval_time: The amount of time in seconds to wait
between polling.
@type interval_time: Integer
@param timeout: The amount of time in seconds to wait before aborting.
@type timeout: Integer
@return: The final value of the metadata_key, either a specified value
or the value of the key at timeout
@rtype: String
"""
interval_time = interval_time or self.config.server_status_interval
end_time = time.time() + timeout
metadata_value = None
while time.time() < end_time:
response = self.servers_client.list_server_metadata(server_id)
metadata = self.verify_entity(response)
# Key may not exist yet, so check before accessing
if metadata_key in metadata:
metadata_value = metadata[metadata_key]
if metadata_value in potential_values:
return metadata_value
time.sleep(interval_time)
# Raise an exception if metadata didn't reach desired value within
# the timeout interval
if metadata_value:
metadata_result = "Key {0} ended with value {1}".format(
metadata_key, metadata_value)
else:
metadata_result = "Key {0} was not found.".format(metadata_key)
raise TimeoutException(
"wait_for_metadata_value ran for {timeout} seconds and did not "
"observe server {server_id} reach any of the specified values, "
"{potential_values}, for metadata key {metadata_key}. {result}".
format(timeout=timeout,
server_id=server_id,
potential_values=potential_values,
metadata_key=metadata_key,
result=metadata_result))
def wait_for_server_task_state(self,
server_id,
state_to_wait_for,
timeout,
interval_time=None):
"""
@summary: Polls server task state until state_to_wait_for is met
@param server_id: The uuid of the server
@type server_id: String
@param state_to_wait_for: The desired final status of the server
@type state_to_wait_for: String
@param timeout: The amount of time in seconds to wait
before aborting
@type timeout: Integer
@param interval_time: The amount of time in seconds to wait
between polling
@type interval_time: Integer
"""
interval_time = interval_time or self.config.server_status_interval
end_time = time.time() + timeout
while time.time() < end_time:
response = self.servers_client.get_server(server_id)
if not response.ok:
raise Exception("Failed to get server information: "
"{code} - {reason}".format(
code=response.status_code,
reason=response.reason))
if response.entity is None:
raise Exception("Response entity was not set. "
"Response was: {0}".format(response.content))
task_state = response.entity.task_state.lower()
if response.entity.status.lower() != ServerStates.ERROR.lower():
raise BuildErrorException(
"Build failed. Server with uuid {server_id} entered "
"ERROR status.".format(server_id))
if task_state == state_to_wait_for.lower():
break
time.sleep(interval_time)
else:
raise TimeoutException(
"Wait for server task ran for {timeout} seconds and did not "
"observe server {server_id} reach desired task state of "
"{state_to_wait_for}.".format(
timeout=timeout,
server_id=server_id,
state_to_wait_for=state_to_wait_for))
return response
def wait_for_server_status(self,
server_id,
desired_status,
interval_time=None,
timeout=None):
"""
@summary: Waits for a server to reach a desired status
@param server_id: The uuid of the server
@type server_id: String
@param desired_status: The desired final status of the server
@type desired_status: String
@param interval_time: The amount of time in seconds to wait
between polling
@type interval_time: Integer
@param timeout: The amount of time in seconds to wait
before aborting
@type timeout: Integer
@return: Response object containing response and the server
domain object
@rtype: requests.Response
"""
interval_time = interval_time or self.config.server_status_interval
timeout = timeout or self.config.server_build_timeout
end_time = time.time() + timeout
time.sleep(interval_time)
while time.time() < end_time:
resp = self.servers_client.get_server(server_id)
if not resp.ok:
raise Exception("Failed to get server information: "
"{code} - {reason}".format(
code=resp.status_code, reason=resp.reason))
if resp.entity is None:
raise Exception("Response entity was not set. "
"Response was: {0}".format(resp.content))
server = resp.entity
if server.status.lower() == ServerStates.ERROR.lower():
raise BuildErrorException(
"Build failed. Server with uuid {server_id} entered "
"ERROR status.".format(server_id=server.id))
if server.status == desired_status:
break
time.sleep(interval_time)
else:
raise TimeoutException(
"wait_for_server_status ran for {0} seconds and did not "
"observe server {1} reach the {2} status.".format(
timeout, server_id, desired_status))
return resp
def _wait_for_compute_delete(self,
resource_id_list,
resource,
delete_method,
get_method,
interval_time=None,
timeout=None,
raise_exception=False):
"""
@summary: Waits for compute resource deletes
@param resource_id_list: uuids of the compute resources to be deleted
@type resource_id_list: List
@param resource: compute resource like servers, ip associations, etc.
@type resource: String
@param delete_method: method used to delete the resource
@type delete_method: behavior or client method
@param get_method: method used to get the resource
@type get_method: behavior or client method
@param interval_time: Seconds to wait between polling
@type interval_time: Integer
@param timeout: The amount of time in seconds to wait before aborting
@type timeout: Integer
@param raise_exception: flag to raise an exception if deletes fail
@type raise_exception: bool
"""
interval_time = (interval_time
or self.compute.servers.config.server_status_interval)
timeout = timeout or self.compute.servers.config.server_build_timeout
end_time = time.time() + timeout
for resource_id in resource_id_list:
delete_method(resource_id)
while time.time() < end_time:
for resource_id in resource_id_list:
resp = get_method(resource_id)
if (resp.status_code == ComputeResponseCodes.NOT_FOUND
and resource_id in resource_id_list):
resource_id_list.remove(resource_id)
if not resource_id_list:
break
time.sleep(interval_time)
else:
msg = ('Wait for compute {0} resource delete {0} seconds timeout '
'for the expected resource get HTTP {1} status code for '
'resources: {2}').format(resource, timeout,
ComputeResponseCodes.NOT_FOUND,
resource_id_list)
self._log.info(msg)
if raise_exception:
raise TimeoutException(msg)
def wait_for_task_status(self,
task_id,
desired_status,
interval_time=10,
timeout=1200):
"""
@summary: Waits for a task to reach a desired status
@param task_id: Task id to evaluate
@type task_id: UUID
@param desired_status: Expected final status of task
@type desired_status: String
@param interval_time: Amount of time in seconds to wait between polling
@type interval_time: Integer
@param timeout: Amount of time in seconds to wait before aborting
@type timeout: Integer
@return: Task
@rtype: Object
"""
interval_time = interval_time or self.config.task_status_interval
timeout = timeout or self.config.task_timeout
end_time = time.time() + timeout
while time.time() < end_time:
resp = self.client.get_task_details(task_id)
task = resp.entity
if ((task.status.lower() == TaskStatus.FAILURE
and desired_status != TaskStatus.FAILURE)
or (task.status.lower() == TaskStatus.SUCCESS
and desired_status != TaskStatus.SUCCESS)):
raise BuildErrorException(
'Task with uuid {0} entered {1} status. Task responded '
'with the message {2}'.format(
task.id_, task.status, task.message.replace('\\', '')))
if task.status == desired_status:
break
time.sleep(interval_time)
else:
raise TimeoutException(
'Failed to reach the {0} status after {1} seconds for task '
'with uuid {2}'.format(desired_status, timeout, task_id))
if (task is not None and task.type_ == TaskTypes.IMPORT
and task.status.lower() == TaskStatus.SUCCESS):
self.resources.add(task.result.image_id, self.client.delete_image)
return task
def wait_for_image_status(self, image_id, desired_status,
interval_time=None, timeout=None):
"""
@summary: Waits for a image to reach a desired status
@param image_id: The uuid of the image
@type image_id: String
@param desired_status: The desired final status of the image
@type desired_status: String
@param interval_time: The amount of time in seconds to wait
between polling
@type interval_time: Integer
@param interval_time: The amount of time in seconds to wait
before aborting
@type interval_time: Integer
@return: Response object containing response and the image
domain object
@rtype: requests.Response
"""
interval_time = interval_time or self.config.image_status_interval
timeout = timeout or self.config.snapshot_timeout
end_time = time.time() + timeout
while time.time() < end_time:
resp = self.images_client.get_image(image_id)
image = resp.entity
if image.status.lower() == ImageStates.ERROR.lower():
raise BuildErrorException(
'Build failed. Image with UUID {0} '
'entered ERROR status.'.format(image.id))
if image.status.lower() == ImageStates.DELETED.lower():
raise BuildErrorException(
'Build failed. Image with UUID {0} '
'entered DELETED status.'.format(image.id))
if image.status == desired_status:
break
time.sleep(interval_time)
else:
raise TimeoutException(
"wait_for_image_status ran for {0} seconds and did not "
"observe image {1} reach the {2} status.".format(
timeout, image_id, desired_status))
return resp
def wait_for_image_status(self,
image_id,
desired_status,
interval_time=15,
timeout=900):
"""
@summary: Wait for a image to reach a desired status
@param image_id: Image id to evaluate
@type image_id: UUID
@param desired_status: Expected final status of image
@type desired_status: String
@param interval_time: Amount of time in seconds to wait between polling
@type interval_time: Integer
@param timeout: Amount of time in seconds to wait before aborting
@type timeout: Integer
@return: Resp
@rtype: Object
"""
interval_time = interval_time or self.config.image_status_interval
timeout = timeout or self.config.snapshot_timeout
end_time = time.time() + timeout
while time.time() < end_time:
resp = self.client.get_image_details(image_id)
image = resp.entity
if image.status.lower() == ImageStatus.ERROR.lower():
raise BuildErrorException("Build failed. Image with uuid {0} "
"entered ERROR status.".format(
image.id))
if image.status == desired_status:
break
time.sleep(interval_time)
else:
raise TimeoutException(
"wait_for_image_status ran for {0} seconds and did not "
"observe image {1} reach the {2} status.".format(
timeout, image_id, desired_status))
return resp
def wait_for_image_status(self,
image_id,
desired_status,
interval_time=15,
timeout=900):
"""
@summary: Wait for a image to reach a desired status
@param image_id: Image id to evaluate
@type image_id: UUID
@param desired_status: Expected final status of image
@type desired_status: String
@param interval_time: Amount of time in seconds to wait between polling
@type interval_time: Integer
@param timeout: Amount of time in seconds to wait before aborting
@type timeout: Integer
@return: Resp
@rtype: Object
"""
interval_time = interval_time or self.config.image_status_interval
timeout = timeout or self.config.snapshot_timeout
end_time = time.time() + timeout
while time.time() < end_time:
resp = self.client.get_image_details(image_id)
image = self.verify_resp(resp, 'get image details', image_id)
if image.status.lower() == ImageStatus.ERROR.lower():
raise BuildErrorException(
'Image with the uuid {0} entered ERROR '
'status.'.format(image_id))
if image.status == desired_status:
break
time.sleep(interval_time)
else:
raise TimeoutException(
'Image with the uuid {0} did not reach the {1} status within '
'{2} seconds.'.format(image_id, desired_status, timeout))
return resp
def wait_for_server_status(self, server_id, desired_status,
interval_time=None, timeout=None):
"""
@summary: Waits for a server to reach a desired status
@param server_id: The uuid of the server
@type server_id: String
@param desired_status: The desired final status of the server
@type desired_status: String
@param interval_time: The amount of time in seconds to wait
between polling
@type interval_time: Integer
@param interval_time: The amount of time in seconds to wait
before aborting
@type interval_time: Integer
@return: Response object containing response and the server
domain object
@rtype: requests.Response
"""
interval_time = interval_time or self.config.server_status_interval
timeout = timeout or self.config.server_build_timeout
end_time = time.time() + timeout
while time.time() < end_time:
resp = self.servers_client.get_server(server_id)
server = resp.entity
if server.status.lower() == ServerStates.ERROR.lower():
raise BuildErrorException(
'Build failed. Server with uuid %s entered ERROR status.'
% server.id)
if server.status == desired_status:
break
time.sleep(interval_time)
else:
raise TimeoutException(
"wait_for_server_status ran for {0} seconds and did not "
"observe the server achieving the {1} status.".format(
timeout, desired_status))
return resp
def wait_for_launched_at(self, server_id, interval_time=10, timeout=200):
'''
@summary: Polls Launch launched_at field until it is populated
@param server_id: The uuid of the instance
@type server_id: String
@param interval_time: Time in seconds to wait between tries
@type inverval_time: Int
@param timeout: Time in seconds before timing out
@type timepout: Int
'''
launch_resp = self.list_launches_for_uuid(instance=server_id)
launches = launch_resp.entity
# Go through each of the launches and check that
# the launched_at attribute exists and is populated
for launch_obj in launches:
found_launched_at = False
time_waited = 0
while ((not found_launched_at
or not hasattr(launch_obj, 'launched_at'))
and (time_waited <= timeout)):
resp = self.list_launches_for_uuid(instance=server_id)
items = resp.entity
# Iterate over response and match on launch id
items = [item for item in items if item.id_ == launch_obj.id_]
try:
found_launched_at = items[0].launched_at
except AttributeError:
self._log("Did not find launched at this time around.")
pass
time.sleep(interval_time)
time_waited += interval_time
if time_waited > timeout:
raise TimeoutException(
"Timed Out. Server with uuid {0} timed "
"out waiting for Launch entry launched_at field to be "
"populated after {1} seconds. response: {2}".format(
server_id, timeout, launch_resp))
return launch_resp
def wait_for_image_resp_code(self,
image_id,
response_code,
interval_time=None,
timeout=None):
"""
@summary: Waits for a image to reach a desired status. Primarily
as a polling mechanism to determine when a new image
registers in Glance
@param image_id: The uuid of the image
@type image_id: String
@param response_code: The desired response code
@type response_code: String
@param interval_time: The amount of time in seconds to wait
between polling
@type interval_time: Integer
@param interval_time: The amount of time in seconds to wait
before aborting
@type interval_time: Integer
@return: Response object containing response and the image
domain object
@rtype: requests.Response
"""
interval_time = interval_time or self.config.image_status_interval
timeout = timeout or self.config.snapshot_timeout
end_time = time.time() + timeout
while time.time() < end_time:
resp = self.images_client.get_image(image_id)
if resp.status_code == response_code:
break
time.sleep(interval_time)
else:
raise TimeoutException(
"wait_for_image_resp_code ran for {0} seconds and did not "
"receive a response with status {1} for image {2}.".format(
timeout, response_code, image_id))
return resp
def wait_for_task_status(self,
task_id,
desired_status,
interval_time=None,
timeout=None):
"""@summary: Waits for a task to reach a desired status"""
interval_time = interval_time or self.config.task_status_interval
timeout = timeout or self.config.task_timeout
end_time = time.time() + timeout
while time.time() < end_time:
resp = self.client.get_task(task_id)
task = resp.entity
if ((task.status.lower() == TaskStatus.FAILURE
and desired_status != TaskStatus.FAILURE)
or (task.status.lower() == TaskStatus.SUCCESS
and desired_status != TaskStatus.SUCCESS)):
raise BuildErrorException(
'Task with uuid {0} entered {1} status. Task responded '
'with the message {2}'.format(
task.id_, task.status, task.message.replace('\\', '')))
if task.status == desired_status:
break
time.sleep(interval_time)
else:
raise TimeoutException(
'Failed to reach the {0} status after {1} seconds for task '
'with uuid {2}'.format(desired_status, timeout, task_id))
if (task is not None and task.type_ == TaskTypes.IMPORT
and task.status.lower() == TaskStatus.SUCCESS):
self.resources.add(task.result.image_id, self.client.delete_image)
return task
def get_remote_instance_client(self,
server,
config=None,
ip_address=None,
username=None,
password=None,
key=None,
auth_strategy=None):
"""
@summary: Gets an client of the server
@param server: Instance uuid id of the server
@type server: String
@param ip_address: IPv4 address of the server
@type ip_address: String
@param username: Valid user of the server
@type username: String
@param password: Valid user password of the server
@type password: String
@return: Either IPv4 or IPv6 address of instance
@rtype: String
"""
if ip_address is None:
network = server.addresses.get_by_name(config.network_for_ssh)
if config.ip_address_version_for_ssh == 4:
ip_address = network.ipv4
elif config.ip_address_version_for_ssh == 6:
ip_address = network.ipv6
# Get Server Image ID
if server.image:
image_id = server.image.id
else:
image_id = self.images_config.primary_image
# Get the Server Image
image = self.images_client.get_image(image_id).entity
if image.metadata.get('os_type', '').lower() == 'windows':
# Importing just in time in case WinRM plugin is not installed
# (todo) dwalleck: Handle this more cleanly
from cloudcafe.compute.common.clients.remote_instance.windows.\
windows_client import WindowsClient
client = WindowsClient
else:
# Importing just in time in case SSH plugin is not installed
# (todo) dwalleck: Handle this more cleanly
from cloudcafe.compute.common.clients.remote_instance.linux.\
linux_client import LinuxClient
client = LinuxClient
user = self.images_config.primary_image_default_user
strategy = auth_strategy or self.config.instance_auth_strategy.lower()
try:
if InstanceAuthStrategies.PASSWORD in strategy:
if password is None:
password = server.admin_pass
return client(
ip_address=ip_address,
username=user,
password=password,
connection_timeout=self.config.connection_timeout)
else:
return client(
ip_address=ip_address,
username=user,
key=key,
connection_timeout=self.config.connection_timeout)
except TimeoutException:
raise TimeoutException(
'Unable to ping server {id} at address {address} '
'within the allowed time of {timeout} seconds. '
'Test unable to proceed.'.format(
id=server.id,
address=ip_address,
timeout=self.config.connection_timeout))
except SshConnectionException:
raise SshConnectionException(
'Able to ping server {id} at {address}, but unable to '
'connect via ssh within the allowed time of {timeout} '
'seconds. Test unable to proceed.'.format(
id=server.id,
address=ip_address,
timeout=self.config.connection_timeout))
