def resource_setup(cls):
super(ListServerFiltersTestJSON, cls).resource_setup()
network = cls.get_tenant_network()
if network:
cls.fixed_network_name = network.get('name')
else:
cls.fixed_network_name = None
network_kwargs = fixed_network.set_networks_kwarg(network)
cls.s1_name = data_utils.rand_name(cls.__name__ + '-instance')
cls.s1 = cls.create_test_server(name=cls.s1_name, **network_kwargs)
cls.s2_name = data_utils.rand_name(cls.__name__ + '-instance')
# If image_ref_alt is "" or None then we still want to boot a server
# but we rely on `testtools.skipUnless` decorator to actually skip
# the irrelevant tests.
cls.s2 = cls.create_test_server(name=cls.s2_name,
image_id=cls.image_ref_alt
or cls.image_ref)
cls.s3_name = data_utils.rand_name(cls.__name__ + '-instance')
cls.s3 = cls.create_test_server(name=cls.s3_name,
flavor=cls.flavor_ref_alt,
wait_until='ACTIVE')
waiters.wait_for_server_status(cls.client, cls.s1['id'], 'ACTIVE')
waiters.wait_for_server_status(cls.client, cls.s2['id'], 'ACTIVE')
def test_list_servers_filter_by_exist_host(self):
# Filter the list of servers by existent host
name = data_utils.rand_name(self.__class__.__name__ + '-server')
network = self.get_tenant_network()
network_kwargs = fixed_network.set_networks_kwarg(network)
# We need to create the server as an admin, so we can't use
# self.create_test_server() here as this method creates the server
# in the "primary" (i.e non-admin) tenant.
test_server, _ = compute.create_test_server(self.os_admin,
wait_until="ACTIVE",
name=name,
**network_kwargs)
self.addCleanup(self.client.delete_server, test_server['id'])
server = self.client.show_server(test_server['id'])['server']
self.assertEqual(server['status'], 'ACTIVE')
hostname = server['OS-EXT-SRV-ATTR:host']
params = {'host': hostname}
body = self.client.list_servers(**params)
servers = body['servers']
nonexistent_params = {'host': 'nonexistent_host'}
nonexistent_body = self.client.list_servers(**nonexistent_params)
nonexistent_servers = nonexistent_body['servers']
self.assertIn(test_server['id'], map(lambda x: x['id'], servers))
self.assertNotIn(test_server['id'],
map(lambda x: x['id'], nonexistent_servers))
def resource_setup(cls):
super(ListServerFiltersTestJSON, cls).resource_setup()
network = cls.get_tenant_network()
if network:
cls.fixed_network_name = network.get('name')
else:
cls.fixed_network_name = None
network_kwargs = fixed_network.set_networks_kwarg(network)
cls.s1_name = data_utils.rand_name(cls.__name__ + '-instance')
cls.s1 = cls.create_test_server(name=cls.s1_name, **network_kwargs)
cls.s2_name = data_utils.rand_name(cls.__name__ + '-instance')
# If image_ref_alt is "" or None then we still want to boot a server
# but we rely on `testtools.skipUnless` decorator to actually skip
# the irrelevant tests.
cls.s2 = cls.create_test_server(
name=cls.s2_name, image_id=cls.image_ref_alt or cls.image_ref)
cls.s3_name = data_utils.rand_name(cls.__name__ + '-instance')
cls.s3 = cls.create_test_server(name=cls.s3_name,
flavor=cls.flavor_ref_alt,
wait_until='ACTIVE')
waiters.wait_for_server_status(cls.client, cls.s1['id'],
'ACTIVE')
waiters.wait_for_server_status(cls.client, cls.s2['id'],
'ACTIVE')
def test_list_servers_filter_by_exist_host(self):
# Filter the list of servers by existent host
name = data_utils.rand_name(self.__class__.__name__ + '-server')
network = self.get_tenant_network()
network_kwargs = fixed_network.set_networks_kwarg(network)
# We need to create the server as an admin, so we can't use
# self.create_test_server() here as this method creates the server
# in the "primary" (i.e non-admin) tenant.
test_server, _ = compute.create_test_server(
self.os_admin, wait_until="ACTIVE", name=name, **network_kwargs)
self.addCleanup(self.client.delete_server, test_server['id'])
server = self.client.show_server(test_server['id'])['server']
self.assertEqual(server['status'], 'ACTIVE')
hostname = server['OS-EXT-SRV-ATTR:host']
params = {'host': hostname}
body = self.client.list_servers(**params)
servers = body['servers']
nonexistent_params = {'host': 'nonexistent_host'}
nonexistent_body = self.client.list_servers(**nonexistent_params)
nonexistent_servers = nonexistent_body['servers']
self.assertIn(test_server['id'], map(lambda x: x['id'], servers))
self.assertNotIn(test_server['id'],
map(lambda x: x['id'], nonexistent_servers))
def create_test_server(clients,
validatable=False,
validation_resources=None,
tenant_network=None,
wait_until=None,
volume_backed=False,
name=None,
flavor=None,
image_id=None,
**kwargs):
"""Common wrapper utility returning a test server.
This method is a common wrapper returning a test server that can be
pingable or sshable.
:param clients: Client manager which provides OpenStack Tempest clients.
:param validatable: Whether the server will be pingable or sshable.
:param validation_resources: Resources created for the connection to the
server. Include a keypair, a security group and an IP.
:param tenant_network: Tenant network to be used for creating a server.
:param wait_until: Server status to wait for the server to reach after
its creation.
:param volume_backed: Whether the server is volume backed or not.
If this is true, a volume will be created and
create server will be requested with
'block_device_mapping_v2' populated with below
values:
--------------------------------------------
bd_map_v2 = [{
'uuid': volume['volume']['id'],
'source_type': 'volume',
'destination_type': 'volume',
'boot_index': 0,
'delete_on_termination': True}]
kwargs['block_device_mapping_v2'] = bd_map_v2
---------------------------------------------
If server needs to be booted from volume with other
combination of bdm inputs than mentioned above, then
pass the bdm inputs explicitly as kwargs and image_id
as empty string ('').
:param name: Name of the server to be provisioned. If not defined a random
string ending with '-instance' will be generated.
:param flavor: Flavor of the server to be provisioned. If not defined,
CONF.compute.flavor_ref will be used instead.
:param image_id: ID of the image to be used to provision the server. If not
defined, CONF.compute.image_ref will be used instead.
:returns: a tuple
"""
# TODO(jlanoux) add support of wait_until PINGABLE/SSHABLE
if name is None:
name = data_utils.rand_name(__name__ + "-instance")
if flavor is None:
flavor = CONF.compute.flavor_ref
if image_id is None:
image_id = CONF.compute.image_ref
kwargs = fixed_network.set_networks_kwarg(tenant_network, kwargs) or {}
multiple_create_request = (max(kwargs.get('min_count', 0),
kwargs.get('max_count', 0)) > 1)
if CONF.validation.run_validation and validatable:
# As a first implementation, multiple pingable or sshable servers will
# not be supported
if multiple_create_request:
msg = ("Multiple pingable or sshable servers not supported at "
"this stage.")
raise ValueError(msg)
if 'security_groups' in kwargs:
kwargs['security_groups'].append(
{'name': validation_resources['security_group']['name']})
else:
try:
kwargs['security_groups'] = [{
'name':
validation_resources['security_group']['name']
}]
except KeyError:
LOG.debug("No security group provided.")
if 'key_name' not in kwargs:
try:
kwargs['key_name'] = validation_resources['keypair']['name']
except KeyError:
LOG.debug("No key provided.")
if CONF.validation.connect_method == 'floating':
if wait_until is None:
wait_until = 'ACTIVE'
if 'user_data' not in kwargs:
# If nothing overrides the default user data script then run
# a simple script on the host to print networking info. This is
# to aid in debugging ssh failures.
script = '''
#!/bin/sh
echo "Printing {user} user authorized keys"
cat ~{user}/.ssh/authorized_keys || true
'''.format(user=CONF.validation.image_ssh_user)
script_clean = textwrap.dedent(script).lstrip().encode('utf8')
script_b64 = base64.b64encode(script_clean)
kwargs['user_data'] = script_b64
if volume_backed:
volume_name = data_utils.rand_name(__name__ + '-volume')
volumes_client = clients.volumes_v2_client
params = {
'name': volume_name,
'imageRef': image_id,
'size': CONF.volume.volume_size
}
volume = volumes_client.create_volume(**params)
waiters.wait_for_volume_resource_status(volumes_client,
volume['volume']['id'],
'available')
bd_map_v2 = [{
'uuid': volume['volume']['id'],
'source_type': 'volume',
'destination_type': 'volume',
'boot_index': 0,
'delete_on_termination': True
}]
kwargs['block_device_mapping_v2'] = bd_map_v2
# Since this is boot from volume an image does not need
# to be specified.
image_id = ''
body = clients.servers_client.create_server(name=name,
imageRef=image_id,
flavorRef=flavor,
**kwargs)
# handle the case of multiple servers
if multiple_create_request:
# Get servers created which name match with name param.
body_servers = clients.servers_client.list_servers()
servers = \
[s for s in body_servers['servers'] if s['name'].startswith(name)]
else:
body = rest_client.ResponseBody(body.response, body['server'])
servers = [body]
# The name of the method to associate a floating IP to as server is too
# long for PEP8 compliance so:
assoc = clients.compute_floating_ips_client.associate_floating_ip_to_server
if wait_until:
for server in servers:
try:
waiters.wait_for_server_status(clients.servers_client,
server['id'], wait_until)
# Multiple validatable servers are not supported for now. Their
# creation will fail with the condition above (l.58).
if CONF.validation.run_validation and validatable:
if CONF.validation.connect_method == 'floating':
assoc(floating_ip=validation_resources['floating_ip']
['ip'],
server_id=servers[0]['id'])
except Exception:
with excutils.save_and_reraise_exception():
for server in servers:
try:
clients.servers_client.delete_server(server['id'])
except Exception:
LOG.exception('Deleting server %s failed',
server['id'])
for server in servers:
# NOTE(artom) If the servers were booted with volumes
# and with delete_on_termination=False we need to wait
# for the servers to go away before proceeding with
# cleanup, otherwise we'll attempt to delete the
# volumes while they're still attached to servers that
# are in the process of being deleted.
try:
waiters.wait_for_server_termination(
clients.servers_client, server['id'])
except Exception:
LOG.exception('Server %s failed to delete in time',
server['id'])
return body, servers
def resource_setup(cls):
super(ComputeServersRbacTest, cls).resource_setup()
cls.server = cls.create_test_server(wait_until='ACTIVE')
cls.tenant_network = fixed_network.set_networks_kwarg(
cls.get_tenant_network()
)
def create_test_server(clients, validatable=False, validation_resources=None,
tenant_network=None, wait_until=None,
volume_backed=False, name=None, flavor=None,
image_id=None, **kwargs):
"""Common wrapper utility returning a test server.
This method is a common wrapper returning a test server that can be
pingable or sshable.
:param clients: Client manager which provides OpenStack Tempest clients.
:param validatable: Whether the server will be pingable or sshable.
:param validation_resources: Resources created for the connection to the
server. Include a keypair, a security group and an IP.
:param tenant_network: Tenant network to be used for creating a server.
:param wait_until: Server status to wait for the server to reach after
its creation.
:param volume_backed: Whether the server is volume backed or not.
If this is true, a volume will be created and
create server will be requested with
'block_device_mapping_v2' populated with below
values:
--------------------------------------------
bd_map_v2 = [{
'uuid': volume['volume']['id'],
'source_type': 'volume',
'destination_type': 'volume',
'boot_index': 0,
'delete_on_termination': True}]
kwargs['block_device_mapping_v2'] = bd_map_v2
---------------------------------------------
If server needs to be booted from volume with other
combination of bdm inputs than mentioned above, then
pass the bdm inputs explicitly as kwargs and image_id
as empty string ('').
:param name: Name of the server to be provisioned. If not defined a random
string ending with '-instance' will be generated.
:param flavor: Flavor of the server to be provisioned. If not defined,
CONF.compute.flavor_ref will be used instead.
:param image_id: ID of the image to be used to provision the server. If not
defined, CONF.compute.image_ref will be used instead.
:returns: a tuple
"""
# TODO(jlanoux) add support of wait_until PINGABLE/SSHABLE
if name is None:
name = data_utils.rand_name(__name__ + "-instance")
if flavor is None:
flavor = CONF.compute.flavor_ref
if image_id is None:
image_id = CONF.compute.image_ref
kwargs = fixed_network.set_networks_kwarg(
tenant_network, kwargs) or {}
multiple_create_request = (max(kwargs.get('min_count', 0),
kwargs.get('max_count', 0)) > 1)
if CONF.validation.run_validation and validatable:
# As a first implementation, multiple pingable or sshable servers will
# not be supported
if multiple_create_request:
msg = ("Multiple pingable or sshable servers not supported at "
"this stage.")
raise ValueError(msg)
LOG.debug("Provisioning test server with validation resources %s",
validation_resources)
if 'security_groups' in kwargs:
kwargs['security_groups'].append(
{'name': validation_resources['security_group']['name']})
else:
try:
kwargs['security_groups'] = [
{'name': validation_resources['security_group']['name']}]
except KeyError:
LOG.debug("No security group provided.")
if 'key_name' not in kwargs:
try:
kwargs['key_name'] = validation_resources['keypair']['name']
except KeyError:
LOG.debug("No key provided.")
if CONF.validation.connect_method == 'floating':
if wait_until is None:
wait_until = 'ACTIVE'
if 'user_data' not in kwargs:
# If nothing overrides the default user data script then run
# a simple script on the host to print networking info. This is
# to aid in debugging ssh failures.
script = '''
#!/bin/sh
echo "Printing {user} user authorized keys"
cat ~{user}/.ssh/authorized_keys || true
'''.format(user=CONF.validation.image_ssh_user)
script_clean = textwrap.dedent(script).lstrip().encode('utf8')
script_b64 = base64.b64encode(script_clean)
kwargs['user_data'] = script_b64
if volume_backed:
volume_name = data_utils.rand_name(__name__ + '-volume')
volumes_client = clients.volumes_client_latest
params = {'name': volume_name,
'imageRef': image_id,
'size': CONF.volume.volume_size}
volume = volumes_client.create_volume(**params)
waiters.wait_for_volume_resource_status(volumes_client,
volume['volume']['id'],
'available')
bd_map_v2 = [{
'uuid': volume['volume']['id'],
'source_type': 'volume',
'destination_type': 'volume',
'boot_index': 0,
'delete_on_termination': True}]
kwargs['block_device_mapping_v2'] = bd_map_v2
# Since this is boot from volume an image does not need
# to be specified.
image_id = ''
body = clients.servers_client.create_server(name=name, imageRef=image_id,
flavorRef=flavor,
**kwargs)
# handle the case of multiple servers
if multiple_create_request:
# Get servers created which name match with name param.
body_servers = clients.servers_client.list_servers()
servers = \
[s for s in body_servers['servers'] if s['name'].startswith(name)]
else:
body = rest_client.ResponseBody(body.response, body['server'])
servers = [body]
def _setup_validation_fip():
if CONF.service_available.neutron:
ifaces = clients.interfaces_client.list_interfaces(server['id'])
validation_port = None
for iface in ifaces['interfaceAttachments']:
if iface['net_id'] == tenant_network['id']:
validation_port = iface['port_id']
break
if not validation_port:
# NOTE(artom) This will get caught by the catch-all clause in
# the wait_until loop below
raise ValueError('Unable to setup floating IP for validation: '
'port not found on tenant network')
clients.floating_ips_client.update_floatingip(
validation_resources['floating_ip']['id'],
port_id=validation_port)
else:
fip_client = clients.compute_floating_ips_client
fip_client.associate_floating_ip_to_server(
floating_ip=validation_resources['floating_ip']['ip'],
server_id=servers[0]['id'])
if wait_until:
for server in servers:
try:
waiters.wait_for_server_status(
clients.servers_client, server['id'], wait_until)
# Multiple validatable servers are not supported for now. Their
# creation will fail with the condition above.
if CONF.validation.run_validation and validatable:
if CONF.validation.connect_method == 'floating':
_setup_validation_fip()
except Exception:
with excutils.save_and_reraise_exception():
for server in servers:
try:
clients.servers_client.delete_server(
server['id'])
except Exception:
LOG.exception('Deleting server %s failed',
server['id'])
for server in servers:
# NOTE(artom) If the servers were booted with volumes
# and with delete_on_termination=False we need to wait
# for the servers to go away before proceeding with
# cleanup, otherwise we'll attempt to delete the
# volumes while they're still attached to servers that
# are in the process of being deleted.
try:
waiters.wait_for_server_termination(
clients.servers_client, server['id'])
except Exception:
LOG.exception('Server %s failed to delete in time',
server['id'])
return body, servers