def _create_servers(self, port_1, port_2):
params = {
'flavor_ref': CONF.compute.flavor_ref,
'image_ref': CONF.compute.image_ref,
'key_name': self.keypair['name']
}
vms = []
vms.append(
self.create_server(networks=[{
'port': port_1['id']
}], **params))
if (CONF.compute.min_compute_nodes > 1 and
compute.is_scheduler_filter_enabled("DifferentHostFilter")):
params['scheduler_hints'] = {
'different_host': [vms[0]['server']['id']]
}
vms.append(
self.create_server(networks=[{
'port': port_2['id']
}], **params))
for vm in vms:
self.wait_for_server_active(vm['server'])
return vms
def _create_servers(self, port_1, port_2):
params = {
'flavor_ref': CONF.compute.flavor_ref,
'image_ref': CONF.compute.image_ref,
'key_name': self.keypair['name']
}
vm1 = self.create_server(networks=[{'port': port_1['id']}], **params)
if (CONF.compute.min_compute_nodes > 1 and
compute.is_scheduler_filter_enabled("DifferentHostFilter")):
params['scheduler_hints'] = {
'different_host': [vm1['server']['id']]
}
self.create_server(networks=[{'port': port_2['id']}], **params)
def resource_setup(cls):
super(TestSecurityGroupsBasicOps, cls).resource_setup()
cls.multi_node = CONF.compute.min_compute_nodes > 1 and \
compute.is_scheduler_filter_enabled("DifferentHostFilter")
if cls.multi_node:
LOG.info("Working in Multi Node mode")
else:
LOG.info("Working in Single Node mode")
cls.floating_ips = {}
cls.tenants = {}
cls.primary_tenant = cls.TenantProperties(cls.os_primary)
cls.alt_tenant = cls.TenantProperties(cls.os_alt)
for tenant in [cls.primary_tenant, cls.alt_tenant]:
cls.tenants[tenant.creds.tenant_id] = tenant
cls.floating_ip_access = not CONF.network.public_router_id
def resource_setup(cls):
super(TestSecurityGroupsBasicOps, cls).resource_setup()
cls.multi_node = CONF.compute.min_compute_nodes > 1 and \
compute.is_scheduler_filter_enabled("DifferentHostFilter")
if cls.multi_node:
LOG.info("Working in Multi Node mode")
else:
LOG.info("Working in Single Node mode")
cls.floating_ips = {}
cls.tenants = {}
cls.primary_tenant = cls.TenantProperties(cls.os_primary)
cls.alt_tenant = cls.TenantProperties(cls.os_alt)
for tenant in [cls.primary_tenant, cls.alt_tenant]:
cls.tenants[tenant.creds.tenant_id] = tenant
cls.floating_ip_access = not CONF.network.public_router_id
class ServersOnMultiNodesTest(base.BaseV2ComputeAdminTest):
@classmethod
def resource_setup(cls):
super(ServersOnMultiNodesTest, cls).resource_setup()
cls.server01 = cls.create_test_server(wait_until='ACTIVE')['id']
cls.host01 = cls.get_host_for_server(cls.server01)
@classmethod
def skip_checks(cls):
super(ServersOnMultiNodesTest, cls).skip_checks()
if CONF.compute.min_compute_nodes < 2:
raise cls.skipException(
"Less than 2 compute nodes, skipping multi-nodes test.")
def _create_servers_with_group(self, policy):
group_id = self.create_test_server_group(policy=[policy])['id']
hints = {'group': group_id}
reservation_id = self.create_test_server(
scheduler_hints=hints, wait_until='ACTIVE', min_count=2,
return_reservation_id=True)['reservation_id']
# Get the servers using the reservation_id.
servers = self.servers_client.list_servers(
detail=True, reservation_id=reservation_id)['servers']
self.assertEqual(2, len(servers))
# Assert the servers are in the group.
server_group = self.server_groups_client.show_server_group(
group_id)['server_group']
hosts = {}
for server in servers:
self.assertIn(server['id'], server_group['members'])
hosts[server['id']] = self.get_host_for_server(server['id'])
return hosts
@decorators.idempotent_id('26a9d5df-6890-45f2-abc4-a659290cb130')
@testtools.skipUnless(
compute.is_scheduler_filter_enabled("SameHostFilter"),
'SameHostFilter is not available.')
def test_create_servers_on_same_host(self):
hints = {'same_host': self.server01}
server02 = self.create_test_server(scheduler_hints=hints,
wait_until='ACTIVE')['id']
host02 = self.get_host_for_server(server02)
self.assertEqual(self.host01, host02)
@decorators.idempotent_id('cc7ca884-6e3e-42a3-a92f-c522fcf25e8e')
@testtools.skipUnless(
compute.is_scheduler_filter_enabled("DifferentHostFilter"),
'DifferentHostFilter is not available.')
def test_create_servers_on_different_hosts(self):
hints = {'different_host': self.server01}
server02 = self.create_test_server(scheduler_hints=hints,
wait_until='ACTIVE')['id']
host02 = self.get_host_for_server(server02)
self.assertNotEqual(self.host01, host02)
@decorators.idempotent_id('7869cc84-d661-4e14-9f00-c18cdc89cf57')
@testtools.skipUnless(
compute.is_scheduler_filter_enabled("DifferentHostFilter"),
'DifferentHostFilter is not available.')
def test_create_servers_on_different_hosts_with_list_of_servers(self):
# This scheduler-hint supports list of servers also.
hints = {'different_host': [self.server01]}
server02 = self.create_test_server(scheduler_hints=hints,
wait_until='ACTIVE')['id']
host02 = self.get_host_for_server(server02)
self.assertNotEqual(self.host01, host02)
@decorators.idempotent_id('f8bd0867-e459-45f5-ba53-59134552fe04')
@testtools.skipUnless(
compute.is_scheduler_filter_enabled("ServerGroupAntiAffinityFilter"),
'ServerGroupAntiAffinityFilter is not available.')
def test_create_server_with_scheduler_hint_group_anti_affinity(self):
"""Tests the ServerGroupAntiAffinityFilter
Creates two servers in an anti-affinity server group and
asserts the servers are in the group and on different hosts.
"""
hosts = self._create_servers_with_group('anti-affinity')
hostnames = list(hosts.values())
self.assertNotEqual(hostnames[0], hostnames[1],
'Servers are on the same host: %s' % hosts)
@decorators.idempotent_id('9d2e924a-baf4-11e7-b856-fa163e65f5ce')
@testtools.skipUnless(
compute.is_scheduler_filter_enabled("ServerGroupAffinityFilter"),
'ServerGroupAffinityFilter is not available.')
def test_create_server_with_scheduler_hint_group_affinity(self):
"""Tests the ServerGroupAffinityFilter
Creates two servers in an affinity server group and
asserts the servers are in the group and on same host.
"""
hosts = self._create_servers_with_group('affinity')
hostnames = list(hosts.values())
self.assertEqual(hostnames[0], hostnames[1],
'Servers are on the different hosts: %s' % hosts)
class LiveMigrationRemoteConsolesV26Test(LiveMigrationTestBase):
min_microversion = '2.6'
max_microversion = 'latest'
@decorators.idempotent_id('6190af80-513e-4f0f-90f2-9714e84955d7')
@testtools.skipUnless(CONF.compute_feature_enabled.serial_console,
'Serial console not supported.')
@testtools.skipUnless(
compute.is_scheduler_filter_enabled("DifferentHostFilter"),
'DifferentHostFilter is not available.')
def test_live_migration_serial_console(self):
"""Test the live-migration of an instance which has a serial console
The serial console feature of an instance uses ports on the host.
These ports need to be updated when they are already in use by
another instance on the target host. This test checks if this
update behavior is correctly done, by connecting to the serial
consoles of the instances before and after the live migration.
"""
server01_id = self.create_test_server(wait_until='ACTIVE')['id']
hints = {'different_host': server01_id}
server02_id = self.create_test_server(scheduler_hints=hints,
wait_until='ACTIVE')['id']
host01_id = self.get_host_for_server(server01_id)
host02_id = self.get_host_for_server(server02_id)
self.assertNotEqual(host01_id, host02_id)
# At this step we have 2 instances on different hosts, both with
# serial consoles, both with port 10000 (the default value).
# https://bugs.launchpad.net/nova/+bug/1455252 describes the issue
# when live-migrating in such a scenario.
self._verify_console_interaction(server01_id)
self._verify_console_interaction(server02_id)
self._live_migrate(server01_id, host02_id, 'ACTIVE')
self._verify_console_interaction(server01_id)
# At this point, both instances have a valid serial console
# connection, which means the ports got updated.
def _verify_console_interaction(self, server_id):
body = self.servers_client.get_remote_console(server_id,
console_type='serial',
protocol='serial')
console_url = body['remote_console']['url']
data = "test_live_migration_serial_console"
console_output = ''
t = 0.0
interval = 0.1
ws = compute.create_websocket(console_url)
try:
# NOTE (markus_z): It can take a long time until the terminal
# of the instance is available for interaction. Hence the
# long timeout value.
while data not in console_output and t <= 120.0:
try:
ws.send_frame(data)
received = ws.receive_frame()
console_output += received
except Exception:
# In case we had an issue with send/receive on the
# websocket connection, we create a new one.
ws = compute.create_websocket(console_url)
time.sleep(interval)
t += interval
finally:
ws.close()
self.assertIn(data, console_output)
class ServerGroupTestJSON(base.BaseV2ComputeTest):
"""These tests check for the server-group APIs.
They create/delete server-groups with different policies.
policies = affinity/anti-affinity
It also adds the tests for list and get details of server-groups
"""
create_default_network = True
@classmethod
def skip_checks(cls):
super(ServerGroupTestJSON, cls).skip_checks()
if not utils.is_extension_enabled('os-server-groups', 'compute'):
msg = "os-server-groups extension is not enabled."
raise cls.skipException(msg)
@classmethod
def setup_clients(cls):
super(ServerGroupTestJSON, cls).setup_clients()
cls.client = cls.server_groups_client
@classmethod
def _set_policy(cls, policy):
if not cls.is_requested_microversion_compatible('2.63'):
return policy[0]
else:
return policy
@classmethod
def resource_setup(cls):
super(ServerGroupTestJSON, cls).resource_setup()
if cls.is_requested_microversion_compatible('2.63'):
cls.policy_field = 'policies'
cls.policy = ['affinity']
else:
cls.policy_field = 'policy'
cls.policy = 'affinity'
def setUp(self):
super(ServerGroupTestJSON, self).setUp()
# TODO(zhufl): After microversion 2.13 project_id and user_id are
# added to the body of server_group, and microversion is not used
# in resource_setup for now, so we should create server group in setUp
# in order to use the same microversion as in testcases till
# microversion support in resource_setup is fulfilled.
if not hasattr(self, 'created_server_group'):
self.__class__.created_server_group = \
self.create_test_server_group(policy=self.policy)
def _create_server_group(self, name, policy):
# create the test server-group with given policy
server_group = {'name': name, self.policy_field: policy}
body = self.create_test_server_group(name, policy)
for key in ['name', self.policy_field]:
self.assertEqual(server_group[key], body[key])
return body
def _delete_server_group(self, server_group):
# delete the test server-group
self.client.delete_server_group(server_group['id'])
# validation of server-group deletion
server_group_list = self.client.list_server_groups()['server_groups']
self.assertNotIn(server_group, server_group_list)
def _create_delete_server_group(self, policy):
# Create and Delete the server-group with given policy
name = data_utils.rand_name('server-group')
server_group = self._create_server_group(name, policy)
self._delete_server_group(server_group)
@decorators.idempotent_id('5dc57eda-35b7-4af7-9e5f-3c2be3d2d68b')
def test_create_delete_server_group_with_affinity_policy(self):
"""Test Create/Delete the server-group with affinity policy"""
self._create_delete_server_group(self.policy)
@decorators.idempotent_id('3645a102-372f-4140-afad-13698d850d23')
def test_create_delete_server_group_with_anti_affinity_policy(self):
"""Test Create/Delete the server-group with anti-affinity policy"""
policy = self._set_policy(['anti-affinity'])
self._create_delete_server_group(policy)
@decorators.idempotent_id('154dc5a4-a2fe-44b5-b99e-f15806a4a113')
def test_create_delete_multiple_server_groups_with_same_name_policy(self):
"""Test Create/Delete the server-groups with same name and policy"""
server_groups = []
server_group_name = data_utils.rand_name('server-group')
for _ in range(0, 2):
server_groups.append(
self._create_server_group(server_group_name, self.policy))
for key in ['name', self.policy_field]:
self.assertEqual(server_groups[0][key], server_groups[1][key])
self.assertNotEqual(server_groups[0]['id'], server_groups[1]['id'])
for i in range(0, 2):
self._delete_server_group(server_groups[i])
@decorators.idempotent_id('b3545034-dd78-48f0-bdc2-a4adfa6d0ead')
def test_show_server_group(self):
"""Test getting the server-group detail"""
body = self.client.show_server_group(
self.created_server_group['id'])['server_group']
self.assertEqual(self.created_server_group, body)
@decorators.idempotent_id('d4874179-27b4-4d7d-80e4-6c560cdfe321')
def test_list_server_groups(self):
"""Test listing the server-groups"""
body = self.client.list_server_groups()['server_groups']
self.assertIn(self.created_server_group, body)
@decorators.idempotent_id('ed20d3fb-9d1f-4329-b160-543fbd5d9811')
@testtools.skipUnless(
compute.is_scheduler_filter_enabled("ServerGroupAffinityFilter"),
'ServerGroupAffinityFilter is not available.')
def test_create_server_with_scheduler_hint_group(self):
"""Test creating a server with the scheduler hint 'group'"""
hints = {'group': self.created_server_group['id']}
server = self.create_test_server(scheduler_hints=hints,
wait_until='ACTIVE')
self.addCleanup(self.delete_server, server['id'])
# Check a server is in the group
server_group = (self.server_groups_client.show_server_group(
self.created_server_group['id'])['server_group'])
self.assertIn(server['id'], server_group['members'])
class ServersTestJSON(base.BaseV2ComputeTest):
disk_config = 'AUTO'
volume_backed = False
@classmethod
def setup_credentials(cls):
cls.prepare_instance_network()
super(ServersTestJSON, cls).setup_credentials()
@classmethod
def setup_clients(cls):
super(ServersTestJSON, cls).setup_clients()
cls.client = cls.servers_client
@classmethod
def resource_setup(cls):
cls.set_validation_resources()
super(ServersTestJSON, cls).resource_setup()
cls.meta = {'hello': 'world'}
cls.accessIPv4 = '1.1.1.1'
cls.accessIPv6 = '0000:0000:0000:0000:0000:babe:220.12.22.2'
cls.name = data_utils.rand_name(cls.__name__ + '-server')
cls.password = data_utils.rand_password()
disk_config = cls.disk_config
server_initial = cls.create_test_server(
validatable=True,
wait_until='ACTIVE',
name=cls.name,
metadata=cls.meta,
accessIPv4=cls.accessIPv4,
accessIPv6=cls.accessIPv6,
disk_config=disk_config,
adminPass=cls.password,
volume_backed=cls.volume_backed)
cls.server = (cls.client.show_server(server_initial['id'])
['server'])
@decorators.attr(type='smoke')
@decorators.idempotent_id('5de47127-9977-400a-936f-abcfbec1218f')
def test_verify_server_details(self):
# Verify the specified server attributes are set correctly
self.assertEqual(self.accessIPv4, self.server['accessIPv4'])
# NOTE(maurosr): See http://tools.ietf.org/html/rfc5952 (section 4)
# Here we compare directly with the canonicalized format.
self.assertEqual(self.server['accessIPv6'],
str(netaddr.IPAddress(self.accessIPv6)))
self.assertEqual(self.name, self.server['name'])
if self.volume_backed:
# Image is an empty string as per documentation
self.assertEqual("", self.server['image'])
else:
self.assertEqual(self.image_ref, self.server['image']['id'])
self.assertEqual(self.flavor_ref, self.server['flavor']['id'])
self.assertEqual(self.meta, self.server['metadata'])
@decorators.attr(type='smoke')
@decorators.idempotent_id('9a438d88-10c6-4bcd-8b5b-5b6e25e1346f')
def test_list_servers(self):
# The created server should be in the list of all servers
body = self.client.list_servers()
servers = body['servers']
found = [i for i in servers if i['id'] == self.server['id']]
self.assertNotEmpty(found)
@decorators.idempotent_id('585e934c-448e-43c4-acbf-d06a9b899997')
def test_list_servers_with_detail(self):
# The created server should be in the detailed list of all servers
body = self.client.list_servers(detail=True)
servers = body['servers']
found = [i for i in servers if i['id'] == self.server['id']]
self.assertNotEmpty(found)
@decorators.idempotent_id('cbc0f52f-05aa-492b-bdc1-84b575ca294b')
@testtools.skipUnless(CONF.validation.run_validation,
'Instance validation tests are disabled.')
def test_verify_created_server_vcpus(self):
# Verify that the number of vcpus reported by the instance matches
# the amount stated by the flavor
flavor = self.flavors_client.show_flavor(self.flavor_ref)['flavor']
linux_client = remote_client.RemoteClient(
self.get_server_ip(self.server),
self.ssh_user,
self.password,
self.validation_resources['keypair']['private_key'],
server=self.server,
servers_client=self.client)
output = linux_client.exec_command('grep -c ^processor /proc/cpuinfo')
self.assertEqual(flavor['vcpus'], int(output))
@decorators.idempotent_id('ac1ad47f-984b-4441-9274-c9079b7a0666')
@testtools.skipUnless(CONF.validation.run_validation,
'Instance validation tests are disabled.')
def test_host_name_is_same_as_server_name(self):
# Verify the instance host name is the same as the server name
linux_client = remote_client.RemoteClient(
self.get_server_ip(self.server),
self.ssh_user,
self.password,
self.validation_resources['keypair']['private_key'],
server=self.server,
servers_client=self.client)
hostname = linux_client.exec_command("hostname").rstrip()
msg = ('Failed while verifying servername equals hostname. Expected '
'hostname "%s" but got "%s".' % (self.name, hostname))
self.assertEqual(self.name.lower(), hostname, msg)
@decorators.idempotent_id('ed20d3fb-9d1f-4329-b160-543fbd5d9811')
@testtools.skipUnless(
compute.is_scheduler_filter_enabled("ServerGroupAffinityFilter"),
'ServerGroupAffinityFilter is not available.')
def test_create_server_with_scheduler_hint_group(self):
# Create a server with the scheduler hint "group".
group_id = self.create_test_server_group()['id']
hints = {'group': group_id}
server = self.create_test_server(scheduler_hints=hints,
wait_until='ACTIVE')
# Check a server is in the group
server_group = (self.server_groups_client.show_server_group(group_id)
['server_group'])
self.assertIn(server['id'], server_group['members'])
class ServerGroupTestJSON(base.BaseV2ComputeTest):
"""These tests check for the server-group APIs.
They create/delete server-groups with different policies.
policies = affinity/anti-affinity
It also adds the tests for list and get details of server-groups
"""
@classmethod
def skip_checks(cls):
super(ServerGroupTestJSON, cls).skip_checks()
if not utils.is_extension_enabled('os-server-groups', 'compute'):
msg = "os-server-groups extension is not enabled."
raise cls.skipException(msg)
@classmethod
def setup_clients(cls):
super(ServerGroupTestJSON, cls).setup_clients()
cls.client = cls.server_groups_client
@classmethod
def resource_setup(cls):
super(ServerGroupTestJSON, cls).resource_setup()
cls.policy = ['affinity']
cls.created_server_group = cls.create_test_server_group(
policy=cls.policy)
def _create_server_group(self, name, policy):
# create the test server-group with given policy
server_group = {'name': name, 'policies': policy}
body = self.create_test_server_group(name, policy)
for key in ['name', 'policies']:
self.assertEqual(server_group[key], body[key])
return body
def _delete_server_group(self, server_group):
# delete the test server-group
self.client.delete_server_group(server_group['id'])
# validation of server-group deletion
server_group_list = self.client.list_server_groups()['server_groups']
self.assertNotIn(server_group, server_group_list)
def _create_delete_server_group(self, policy):
# Create and Delete the server-group with given policy
name = data_utils.rand_name('server-group')
server_group = self._create_server_group(name, policy)
self._delete_server_group(server_group)
@decorators.idempotent_id('5dc57eda-35b7-4af7-9e5f-3c2be3d2d68b')
def test_create_delete_server_group_with_affinity_policy(self):
# Create and Delete the server-group with affinity policy
self._create_delete_server_group(self.policy)
@decorators.idempotent_id('3645a102-372f-4140-afad-13698d850d23')
def test_create_delete_server_group_with_anti_affinity_policy(self):
# Create and Delete the server-group with anti-affinity policy
policy = ['anti-affinity']
self._create_delete_server_group(policy)
@decorators.idempotent_id('154dc5a4-a2fe-44b5-b99e-f15806a4a113')
def test_create_delete_multiple_server_groups_with_same_name_policy(self):
# Create and Delete the server-groups with same name and same policy
server_groups = []
server_group_name = data_utils.rand_name('server-group')
for _ in range(0, 2):
server_groups.append(
self._create_server_group(server_group_name, self.policy))
for key in ['name', 'policies']:
self.assertEqual(server_groups[0][key], server_groups[1][key])
self.assertNotEqual(server_groups[0]['id'], server_groups[1]['id'])
for i in range(0, 2):
self._delete_server_group(server_groups[i])
@decorators.idempotent_id('b3545034-dd78-48f0-bdc2-a4adfa6d0ead')
def test_show_server_group(self):
# Get the server-group
body = self.client.show_server_group(
self.created_server_group['id'])['server_group']
self.assertEqual(self.created_server_group, body)
@decorators.idempotent_id('d4874179-27b4-4d7d-80e4-6c560cdfe321')
def test_list_server_groups(self):
# List the server-group
body = self.client.list_server_groups()['server_groups']
self.assertIn(self.created_server_group, body)
@decorators.idempotent_id('ed20d3fb-9d1f-4329-b160-543fbd5d9811')
@testtools.skipUnless(
compute.is_scheduler_filter_enabled("ServerGroupAffinityFilter"),
'ServerGroupAffinityFilter is not available.')
def test_create_server_with_scheduler_hint_group(self):
# Create a server with the scheduler hint "group".
hints = {'group': self.created_server_group['id']}
server = self.create_test_server(scheduler_hints=hints,
wait_until='ACTIVE')
self.addCleanup(self.delete_server, server['id'])
# Check a server is in the group
server_group = (self.server_groups_client.show_server_group(
self.created_server_group['id'])['server_group'])
self.assertIn(server['id'], server_group['members'])
