def test_config_drive_network_metadata_dns_services(self):
"""
Verify Services of vendor networking metadata on config drive
Validate that there is at least one network information service in the
vendor metadata. Attempt to ping every service IP address in the network
information service(s). Validate that none of the ping attempts failed.
The following assertions occur:
- The number of network information services on the server is
greater than or equal to 1
- The list of failed ping attempts is empty.
"""
self.assertGreaterEqual(len(self.vendor_meta.network_info.services), 1,
msg='Expected config drive to have at least 1'
' network dns service configured')
service_ips = [service.address for service in
self.vendor_meta.network_info.services]
failed_pings = []
for service_ip in service_ips:
try:
PingClient.ping_until_reachable(
service_ip, timeout=60, interval_time=5)
except:
failed_pings.append(service_ip)
self.assertFalse(failed_pings, msg="Unable to reach the following "
"IP addresses: {0}".format(failed_pings))
def setUpClass(cls):
"""
Perform actions that setup the necessary resources for testing.
The following resources are created during the setup:
- Create a server in active state.
"""
super(StopServerTests, cls).setUpClass()
cls.connection_timeout = cls.servers_config.connection_timeout
cls.retry_interval = cls.servers_config.connection_retry_interval
key_resp = cls.keypairs_client.create_keypair(rand_name("key"))
assert key_resp.status_code is 200, ("Create keypair failed with response "
"code {0}".format(key_resp.status_code))
cls.key = key_resp.entity
cls.resources.add(cls.key.name,
cls.keypairs_client.delete_keypair)
cls.server = cls.server_behaviors.create_active_server(
key_name=cls.key.name).entity
cls.resources.add(cls.server.id, cls.servers_client.delete_server)
cls.ping_ip = cls.server.addresses.get_by_name(
cls.servers_config.network_for_ssh).ipv4
PingClient.ping_until_reachable(
cls.ping_ip, timeout=cls.connection_timeout,
interval_time=cls.retry_interval)
def __init__(self,
ip_address,
username='******',
password=None,
key=None,
connection_timeout=600,
retry_interval=10):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
# Verify the IP address has a valid format
try:
IP(ip_address)
except ValueError:
raise InvalidAddressFormat(ip_address)
# Verify the server can be pinged before attempting to connect
PingClient.ping_until_reachable(ip_address,
timeout=connection_timeout,
interval_time=retry_interval)
self.ip_address = ip_address
self.username = username
self.password = password
self.client = WinRMClient(username=username,
password=password,
host=ip_address)
connected = self.client.connect_with_retries()
if not connected:
raise WinRMConnectionException(ip_address=ip_address)
def __init__(self, ip_address, username='******',
password=None, key=None, connection_timeout=600,
retry_interval=10):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
# Verify the IP address has a valid format
try:
IP(ip_address)
except ValueError:
raise InvalidAddressFormat(ip_address)
# Verify the server can be pinged before attempting to connect
PingClient.ping_until_reachable(ip_address,
timeout=connection_timeout,
interval_time=retry_interval)
self.ip_address = ip_address
self.username = username
self.password = password
self.client = WinRMClient(
username=username, password=password, host=ip_address)
connected = self.client.connect_with_retries()
if not connected:
raise WinRMConnectionException(ip_address=ip_address)
def test_suspend_reboot_hard_server(self):
"""
Verify that a server reboot after suspend does not restore it.
Will suspend the server and waits for the server state to be
"PAUSED" followed by pinging the ip until its unreachable. Tries to
reboot the server and expects a "ActionInProgress" exception to be
raised. Then will ping until its unreachable again.
The following assertions occur:
- 202 status code response from the stop server call.
- Expect a "ActionInProgress" exception is raised when rebooting.
"""
ping_ip = self.get_accessible_ip_address(self.server)
response = self.admin_servers_client.suspend_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.PAUSED)
PingClient.ping_until_unreachable(
ping_ip, timeout=60, interval_time=5)
with self.assertRaises(ActionInProgress):
self.servers_client.reboot(self.server.id,
NovaServerRebootTypes.HARD)
PingClient.ping_until_unreachable(
ping_ip, timeout=60, interval_time=5)
def test_reboot_hard_suspended_server(self):
"""
Verify that a server reboot after suspend does not restore it.
Will suspend the server and waits for the server state to be
suspended followed by pinging the ip until it's unreachable. Tries to
reboot the server and expects a "Forbidden" exception to be raised.
Then will ping until it's unreachable again.
The following assertions occur:
- 202 status code response from the stop server call.
- 202 status code response from the start server call.
- Get remote instance client returns true (successful connection).
"""
self.ping_ip = self.server.addresses.get_by_name(
self.servers_config.network_for_ssh).ipv4
response = self.admin_servers_client.suspend_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.SUSPENDED)
PingClient.ping_until_unreachable(
self.ping_ip, timeout=60, interval_time=5)
with self.assertRaises(Forbidden):
self.servers_client.reboot(self.server.id,
NovaServerRebootTypes.HARD)
PingClient.ping_until_unreachable(
self.ping_ip, timeout=60, interval_time=5)
def test_suspend_delete_server(self):
"""
Verify that a server can be suspended and then deleted by the user.
Will suspend the server and waits for the server state to be
suspended followed by pinging the ip until it's unreachable. Deletes
the server as the user and the server was deleted successfully.
The following assertions occur:
- 202 status code response from the stop server call.
- 204 status code response from the start server call.
- Verify the server was deleted successfully.
"""
self.ping_ip = self.server.addresses.get_by_name(
self.servers_config.network_for_ssh).ipv4
response = self.admin_servers_client.suspend_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.SUSPENDED)
PingClient.ping_until_unreachable(
self.ping_ip, timeout=60, interval_time=5)
delete_response = self.servers_client.delete_server(self.server.id)
self.assertEqual(delete_response.status_code, 204,
msg="Delete server {0} failed with response code "
"{1}".format(self.server.id, delete_response.status_code))
self.server_behaviors.wait_for_server_to_be_deleted(self.server.id)
def test_suspend_delete_server(self):
"""
Verify that a server can be suspended and then deleted by the user.
Will suspend the server and waits for the server state to be
suspended followed by pinging the ip until it's unreachable. Deletes
the server as the user and the server was deleted successfully.
The following assertions occur:
- 202 status code response from the stop server call.
- 204 status code response from the start server call.
- Verify the server was deleted successfully.
"""
self.ping_ip = self.server.addresses.get_by_name(
self.servers_config.network_for_ssh).ipv4
response = self.admin_servers_client.suspend_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.SUSPENDED)
PingClient.ping_until_unreachable(self.ping_ip,
timeout=60,
interval_time=5)
delete_response = self.servers_client.delete_server(self.server.id)
self.assertEqual(delete_response.status_code,
204,
msg="Delete server {0} failed with response code "
"{1}".format(self.server.id,
delete_response.status_code))
self.server_behaviors.wait_for_server_to_be_deleted(self.server.id)
def test_pause_reboot_server(self):
"""
Verify that a server reboot during pause does not restore it.
First step is getting the IP address for communication based on the
configuration. We pause the instance making sure that
there is no connectivity. After that we check what happens when we
reboot the instance and expecting a "Forbidden" exception and finally
making sure the connectivity is still down.
This test will be successful if:
- Ensures a 202 response is returned from the pause call.
- Pings the server expecting an unreachable destination.
- Pings the server again expecting an unreachable destination
after the failed reboot.
"""
self.ping_ip = self.get_ip_address_for_live_communication(self.server)
response = self.admin_servers_client.pause_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.PAUSED)
PingClient.ping_until_unreachable(
self.ping_ip, timeout=60, interval_time=5)
with self.assertRaises(Forbidden):
self.servers_client.reboot(self.server.id,
NovaServerRebootTypes.HARD)
PingClient.ping_until_unreachable(
self.ping_ip, timeout=60, interval_time=5)
def test_reboot_hard_suspended_server(self):
"""
Verify that a server reboot after suspend does not restore it.
Will suspend the server and waits for the server state to be
suspended followed by pinging the ip until it's unreachable. Tries to
reboot the server and expects a "Forbidden" exception to be raised.
Then will ping until it's unreachable again.
The following assertions occur:
- 202 status code response from the stop server call.
- 202 status code response from the start server call.
- Get remote instance client returns true (successful connection).
"""
self.ping_ip = self.server.addresses.get_by_name(
self.servers_config.network_for_ssh).ipv4
response = self.admin_servers_client.suspend_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.SUSPENDED)
PingClient.ping_until_unreachable(self.ping_ip,
timeout=60,
interval_time=5)
with self.assertRaises(Forbidden):
self.servers_client.reboot(self.server.id,
NovaServerRebootTypes.HARD)
PingClient.ping_until_unreachable(self.ping_ip,
timeout=60,
interval_time=5)
def setUpClass(cls):
"""
Perform actions that setup the necessary resources for testing.
The following resources are created during the setup:
- Create a server in active state.
"""
super(StopServerTests, cls).setUpClass()
cls.connection_timeout = cls.servers_config.connection_timeout
cls.retry_interval = cls.servers_config.connection_retry_interval
key_resp = cls.keypairs_client.create_keypair(rand_name("key"))
assert key_resp.status_code is 200, ("Create keypair failed with response "
"code {0}".format(key_resp.status_code))
cls.key = key_resp.entity
cls.resources.add(cls.key.name,
cls.keypairs_client.delete_keypair)
cls.server = cls.server_behaviors.create_active_server(
key_name=cls.key.name).entity
cls.resources.add(cls.server.id, cls.servers_client.delete_server)
cls.ping_ip = cls.server.addresses.get_by_name(
cls.servers_config.network_for_ssh).ipv4
PingClient.ping_until_reachable(
cls.ping_ip, timeout=cls.connection_timeout,
interval_time=cls.retry_interval)
def test_pause_unpause_server(self):
"""Verify that a server can be paused and then unpaused successfully"""
response = self.admin_servers_client.pause_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.PAUSED)
PingClient.ping_until_unreachable(
self.ping_ip, timeout=60, interval_time=5)
response = self.admin_servers_client.unpause_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.ACTIVE)
PingClient.ping_until_reachable(
self.ping_ip, timeout=60, interval_time=5)
self.assertTrue(self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config),
"Unable to connect to active server {0} after unpausing".format(
self.server.id))
def test_config_drive_network_metadata_dns_services(self):
"""
Verify Services of vendor networking metadata on config drive
Validate that there is at least one network information service in the
vendor metadata. Attempt to ping every service IP address in the network
information service(s). Validate that none of the ping attempts failed.
The following assertions occur:
- The number of network information services on the server is
greater than or equal to 1
- The list of failed ping attempts is empty.
"""
self.assertGreaterEqual(len(self.vendor_meta.network_info.services),
1,
msg='Expected config drive to have at least 1'
' network dns service configured')
service_ips = [
service.address
for service in self.vendor_meta.network_info.services
]
failed_pings = []
for service_ip in service_ips:
try:
PingClient.ping_until_reachable(service_ip,
timeout=60,
interval_time=5)
except:
failed_pings.append(service_ip)
self.assertFalse(failed_pings,
msg="Unable to reach the following "
"IP addresses: {0}".format(failed_pings))
def test_stop_start_server(self):
"""Verify that a server can be stopped and then started"""
response = self.admin_servers_client.stop_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.SHUTOFF)
PingClient.ping_until_unreachable(
self.ping_ip, timeout=60, interval_time=5)
response = self.admin_servers_client.start_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.ACTIVE)
PingClient.ping_until_reachable(
self.ping_ip, timeout=60, interval_time=5)
self.assertTrue(self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config),
"Unable to connect to active server {0} after stopping "
"and starting".format(self.server.id))
def __init__(self,
ip_address=None,
username='******',
password=None,
key=None,
connection_timeout=600,
retry_interval=10):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
self.ip_address = ip_address
self.username = username
self.password = password
self.connection_timeout = connection_timeout
# Verify the IP address has a valid format
try:
IP(ip_address)
except ValueError:
raise InvalidAddressFormat(ip_address)
# Verify the server can be pinged before attempting to connect
PingClient.ping_until_reachable(ip_address,
timeout=connection_timeout,
interval_time=retry_interval)
if key is not None:
auth_strategy = SSHAuthStrategy.KEY_STRING
else:
auth_strategy = SSHAuthStrategy.PASSWORD
allow_agent = True
if not key:
allow_agent = False
self.ssh_client = SSHClient(username=self.username,
password=self.password,
host=self.ip_address,
tcp_timeout=20,
auth_strategy=auth_strategy,
look_for_keys=False,
key=key,
allow_agent=allow_agent)
self.ssh_client.connect_with_timeout(cooldown=20,
timeout=connection_timeout)
if not self.ssh_client.is_connected():
message = ('SSH timeout after {timeout} seconds: '
'Could not connect to {ip_address}.')
raise SshConnectionException(
message.format(timeout=connection_timeout,
ip_address=ip_address))
def _pinger(ip, delta, conn_flag, connection_timeout):
"""
Pinger function which is responsible for connectivity check starting before
migrate starts and finishing 10 seconds after migrate finished
If we do not get connectivity lost at all we put 0 for the delta
otherwise we calculate the delta time without connectivity
"""
ping_resp = PingClient.ping_until_unreachable(
ip, timeout=connection_timeout, interval_time=1)
conn_flag.put("Connection lost")
if ping_resp is None:
t0 = time()
ping_reach = PingClient.ping_until_reachable(
ip, timeout=connection_timeout, interval_time=1)
time_pass = time() - t0
delta.put(time_pass)
else:
delta.put(0)
def test_pause_unpause_server(self):
"""
Verify that a server can be paused and then unpaused successfully.
First step is getting the IP address for communication based on the
configuration, after that we pause the instance making sure that
there is no connectivity. After that we check what happens when we
unpause the instance and making sure the connectivity is restored.
The following assertions occur:
- Ensures a 202 response is returned from the pause call.
- Ensures a 202 response is returned from the unpause call.
- Pings the server expecting a reachable destination.
- Get the remote instance of the server returns true.
"""
self.ping_ip = self.get_ip_address_for_live_communication(self.server)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.ACTIVE)
response = self.admin_servers_client.pause_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.PAUSED)
PingClient.ping_until_unreachable(
self.ping_ip, timeout=60, interval_time=5)
response = self.admin_servers_client.unpause_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.ACTIVE)
PingClient.ping_until_reachable(
self.ping_ip, timeout=60, interval_time=5)
self.assertTrue(self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config),
"Unable to connect to active server {0} after unpausing".format(
self.server.id))
def test_pause_unpause_server(self):
"""
Verify that a server can be paused and then unpaused successfully.
First step is getting the IP address for communication based on the
configuration, after that we pause the instance making sure that
there is no connectivity. After that we check what happens when we
unpause the instance and making sure the connectivity is restored.
The following assertions occur:
- A 202 response is returned from the pause call.
- A 202 response is returned from the unpause call.
- The remote instance client is able to connect to
the instance after it is unpaused.
"""
self.ping_ip = self.get_accessible_ip_address(self.server)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.ACTIVE)
response = self.admin_servers_client.pause_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.PAUSED)
PingClient.ping_until_unreachable(
self.ping_ip, timeout=60, interval_time=5)
response = self.admin_servers_client.unpause_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.ACTIVE)
PingClient.ping_until_reachable(
self.ping_ip, timeout=60, interval_time=5)
self.assertTrue(self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config),
"Unable to connect to active server {0} after unpausing".format(
self.server.id))
def test_suspend_resume_server(self):
"""
Verify that a server can be suspended and then resumed.
Will suspend the server and waits for the server state to be
suspended followed by pinging the ip until it's unreachable. Resumes
the server and waits for the server state to be active followed
by pinging the server until it's reachable. Then retrieve the instance.
The following assertions occur:
- 202 status code response from the stop server call.
- 202 status code response from the start server call.
- Get remote instance client returns true (successful connection).
"""
self.ping_ip = self.server.addresses.get_by_name(
self.servers_config.network_for_ssh).ipv4
response = self.admin_servers_client.suspend_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.SUSPENDED)
PingClient.ping_until_unreachable(self.ping_ip,
timeout=60,
interval_time=5)
response = self.admin_servers_client.resume_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.ACTIVE)
PingClient.ping_until_reachable(self.ping_ip,
timeout=600,
interval_time=5)
self.assertTrue(
self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config, key=self.key.private_key),
"Unable to connect to active server {0} after suspending "
"and resuming".format(self.server.id))
def _pinger(ip, delta, conn_flag, connection_timeout):
"""
Pinger function which is responsible for connectivity check starting before
migrate starts and finishing 10 seconds after migrate finished
If we do not get connectivity lost at all we put 0 for the delta
otherwise we calculate the delta time without connectivity
"""
ping_resp = PingClient.ping_until_unreachable(ip,
timeout=connection_timeout,
interval_time=1)
conn_flag.put("Connection lost")
if ping_resp is None:
t0 = time()
ping_reach = PingClient.ping_until_reachable(
ip, timeout=connection_timeout, interval_time=1)
time_pass = time() - t0
delta.put(time_pass)
else:
delta.put(0)
def _is_instance_reachable(ip_address, retry_interval, timeout):
"""Verify the server can be pinged."""
start = int(time.time())
reachable = False
while not reachable:
reachable = PingClient.ping(ip_address)
if reachable:
return True
time.sleep(retry_interval)
if int(time.time()) - start >= timeout:
return False
def __init__(self, ip_address=None, username='******', password=None,
key=None, connection_timeout=600, retry_interval=10):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
self.ip_address = ip_address
self.username = username
self.password = password
self.connection_timeout = connection_timeout
# Verify the IP address has a valid format
try:
IP(ip_address)
except ValueError:
raise InvalidAddressFormat(ip_address)
# Verify the server can be pinged before attempting to connect
PingClient.ping_until_reachable(ip_address,
timeout=connection_timeout,
interval_time=retry_interval)
if key is not None:
auth_strategy = SSHAuthStrategy.KEY_STRING
else:
auth_strategy = SSHAuthStrategy.PASSWORD
allow_agent = True
if not key:
allow_agent = False
self.ssh_client = SSHClient(
username=self.username, password=self.password,
host=self.ip_address, tcp_timeout=20, auth_strategy=auth_strategy,
look_for_keys=False, key=key, allow_agent=allow_agent)
self.ssh_client.connect_with_timeout(
cooldown=20, timeout=connection_timeout)
if not self.ssh_client.is_connected():
message = ('SSH timeout after {timeout} seconds: '
'Could not connect to {ip_address}.')
raise SshConnectionException(message.format(
timeout=connection_timeout, ip_address=ip_address))
def test_stop_start_server(self):
"""
Verify that a server can be stopped and then started.
Will stop the server and waits for the server state to be shutoff
followed by pinging the ip until its unreachable. Start the server
back up and wait for the server state to be active followed by
pinging the server until its reachable. Then retrieve the instance.
The following assertions occur:
- 202 status code response from the stop server call.
- 202 status code response from the start server call.
- Get remote instance client returns true (successful connection).
"""
response = self.admin_servers_client.stop_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.SHUTOFF)
PingClient.ping_until_unreachable(self.ping_ip,
timeout=60,
interval_time=5)
response = self.admin_servers_client.start_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.ACTIVE)
PingClient.ping_until_reachable(self.ping_ip,
timeout=60,
interval_time=5)
self.assertTrue(
self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config),
"Unable to connect to active server {0} after stopping "
"and starting".format(self.server.id))
def test_suspend_resume_server(self):
"""
Verify that a server can be suspended and then resumed.
Will suspend the server and waits for the server state to be
suspended followed by pinging the ip until it's unreachable. Resumes
the server and waits for the server state to be active followed
by pinging the server until it's reachable. Then retrieve the instance.
The following assertions occur:
- 202 status code response from the stop server call.
- 202 status code response from the start server call.
- Get remote instance client returns true (successful connection).
"""
self.ping_ip = self.server.addresses.get_by_name(
self.servers_config.network_for_ssh).ipv4
response = self.admin_servers_client.suspend_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.SUSPENDED)
PingClient.ping_until_unreachable(
self.ping_ip, timeout=60, interval_time=5)
response = self.admin_servers_client.resume_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(
self.server.id, ServerStates.ACTIVE)
PingClient.ping_until_reachable(
self.ping_ip, timeout=600, interval_time=5)
self.assertTrue(self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config, key=self.key.private_key),
"Unable to connect to active server {0} after suspending "
"and resuming".format(self.server.id))
def test_stop_start_server(self):
"""
Verify that a server can be stopped and then started.
Will stop the server and waits for the server state to be shutoff
followed by pinging the ip until its unreachable. Start the server
back up and wait for the server state to be active followed by
pinging the server until its reachable. Then retrieve the instance.
The following assertions occur:
- 202 status code response from the stop server call.
- 202 status code response from the start server call.
- Get remote instance client returns true (successful connection).
"""
response = self.admin_servers_client.stop_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(self.server.id, ServerStates.SHUTOFF)
PingClient.ping_until_unreachable(
self.ping_ip, timeout=self.connection_timeout, interval_time=self.retry_interval
)
response = self.admin_servers_client.start_server(self.server.id)
self.assertEqual(response.status_code, 202)
self.admin_server_behaviors.wait_for_server_status(self.server.id, ServerStates.ACTIVE)
PingClient.ping_until_reachable(
self.ping_ip, timeout=self.connection_timeout, interval_time=self.retry_interval
)
self.assertTrue(
self.server_behaviors.get_remote_instance_client(
self.server, self.servers_config, key=self.key.private_key
),
"Unable to connect to active server {0} after stopping " "and starting".format(self.server.id),
)
def verify_server_reachable(cls, ip=None):
"""
@summary: Verify server connectivity with a basic ping check.
@param ip: IP address to ping.
Defaults to SSH IPv4 address if no IP is provided
@type ip: string
"""
if not ip:
ip = cls.server.addresses.get_by_name(
cls.servers_config.network_for_ssh).ipv4
if not PingClient.ping(ip):
raise ServerUnreachable(
"Server {id} was not pingable at {ip}".format(id=cls.server.id,
ip=ip))
def verify_server_reachable(cls, ip=None):
"""
@summary: Verify server connectivity with a basic ping check.
@param ip: IP address to ping.
Defaults to SSH IPv4 address if no IP is provided
@type ip: string
"""
if not ip:
ip = cls.server.addresses.get_by_name(
cls.servers_config.network_for_ssh).ipv4
if not PingClient.ping(ip):
raise ServerUnreachable(
"Server {id} was not pingable at {ip}".format(
id=cls.server.id, ip=ip))
def __init__(self,
ip_address=None,
username='******',
password=None,
key=None,
connection_timeout=600,
retry_interval=10):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
if ip_address is None:
raise ServerUnreachable("None")
self.ip_address = ip_address
self.username = username
self.password = password
# Verify the server can be pinged before attempting to connect
start = int(time.time())
reachable = False
while not reachable:
reachable = PingClient.ping(ip_address)
if reachable:
break
time.sleep(retry_interval)
if int(time.time()) - start >= connection_timeout:
raise ServerUnreachable(ip_address)
if key is not None:
auth_strategy = SSHAuthStrategy.KEY_STRING
else:
auth_strategy = SSHAuthStrategy.PASSWORD
self.ssh_client = SSHBehaviors(username=self.username,
password=self.password,
host=self.ip_address,
tcp_timeout=20,
auth_strategy=auth_strategy,
look_for_keys=False,
key=key)
self.ssh_client.connect_with_timeout(cooldown=20,
timeout=connection_timeout)
if not self.ssh_client.is_connected():
message = ('SSH timeout after {timeout} seconds: '
'Could not connect to {ip_address}.')
raise SshConnectionException(
message.format(timeout=connection_timeout,
ip_address=ip_address))
def __init__(self, ip_address=None, username='******', password=None,
key=None, connection_timeout=600, retry_interval=10):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
if ip_address is None:
raise ServerUnreachable("None")
self.ip_address = ip_address
self.username = username
self.password = password
self.connection_timeout = connection_timeout
# Verify the server can be pinged before attempting to connect
start = int(time.time())
reachable = False
while not reachable:
reachable = PingClient.ping(ip_address)
if reachable:
break
time.sleep(retry_interval)
if int(time.time()) - start >= connection_timeout:
raise ServerUnreachable(
'Could not reach the server at {ip_address}'.format(
ip_address=ip_address))
if key is not None:
auth_strategy = SSHAuthStrategy.KEY_STRING
else:
auth_strategy = SSHAuthStrategy.PASSWORD
self.ssh_client = SSHClient(
username=self.username, password=self.password,
host=self.ip_address, tcp_timeout=20, auth_strategy=auth_strategy,
look_for_keys=False, key=key)
self.ssh_client.connect_with_timeout(
cooldown=20, timeout=connection_timeout)
if not self.ssh_client.is_connected():
message = ('SSH timeout after {timeout} seconds: '
'Could not connect to {ip_address}.')
raise SshConnectionException(message.format(
timeout=connection_timeout, ip_address=ip_address))