def ensure_server(self, status='ACTIVE'):
try:
server_id: str = self.stack.server_id
nova.get_server(server_id=server_id)
except heat.HeatStackNotFound:
tobiko.setup_fixture(self.stack)
except nova.ServerNotFoundError:
tobiko.reset_fixture(self.stack)
return self.stack.ensure_server_status(status=status)
def get_amphora_compute_node(loadbalancer_id: str,
lb_port: int,
lb_protocol: str,
ip_address: str) -> (
topology.OpenStackTopologyNode):
"""Gets the compute node which hosts the LB amphora
This function finds the Overcloud compute node which
hosts the amphora. In case there are more than 1 amphora
(e.g. if the LB's topology is Active/standby), so the compute node which
hosts the master amphora will be returned.
:param loadbalancer_id (str): The loadbalancer ID.
:param lb_port (int): The loadbalancer port.
:param lb_protocol (str): The loadbalancer protocol.
:param ip_address (str): The ip adress of the loadbalancer.
:return (TripleoTopologyNode): The compute node which hosts the Amphora.
"""
amphorae = list_amphorae(loadbalancer_id)
if len(amphorae) > 1: # For a high available LB
amphora = get_master_amphora(amphorae=amphorae,
lb_port=lb_port,
lb_protocol=lb_protocol,
ip_address=ip_address)
else:
amphora = amphorae[0]
server = nova.get_server(amphora['compute_id'])
hostname = getattr(server, 'OS-EXT-SRV-ATTR:hypervisor_hostname')
return topology.get_openstack_node(hostname=hostname)
def vm_floating_ip(vm_id):
"""input: vm_id
output it's floating ip"""
vm = nova.get_server(vm_id)
floating_ip = nova.list_server_ip_addresses(
vm, address_type='floating').first
return floating_ip
def validate_created_stack(self):
stack = super().validate_created_stack()
server = nova.get_server(self.server_id)
if server.status != 'SHUTOFF':
if server.status != 'ACTIVE':
try:
nova.activate_server(server)
except nova.WaitForServerStatusTimeout as ex:
raise heat.InvalidStackError(name=self.stack_name) from ex
return stack
def test_servers_creation(self):
all_servers_ids = {server.id for server in nova.list_servers()}
stacks = tests.test_servers_creation()
self.assertEqual(2, len(stacks))
pid = os.getpid()
for i, stack in enumerate(stacks):
self.assertIsInstance(stack, tests.TestServerCreationStack)
class_name = tobiko.get_fixture_name(tests.TestServerCreationStack)
self.assertEqual(f"{class_name}-{pid}-{i}", stack.stack_name)
self.assertNotIn(stack.server_id, all_servers_ids)
self.assertEqual('ACTIVE', nova.get_server(stack.server_id).status)
def test_reboot_server_when_shutoff(self):
server = self.stack.ensure_server_status('SHUTOFF')
self.assertEqual('SHUTOFF', server.status)
ssh_client = self.stack.ssh_client
self.assert_is_not_connected(ssh_client)
self.assertRaises(sh.RebootHostTimeoutError,
sh.reboot_host,
ssh_client=ssh_client,
timeout=5.0)
self.assert_is_not_connected(ssh_client)
server = nova.get_server(self.stack.server_id)
self.assertEqual('SHUTOFF', server.status)
def test_2_delete_server(self):
server = self.ensure_server(status='ACTIVE')
self.stack.assert_is_reachable()
nova.delete_server(server.id)
for _ in tobiko.retry(timeout=60., interval=3.):
try:
server = nova.get_server(server_id=server.id)
except nova.ServerNotFoundError:
LOG.debug(f"Server '{server.id}' deleted")
break
else:
LOG.debug(f"Waiting for server deletion:\n"
f" - server.id='{server.id}'"
f" - server.status='{server.status}'")
self.stack.assert_is_unreachable()
def server_details(self):
return nova.get_server(self.server_id)
def test_server_creation_and_shutoff(self):
stack = tests.test_server_creation_and_shutoff()
self.assertIsInstance(stack, tests.TestServerCreationStack)
self.assertEqual('SHUTOFF', nova.get_server(stack.server_id).status)