def setUp(self):
super(MuranoTest, self).setUp()
self.check_clients_state()
self.env_name = rand_name("ostf_test-Murano_env")
if not self.config.compute.compute_nodes \
and self.config.compute.libvirt_type != 'vcenter':
self.skipTest('There are no compute nodes')
self.max_available_ram = 0
for hypervisor in self.compute_client.hypervisors.list():
if hypervisor.free_ram_mb >= 2048:
self.flavor_reqs = True
break
else:
if hypervisor.free_ram_mb > self.max_available_ram:
self.max_available_ram = hypervisor.free_ram_mb
self.flavor_reqs = False
self.flavor_name = rand_name("ostf_test_Murano_flavor")
if self.flavor_reqs:
self.flavor = self.compute_client.flavors.create(self.flavor_name,
disk=60, ram=2048,
vcpus=1)
self.murano_available = True
self.endpoint = self.config.murano.api_url + '/v1/'
self.headers = {'X-Auth-Token': self.murano_client.auth_token,
'content-type': 'application/json'}
try:
self.list_environments()
except exceptions.CommunicationError:
self.murano_available = False
self.skipTest("Murano service is not available")
def setUp(self):
super(SaharaTemplatesTest, self).setUp()
flavor_id = self.create_flavor()
self.ng_template = {
'name': rand_name('sahara-ng-template-'),
'plugin_name': self._plugin_name,
'hadoop_version': self._hadoop_version,
'flavor_id': flavor_id,
'node_processes': self._node_processes,
'description': 'Test node group template'
}
self.cl_template = {
'name':
rand_name('sahara-cl-template-'),
'plugin_name':
self._plugin_name,
'hadoop_version':
self._hadoop_version,
'node_groups': [{
'name': 'all-in-one',
'flavor_id': flavor_id,
'node_processes': self._node_processes,
'count': 1
}],
'description':
'Test cluster template'
}
self.client = self.sahara_client
def test_create_and_delete_image(self):
"""Check create, update and delete image actions using Glance v1
Target component: Glance
Scenario:
1.Create image
2.Checking image status
3.Check that image was created successfully
4.Update image with properties
5.Check that properties was updated successfully
6.Delete image
Duration: 130 s.
Available since release: 2014.2-6.1
"""
fail_msg = "Error creating image. Please refer to Openstack logs " "for more information."
self.image = self.verify(100, self.image_create, 1, fail_msg, "Image creation", self.glance_client_v1)
fail_msg = "Image status is incorrect. Please refer to " "Openstack logs for more information."
self.verify(
200, self.check_image_status, 2, fail_msg, "Checking image status", self.glance_client_v1, self.image
)
fail_msg = "Image doesn't appear at list. Please refer to " "Openstack logs for more information."
self.verify(100, self.find_image_by_id, 3, fail_msg, "Finding image", self.glance_client_v1, self.image.id)
group_props = rand_name("ostf_test")
prop = rand_name("ostf-prop")
value_prop = rand_name("prop-value")
fail_msg = "Can't update image with properties. Please refer to " "Openstack logs for more information."
self.image = self.verify(
100,
self.update_image,
4,
fail_msg,
"Updating image",
self.glance_client_v1,
self.image,
group_props,
prop,
value_prop,
)
fail_msg = "Can't find appended properties. Please refer to " "OSTF logs for more information."
self.verify(
100,
self.find_props,
5,
fail_msg,
"Finding properties",
self.glance_client_v1,
self.image,
group_props,
prop,
value_prop,
)
fail_msg = "Cant delete image. Please refer to Openstack logs " "for more information."
self.verify(100, self.delete_image, 6, fail_msg, "Deleting image", self.glance_client_v1, self.image)
def _create_cluster(
cls, compute_client, sahara_client, plugin_name, plugin_version,
cluster_template_id, description, image_id, cluster_configs,
node_groups, anti_affinity, neutron_management_network=None):
key_name = rand_name(cls.USER_KEYPAIR_ID)
cls.keys.append(
compute_client.keypairs.create(key_name))
body = sahara_client.clusters.create(
name=rand_name(cls.CLUSTER_NAME),
plugin_name=plugin_name,
hadoop_version=plugin_version,
cluster_template_id=cluster_template_id,
default_image_id=image_id,
description=description,
cluster_configs=cluster_configs,
node_groups=node_groups,
user_keypair_id=key_name,
anti_affinity=anti_affinity,
net_id=neutron_management_network)
if body:
cls.clusters.append(body.id)
return body
def setUp(self):
super(SaharaTemplatesTest, self).setUp()
flavor_id = self.create_flavor()
self.ng_template = {
'name': rand_name('sahara-ng-template-'),
'plugin_name': self._plugin_name,
'hadoop_version': self._hadoop_version,
'flavor_id': flavor_id,
'node_processes': self._node_processes,
'description': 'Test node group template'
}
self.cl_template = {
'name': rand_name('sahara-cl-template-'),
'plugin_name': self._plugin_name,
'hadoop_version': self._hadoop_version,
'node_groups': [
{
'name': 'all-in-one',
'flavor_id': flavor_id,
'node_processes': self._node_processes,
'count': 1
}
],
'description': 'Test cluster template'
}
self.client = self.sahara_client
def test_create_and_delete_image(self):
"""Check create, update and delete image actions using Glance v1
Target component: Glance
Scenario:
1.Create image
2.Checking image status
3.Check that image was created successfully
4.Update image with properties
5.Check that properties was updated successfully
6.Delete image
Duration: 130 s.
Deployment tags: disabled
Available since release: 2014.2-6.1
"""
# TODO(tleontovich) enable when mos LP1527224 fixed
fail_msg = ("Error creating image. Please refer to Openstack logs "
"for more information.")
self.image = self.verify(100, self.image_create, 1, fail_msg,
'Image creation', self.glance_client_v1)
fail_msg = ("Image status is incorrect. Please refer to "
"Openstack logs for more information.")
self.verify(200, self.check_image_status, 2, fail_msg,
'Checking image status', self.glance_client_v1, self.image)
fail_msg = ("Image doesn't appear at list. Please refer to "
"Openstack logs for more information.")
self.verify(100, self.find_image_by_id, 3, fail_msg, 'Finding image',
self.glance_client_v1, self.image.id)
group_props = rand_name("ostf_test")
prop = rand_name("ostf-prop")
value_prop = rand_name("prop-value")
fail_msg = ("Can't update image with properties. Please refer to "
"Openstack logs for more information.")
self.image = self.verify(100, self.update_image, 4, fail_msg,
'Updating image', self.glance_client_v1,
self.image, group_props, prop, value_prop)
fail_msg = ("Can't find appended properties. Please refer to "
"OSTF logs for more information.")
self.verify(100, self.find_props, 5, fail_msg, 'Finding properties',
self.glance_client_v1, self.image, group_props, prop,
value_prop)
fail_msg = ("Can't delete image. Please refer to Openstack logs "
"for more information.")
self.verify(100, self.delete_image, 6, fail_msg, 'Deleting image',
self.glance_client_v1, self.image)
def test_create_and_delete_image(self):
"""Check create, update and delete image actions using Glance v1
Target component: Glance
Scenario:
1.Create image
2.Checking image status
3.Check that image was created successfully
4.Update image with properties
5.Check that properties was updated successfully
6.Delete image
Duration: 130 s.
Deployment tags: disabled
Available since release: 2014.2-6.1
"""
# TODO(tleontovich) enable when mos LP1527224 fixed
fail_msg = ("Error creating image. Please refer to Openstack logs "
"for more information.")
self.image = self.verify(100, self.image_create, 1, fail_msg,
'Image creation', self.glance_client_v1)
fail_msg = ("Image status is incorrect. Please refer to "
"Openstack logs for more information.")
self.verify(200, self.check_image_status, 2, fail_msg,
'Checking image status', self.glance_client_v1, self.image)
fail_msg = ("Image doesn't appear at list. Please refer to "
"Openstack logs for more information.")
self.verify(100, self.find_image_by_id, 3, fail_msg, 'Finding image',
self.glance_client_v1, self.image.id)
group_props = rand_name("ostf_test")
prop = rand_name("ostf-prop")
value_prop = rand_name("prop-value")
fail_msg = ("Can't update image with properties. Please refer to "
"Openstack logs for more information.")
self.image = self.verify(100, self.update_image, 4, fail_msg,
'Updating image', self.glance_client_v1,
self.image, group_props, prop, value_prop)
fail_msg = ("Can't find appended properties. Please refer to "
"OSTF logs for more information.")
self.verify(100, self.find_props, 5, fail_msg, 'Finding properties',
self.glance_client_v1, self.image, group_props, prop,
value_prop)
fail_msg = ("Can't delete image. Please refer to Openstack logs "
"for more information.")
self.verify(100, self.delete_image, 6, fail_msg, 'Deleting image',
self.glance_client_v1, self.image)
def test_008_check_public_instance_connectivity_from_instance(self):
"""Check network connectivity from instance via floating IP
Target component: Nova
Scenario:
1. Create a new security group (if it doesn`t exist yet).
2. Create an instance using the new security group.
3. Create a new floating IP
4. Assign the new floating IP to the instance.
5. Check that public IP 8.8.8.8 can be pinged from instance.
6. Remove server floating ip.
7. Delete server.
Duration: 200 s.
"""
if not self.security_groups:
self.security_groups[self.tenant_id] = self.verify(
25, self._create_security_group, 1,
"Security group can not be created.",
'security group creation',
self.compute_client)
name = rand_name('ost1_test-server-smoke-')
security_groups = [self.security_groups[self.tenant_id].name]
server = self.verify(200, self._create_server, 2,
"Server can not be created.",
"server creation",
self.compute_client, name, security_groups)
floating_ip = self.verify(
20,
self._create_floating_ip,
3,
"Floating IP can not be created.",
'floating IP creation')
self.verify(10, self._assign_floating_ip_to_instance,
4, "Floating IP can not be assigned.",
'floating IP assignment',
self.compute_client, server, floating_ip)
self.floating_ips.append(floating_ip)
ip_address = floating_ip.ip
LOG.info('is address is %s' % ip_address)
LOG.debug(ip_address)
self.verify(300, self._check_connectivity_from_vm,
5, ("Connectivity to 8.8.8.8 from the VM doesn`t "
"function properly."),
'public connectivity checking from VM', ip_address,
30, (10, 30))
self.verify(10, self.compute_client.servers.remove_floating_ip,
6, "Floating IP cannot be removed.",
"removing floating IP", server, floating_ip)
self.verify(30, self._delete_server, 7,
"Server can not be deleted. ",
"server deletion", server)
def _create_server(self, client):
name = rand_name('ost1_test-volume-instance')
base_image_id = get_image_from_name()
flavor_id = self._create_nano_flavor().id
if 'neutron' in self.config.network.network_provider:
network = [
net.id for net in self.compute_client.networks.list()
if net.label == self.private_net
]
create_kwargs = {'nics': [{'net-id': network[0]}]}
server = client.servers.create(name, base_image_id, flavor_id,
**create_kwargs)
else:
server = client.servers.create(name, base_image_id, flavor_id)
self.set_resource(name, server)
self.verify_response_body_content(server.name, name,
"Instance creation failed")
# The instance retrieved on creation is missing network
# details, necessitating retrieval after it becomes active to
# ensure correct details.
server = self._wait_server_param(client, server, 'addresses', 5, 1)
self.servers.append(server)
self.set_resource(name, server)
return server
def setUp(self):
super(MuranoTest, self).setUp()
self.check_clients_state()
self.env_name = rand_name("ostf_test-Murano_env")
if not self.config.compute.compute_nodes:
self.skipTest('There are no compute nodes to run tests')
self.min_required_ram_mb = 4096
self.murano_available = True
self.endpoint = '{0}/v1/'.format(
self.identity_client.service_catalog.url_for(
service_type='application-catalog', endpoint_type='publicURL'))
self.headers = {
'X-Auth-Token': self.murano_client.http_client.auth_token,
'content-type': 'application/json'
}
try:
self.list_environments()
except exceptions.CommunicationError:
self.murano_available = False
self.skipTest("Murano service is not available")
def test_005_create_servers(self):
"""Launch instance
Target component: Nova
Scenario:
1. Create a new security group (if it doesn`t exist yet).
2. Create an instance using the new security group.
Duration: 200 s.
"""
if not self.security_groups:
self.security_groups[self.tenant_id] = self.verify(
25,
self._create_security_group,
1,
"Security group can not be created.",
'security group creation',
self.compute_client)
name = rand_name('ost1_test-server-smoke-')
security_groups = [self.security_groups[self.tenant_id].name]
server = self.verify(
200,
self._create_server,
2,
"Creating instance using the new security group has failed.",
'image creation',
self.compute_client, name, security_groups
)
self.servers.append(server)
def setUp(self):
super(MuranoTest, self).setUp()
self.check_clients_state()
self.env_name = rand_name("ostf_test-Murano_env")
if not self.config.compute.compute_nodes:
self.skipTest('There are no compute nodes to run tests')
self.min_required_ram_mb = 4096
self.murano_available = True
self.endpoint = '{0}/v1/'.format(
self.identity_client.service_catalog.url_for(
service_type='application-catalog',
endpoint_type='publicURL'))
self.headers = {
'X-Auth-Token': self.murano_client.http_client.auth_token,
'content-type': 'application/json'
}
try:
self.list_environments()
except exceptions.CommunicationError:
self.murano_available = False
self.skipTest("Murano service is not available")
def _create_keypair(self, client, namestart='ost1_test-keypair-smoke-'):
kp_name = rand_name(namestart)
keypair = client.keypairs.create(kp_name)
self.set_resource(kp_name, keypair)
self.verify_response_body_content(keypair.id, kp_name,
'Keypair creation failed')
return keypair
def _create_volume(self, client, display_name=None, **kwargs):
if display_name is None:
display_name = rand_name('ost1_test-volume')
volume = client.volumes.create(
size=1, display_name=display_name, **kwargs)
self.set_resource(display_name, volume)
return volume
def test_1_vcenter_create_servers(self):
"""vCenter: Launch instance
Target component: Nova
Scenario:
1. Create a new security group (if it doesn`t exist yet).
2. Create an instance using the new security group.
3. Delete instance.
Duration: 200 s.
Available since release: 2014.2-6.1
Deployment tags: use_vcenter
"""
img_name = 'TestVM-VMDK'
self.manager.config.compute.image_name = img_name
self.check_image_exists()
if not self.security_groups:
self.security_groups[self.tenant_id] = self.verify(
25, self._create_security_group, 1,
"Security group can not be created.",
'security group creation', self.compute_client)
name = rand_name('ost1_test-server-smoke-')
security_groups = [self.security_groups[self.tenant_id].name]
flavor_id = self.find_flavor_id()
server = self.verify(
200, self._create_server, 2,
"Creating instance using the new security group has failed.",
'image creation', self.compute_client, name, security_groups,
flavor_id, None, img_name)
self.verify(30, self._delete_server, 3, "Server can not be deleted.",
"server deletion", server)
def test_004_create_servers(self):
"""Launch instance
Target component: Nova
Scenario:
1. Create a new security group (if it doesn`t exist yet).
2. Create an instance using the new security group.
3. Delete instance.
Duration: 200 s.
"""
self.check_image_exists()
if not self.security_groups:
self.security_groups[self.tenant_id] = self.verify(
25, self._create_security_group, 1,
"Security group can not be created.",
'security group creation', self.compute_client)
name = rand_name('ost1_test-server-smoke-')
security_groups = [self.security_groups[self.tenant_id].name]
server = self.verify(
200, self._create_server, 2,
"Creating instance using the new security group has failed.",
'image creation', self.compute_client, name, security_groups)
self.verify(30, self._delete_server, 3, "Server can not be deleted.",
"server deletion", server)
def test_009_check_internet_connectivity_instance_without_floatingIP(self):
"""Check network connectivity from instance without floating IP
Scenario:
1. Create a new security group (if it doesn`t exist yet).
2. Create an instance using the new security group.
(if it doesn`t exist yet).
3. Check that public IP 8.8.8.8 can be pinged from instance.
Duration: 200 s.
"""
if not self.servers:
if not self.security_groups:
self.security_groups[self.tenant_id] = self.verify(
25, self._create_security_group, 1,
"Security group can not be created.",
'security group creation', self.compute_client)
name = rand_name('ost1_test-server-smoke-')
security_groups = [self.security_groups[self.tenant_id].name]
server = self.verify(200, self._create_server, 2,
"Server can not be created.",
'server creation', self.compute_client, name,
security_groups)
self.servers.append(server)
server = self.servers[-1]
instance_ip = server.addresses['novanetwork'][0]['addr']
compute = getattr(server, 'OS-EXT-SRV-ATTR:host')
self.verify(100, self._check_connectivity_from_vm, 3,
("Connectivity to 8.8.8.8 from the VM doesn`t "
"function properly."),
'public connectivity checking from VM', instance_ip,
compute)
def setUp(self):
super(MuranoDeployLinuxServicesTests, self).setUp()
self.check_clients_state()
msg = ("Linux image with Murano "
"tag isn't available. Need to import this image into "
"glance and mark with Murano metadata tag. Please refer to"
" the Mirantis OpenStack and Murano user documentation. ")
self.image = self.find_murano_image('linux')
if not self.image:
LOG.debug(msg)
self.skipTest(msg)
self.flavor_name = rand_name("ostf_test_Murano_flavor")
if self.flavor_reqs:
try:
self.flavor = self.compute_client.flavors.create(
self.flavor_name,
disk=60,
ram=self.min_required_ram,
vcpus=1)
except Exception:
self.fail('Failed to create flavor "%s" for the test. Please, '
'refer to the Mirantis OpenStack documentation and '
'OpenStack Health Check logs.' % self.flavor_name)
else:
self.skipTest(
"This test requires more resources on one of "
"the compute nodes (> {0} MB of free RAM), but you "
"have only {1} MB on most appropriate compute node.".format(
self.min_required_ram, self.max_available_ram))
def _create_server(self, client):
if not self.smoke_flavor:
self.fail("Flavor for tests was not created. Seems that "
"something is wrong with nova services.")
name = rand_name('ost1_test-volume-instance')
base_image_id = self.get_image_from_name()
if 'neutron' in self.config.network.network_provider:
network = [
net.id for net in self.compute_client.networks.list()
if net.label == self.private_net
]
if network:
create_kwargs = {'nics': [{'net-id': network[0]}]}
else:
self.fail("Default private network '{0}' isn't present."
"Please verify it is properly created.".format(
self.private_net))
server = client.servers.create(name, base_image_id,
self.smoke_flavor.id,
**create_kwargs)
else:
server = client.servers.create(name, base_image_id,
self.smoke_flavor.id)
self.verify_response_body_content(server.name, name,
"Instance creation failed")
# The instance retrieved on creation is missing network
# details, necessitating retrieval after it becomes active to
# ensure correct details.
server = self._wait_server_param(client, server, 'addresses', 5, 1)
self.set_resource(name, server)
return server
def _create_user(self, client, tenant_id):
password = "******"
email = "*****@*****.**"
name = rand_name('ost1_test-user-')
user = client.users.create(name, password, email, tenant_id)
self.users.append(user)
return user
def setUp(self):
super(MuranoDeployLinuxServicesTests, self).setUp()
self.check_clients_state()
msg = ("Linux image with Murano "
"tag isn't available. Need to import this image into "
"glance and mark with Murano metadata tag. Please refer to"
" the Mirantis OpenStack and Murano user documentation. ")
self.image = self.find_murano_image('linux')
if not self.image:
LOG.debug(msg)
self.skipTest(msg)
self.flavor_name = rand_name("ostf_test_Murano_flavor")
if self.flavor_reqs:
try:
self.flavor = self.compute_client.flavors.create(
self.flavor_name, disk=60, ram=self.min_required_ram,
vcpus=1)
except Exception:
self.fail('Failed to create flavor "%s" for the test. Please, '
'refer to the Mirantis OpenStack documentation and '
'OpenStack Health Check logs.' % self.flavor_name)
else:
self.skipTest("This test requires more resources on one of "
"the compute nodes (> {0} MB of free RAM), but you "
"have only {1} MB on most appropriate compute node."
.format(self.min_required_ram,
self.max_available_ram))
def _create_server(self, client):
name = rand_name('ost1_test-volume-instance')
base_image_id = self.get_image_from_name()
if 'neutron' in self.config.network.network_provider:
network = [net.id for net in
self.compute_client.networks.list()
if net.label == self.private_net]
if network:
create_kwargs = {'nics': [{'net-id': network[0]}]}
else:
self.fail('Private network was not created by default')
server = client.servers.create(
name, base_image_id, self.smoke_flavor.id, **create_kwargs)
else:
server = client.servers.create(name, base_image_id,
self.smoke_flavor.id)
self.verify_response_body_content(server.name,
name,
"Instance creation failed")
# The instance retrieved on creation is missing network
# details, necessitating retrieval after it becomes active to
# ensure correct details.
server = self._wait_server_param(client, server, 'addresses', 5, 1)
self.set_resource(name, server)
return server
def _create_flavors(self, client, ram, disk, vcpus=1):
name = rand_name('ost1_test-flavor-')
flavorid = rand_int_id()
flavor = client.flavors.create(name=name, ram=ram, disk=disk,
vcpus=vcpus, flavorid=flavorid)
self.flavors.append(flavor)
return flavor
def setUp(self):
super(MuranoDeployLinuxServicesTests, self).setUp()
self.check_clients_state()
self.doc_link = ('http://docs.mirantis.com/openstack/fuel/'
'fuel-{0}/user-guide.html#platform-tests-'
'description'.format(self.config.fuel.fuel_version))
max_free_ram_mb = (
self.get_max_free_compute_node_ram(self.min_required_ram_mb))
if max_free_ram_mb < self.min_required_ram_mb:
msg = ('This test requires more hardware resources of your '
'OpenStack cluster: at least one of the compute nodes '
'must have >= {0} MB of free RAM, but you have only '
'{1} MB on most appropriate compute node.'
.format(self.min_required_ram_mb, max_free_ram_mb))
LOG.debug(msg)
self.skipTest(msg)
self.image = self.find_murano_image('linux')
self.dummy_fqdn = 'io.murano.apps.Simple'
self.flavor_name = rand_name("ostf_test_Murano_flavor")
flavor = self.compute_client.flavors.create(
self.flavor_name, disk=60, ram=self.min_required_ram_mb, vcpus=1)
self.addCleanup(self.compute_client.flavors.delete, flavor.id)
def _create_boot_volume(self, client):
display_name = rand_name('ost1_test-bootable-volume')
imageRef = self.get_image_from_name()
LOG.debug(
'Image ref is {0} for volume {1}'.format(imageRef, display_name))
return self._create_volume(
client, display_name=display_name, imageRef=imageRef)
def _boot_image(self, image_id):
name = rand_name('ost1_test-image')
client = self.compute_client
flavor_id = self.smoke_flavor
LOG.debug("name:%s, image:%s" % (name, image_id))
if 'neutron' in self.config.network.network_provider:
network = [net.id for net in
self.compute_client.networks.list()
if net.label == self.private_net]
create_kwargs = {
'nics': [
{'net-id': network[0]},
],
}
server = client.servers.create(name=name,
image=image_id,
flavor=flavor_id, **create_kwargs)
else:
server = client.servers.create(name=name,
image=image_id,
flavor=flavor_id)
self.set_resource(name, server)
#self.addCleanup(self.compute_client.servers.delete, server)
self.verify_response_body_content(
name, server.name,
msg="Please refer to OpenStack logs for more details.")
self._wait_for_server_status(server, 'ACTIVE')
server = client.servers.get(server) # getting network information
LOG.debug("server:%s" % server)
return server
def _create_server(self, client):
if not self.smoke_flavor:
self.fail("Flavor for tests was not created. Seems that "
"something is wrong with nova services.")
name = rand_name('ost1_test-volume-instance')
base_image_id = self.get_image_from_name()
if 'neutron' in self.config.network.network_provider:
network = [net.id for net in
self.compute_client.networks.list()
if net.label == self.private_net]
if network:
create_kwargs = {'nics': [{'net-id': network[0]}]}
else:
self.fail("Default private network '{0}' isn't present."
"Please verify it is properly created.".
format(self.private_net))
server = client.servers.create(
name, base_image_id, self.smoke_flavor.id, **create_kwargs)
else:
server = client.servers.create(name, base_image_id,
self.smoke_flavor.id)
self.verify_response_body_content(server.name,
name,
"Instance creation failed")
# The instance retrieved on creation is missing network
# details, necessitating retrieval after it becomes active to
# ensure correct details.
server = self._wait_server_param(client, server, 'addresses', 5, 1)
self.set_resource(name, server)
return server
def _create_user(self, client, tenant_id):
password = "******"
email = "*****@*****.**"
name = rand_name('ost1_test-user-')
user = client.users.create(name, password, email, tenant_id)
self.users.append(user)
return user
def _create_boot_volume(self, client):
display_name = rand_name('ost1_test-bootable-volume')
imageRef = self.get_image_from_name()
LOG.debug('Image ref is {0}'.format(imageRef))
volume = client.volumes.create(
size=1, display_name=display_name, imageRef=imageRef)
return volume
def sahara_helper(self, image_id, plugin_name, hadoop_version):
# Find flavor id for sahara instances
flavor_id = next(flavor.id
for flavor in self.compute_client.flavors.list()
if flavor.name == 'm1.small')
private_net_id, floating_ip_pool = self.create_network_resources()
# Create json for node group
node_group = {
'name':
'all-in-one',
'flavor_id':
flavor_id,
'node_processes': [
'nodemanager', 'datanode', 'resourcemanager', 'namenode',
'historyserver'
],
'count':
1,
'auto_security_group':
True
}
if floating_ip_pool:
node_group['floating_ip_pool'] = floating_ip_pool
# Create json for Sahara cluster
cluster_json = {
'name': rand_name("ceilo-cluster"),
'plugin_name': plugin_name,
'hadoop_version': hadoop_version,
'default_image_id': image_id,
'cluster_configs': {
'HDFS': {
'dfs.replication': 1
}
},
'node_groups': [node_group],
'net_id': private_net_id
}
# Create Sahara cluster
cluster = self.sahara_client.clusters.create(**cluster_json)
self.addCleanup(
self.delete_resource,
delete_method=lambda: self.sahara_client.clusters.delete(cluster.id
),
get_method=lambda: self.sahara_client.clusters.get(cluster.id))
# Wait for change cluster state for metric: cluster.update
def check_status():
cluster_state = self.sahara_client.clusters.get(cluster.id).status
return cluster_state in ['Waiting', 'Active', 'Error']
fuel_health.test.call_until_true(check_status, 300, 1)
# Delete cluster
self.sahara_client.clusters.delete(cluster.id)
return cluster
def create_alarm(self, **kwargs):
"""This method provides creation of alarm."""
if 'name' in kwargs:
kwargs['name'] = rand_name(kwargs['name'])
alarm = self.ceilometer_client.alarms.create(**kwargs)
self.objects_for_delete.append(
(self.ceilometer_client.alarms.delete, alarm.alarm_id))
return alarm
def neutron_helper(self):
net = self.neutron_client.create_network(
{"network": {"name": rand_name("ceilo-net")}})["network"]
self.addCleanup(self.cleanup_resources,
[(self.neutron_client.delete_network, net["id"])])
self.neutron_client.update_network(
net["id"], {"network": {"name": rand_name("ceilo-net-update")}})
subnet = self.neutron_client.create_subnet(
{"subnet": {"name": rand_name("ceilo-subnet"),
"network_id": net["id"],
"ip_version": 4,
"cidr": "10.0.7.0/24"}})["subnet"]
self.addCleanup(self.cleanup_resources,
[(self.neutron_client.delete_subnet, subnet["id"])])
self.neutron_client.update_subnet(
subnet["id"], {"subnet": {"name": rand_name("ceilo-subnet")}})
port = self.neutron_client.create_port({
"port": {"name": rand_name("ceilo-port"),
"network_id": net["id"]}})['port']
self.addCleanup(self.cleanup_resources,
[(self.neutron_client.delete_port, port["id"])])
self.neutron_client.update_port(
port["id"], {"port": {"name": rand_name("ceilo-port-update")}})
router = self.neutron_client.create_router(
{"router": {"name": rand_name("ceilo-router")}})['router']
self.addCleanup(self.cleanup_resources,
[(self.neutron_client.delete_router, router["id"])])
self.neutron_client.update_router(
router["id"],
{"router": {"name": rand_name("ceilo-router-update")}})
external_network = self.find_external_network()
try:
body = {
"floatingip": {
"floating_network_id": external_network["id"]
}
}
fl_ip = self.neutron_client.create_floatingip(body)["floatingip"]
except neutron_exc.IpAddressGenerationFailureClient:
self.fail('No more IP addresses available on external network.')
self.addCleanup(self.cleanup_resources,
[(self.neutron_client.delete_floatingip, fl_ip["id"])])
self.neutron_client.update_floatingip(
fl_ip["id"], {"floatingip": {"port_id": None}})
self.neutron_client.delete_floatingip(fl_ip["id"])
self.neutron_client.delete_router(router["id"])
self.neutron_client.delete_port(port["id"])
self.neutron_client.delete_subnet(subnet["id"])
self.neutron_client.delete_network(net["id"])
return net, subnet, port, router, fl_ip
def create_alarm(self, **kwargs):
"""This method provides creation of alarm."""
if 'name' in kwargs:
kwargs['name'] = rand_name(kwargs['name'])
alarm = self.ceilometer_client.alarms.create(**kwargs)
self.objects_for_delete.append((self.ceilometer_client.alarms.delete,
alarm.alarm_id))
return alarm
def _create_boot_volume(self, client):
display_name = rand_name('ost1_test-bootable-volume')
imageRef = self.get_image_from_name()
LOG.debug('Image ref is {0} for volume {1}'.format(
imageRef, display_name))
return self._create_volume(client,
display_name=display_name,
imageRef=imageRef)
def _create_keypair(self, client, namestart='ost1_test-keypair-smoke-'):
kp_name = rand_name(namestart)
keypair = client.keypairs.create(kp_name)
self.set_resource(kp_name, keypair)
self.verify_response_body_content(keypair.id,
kp_name,
'Keypair creation failed')
return keypair
def test_check_volume_notifications(self):
"""Ceilometer test to check notifications from Cinder
Target component: Ceilometer
Scenario:
1. Create an instance.
2. Wait for 'ACTIVE' status of the instance.
3. Create a volume and volume snapshot.
4. Get volume snapshot notifications.
5. Get volume notifications.
6. Delete the instance.
Duration: 150 s.
Deployment tags: Ceilometer
"""
if (not self.config.volume.cinder_node_exist
and not self.config.volume.ceph_exist):
self.skipTest('There are no storage nodes for volumes.')
self.check_image_exists()
private_net_id, _ = self.create_network_resources()
fail_msg = 'Failed to create instance.'
msg = 'creating instance'
name = rand_name('ostf-ceilo-instance-')
vcenter = self.config.compute.use_vcenter
image_name = 'TestVM-VMDK' if vcenter else None
instance = self.verify(300, self.create_server, 1, fail_msg, msg, name,
net_id=private_net_id, img_name=image_name)
fail_msg = 'Failed while waiting for "ACTIVE" status of instance.'
msg = 'waiting for "ACTIVE" status of instance'
self.verify(200, self.wait_for_resource_status, 2,
fail_msg, msg, self.compute_client.servers,
instance.id, 'ACTIVE')
fail_msg = 'Failed to create volume and volume snapshot.'
msg = 'creating volume and volume snapshot'
volume, snapshot = self.verify(300, self.volume_helper, 3,
fail_msg, msg, instance)
query = [{'field': 'resource', 'op': 'eq', 'value': snapshot.id}]
fail_msg = 'Failed to get volume snapshot notifications.'
msg = 'getting volume snapshot notifications'
self.verify(300, self.wait_metrics, 4,
fail_msg, msg,
self.snapshot_notifications, query)
query = [{'field': 'resource', 'op': 'eq', 'value': volume.id}]
fail_msg = 'Failed to get volume notifications.'
msg = 'getting volume notifications'
self.verify(300, self.wait_metrics, 5,
fail_msg, msg, self.volume_notifications, query)
fail_msg = 'Failed to delete the server.'
msg = 'deleting server'
self.verify(30, self._delete_server, 6, fail_msg, msg, instance)
def volume_helper(self, instance):
device = '/dev/vdb'
# Create a volume
volume = self.volume_client.volumes.create(
name=rand_name('ost1_test-ceilo-volume'), size=1)
self.addCleanup(
self.delete_resource,
delete_method=lambda: self.volume_client.volumes.delete(volume),
get_method=lambda: self.volume_client.volumes.get(volume.id))
# Wait for "Available" status of the volume
self.wait_for_resource_status(
self.volume_client.volumes, volume.id, 'available')
# Resize the volume
self.volume_client.volumes.extend(volume, 2)
self.wait_for_resource_status(
self.volume_client.volumes, volume.id, 'available')
# Create a volume snapshot
snapshot = self.volume_client.volume_snapshots.create(
volume.id, name=rand_name('ost1_test-'))
self.addCleanup(
self.delete_resource,
delete_method=lambda: self.volume_client.volume_snapshots.delete(
snapshot),
get_method=lambda: self.volume_client.volume_snapshots.get(
snapshot.id))
# Wait for "Available" status of the snapshot
self.wait_for_resource_status(
self.volume_client.volume_snapshots, snapshot.id, 'available')
# Update the volume name
self.volume_client.volumes.update(volume, name="ost1_test-update")
# Attach the volume to the instance
self.volume_client.volumes.attach(volume.id, instance.id, device)
# Detach the volume from the instance
self.volume_client.volumes.detach(volume.id)
# Delete the volume snapshot
self.delete_resource(
delete_method=lambda: self.volume_client.volume_snapshots.delete(
snapshot),
get_method=lambda: self.volume_client.volume_snapshots.get(
snapshot.id))
# Delete the volume
self.delete_resource(
delete_method=lambda: self.volume_client.volumes.delete(volume),
get_method=lambda: self.volume_client.volumes.get(volume.id))
return volume, snapshot
def setUp(self):
super(HeatBaseTest, self).setUp()
self.check_clients_state()
if not self.testvm_flavor:
LOG.debug("Creating a flavor for Heat tests.")
flavor_name = rand_name('ostf-heat-flavor-')
self.testvm_flavor = (self.compute_client.flavors.create(
flavor_name, disk=1, ram=64, vcpus=1))
self.flavors.append(self.testvm_flavor)
def test_002_ironic_node_actions(self):
"""Check that Ironic can operate nodes
Target component: Ironic
Scenario:
1. Create Ironic node with fake driver.
2. Update Ironic node properties.
3. Show and check updated node properties.
4. Delete Ironic node.
Duration: 60 s.
Deployment tags: Ironic
Available since release: 2015.1.0-8.0
"""
# Step 1
fail_msg = "Error creating node."
self.node = self.verify(20,
self.node_create,
1,
fail_msg,
'Node creation',
driver='fake',
extra={'NodeTest': ''})
LOG.debug(self.node)
# Step 2
prop = rand_name("ostf-prop")
value_prop = rand_name("prop-value")
fail_msg = "Can't update node with properties."
self.node = self.verify(20, self.node_update, 2, fail_msg,
'Updating node', self.node, prop, value_prop)
LOG.debug(self.node)
# Step 3
fail_msg = "Can't show node properties."
self.node = self.verify(20, self.node_show, 3, fail_msg,
'Showing node', self.node)
LOG.debug(self.node)
for p, v in self.node.properties.items():
self.verify(5, self.assertTrue, 3, "Can't check node property.",
'Checking node property', prop in p)
self.verify(5, self.assertTrue, 3, "Can't check property value.",
'Checking property value', value_prop in v)
# Step 4
fail_msg = "Can't delete node."
self.verify(20, self.node_delete, 4, fail_msg, 'Deleting node',
self.node)
def test_005_check_public_network_connectivity(self):
"""Check that VM is accessible via floating IP address
Target component: Nova
Scenario:
1. Create a new security group (if it doesn`t exist yet).
2. Create an instance using the new security group
3. Create a new floating IP
4. Assign the new floating IP to the instance.
5. Check connectivity to the floating IP using ping command.
6. Remove server floating ip.
7. Delete server.
Duration: 200 s.
"""
if not self.security_groups:
self.security_groups[self.tenant_id] = self.verify(
25, self._create_security_group, 1,
"Security group can not be created.",
'security group creation',
self.compute_client)
name = rand_name('ost1_test-server-smoke-')
security_groups = [self.security_groups[self.tenant_id].name]
server = self.verify(200, self._create_server, 2,
"Server can not be created.",
"server creation",
self.compute_client, name, security_groups)
floating_ip = self.verify(
20,
self._create_floating_ip,
3,
"Floating IP can not be created.",
'floating IP creation')
self.verify(10, self._assign_floating_ip_to_instance,
4, "Floating IP can not be assigned.",
'floating IP assignment',
self.compute_client, server, floating_ip)
self.floating_ips.append(floating_ip)
self.verify(300, self._check_vm_connectivity, 5,
"VM connectivity doesn`t function properly.",
'VM connectivity checking', floating_ip.ip,
30, (10, 30))
self.verify(10, self.compute_client.servers.remove_floating_ip,
6, "Floating IP cannot be removed.",
"removing floating IP", server, floating_ip)
self.verify(30, self._delete_server, 7,
"Server can not be deleted. ",
"server deletion", server)
def _create_network(self, label='ost1_test-network-smoke-'):
n_label = rand_name(label)
cidr = self.config.network.tenant_network_cidr
networks = self.compute_client.networks.create(label=n_label,
cidr=cidr)
self.set_resource(n_label, networks)
self.network.append(networks)
self.verify_response_body_content(networks.label, n_label,
"Network creation failed")
return networks
def _create_flavors(self, client, ram, disk, vcpus=1):
name = rand_name('ost1_test-flavor-')
flavorid = rand_int_id()
flavor = client.flavors.create(name=name,
ram=ram,
disk=disk,
vcpus=vcpus,
flavorid=flavorid)
self.flavors.append(flavor)
return flavor
def create_flavor(self, ram=256, vcpus=1, disk=2):
"""This method creates a flavor for Heat tests."""
LOG.debug('Creation of Heat tests flavor...')
name = rand_name('ost1_test-heat-flavor-')
flavor = self.compute_client.flavors.create(name, ram, vcpus, disk)
self.addCleanup(self.compute_client.flavors.delete, flavor.id)
LOG.debug('Flavor for Heat tests has been created.')
return flavor
def create_alarm(self, **kwargs):
"""
This method provides creation of alarm
"""
if 'name' in kwargs:
kwargs['name'] = rand_name(kwargs['name'])
alarm = self.ceilometer_client.alarms.create(**kwargs)
if alarm:
self.alarm_id_list.append(alarm.alarm_id)
return alarm
def _create_nano_flavor(cls):
name = rand_name('ost1_test-flavor-nano')
flavorid = rand_int_id(999, 10000)
try:
flavor = cls.compute_client.flavors.create(
name, 64, 1, 1, flavorid)
except Exception:
LOG.debug("OSTF test flavor cannot be created.")
LOG.debug(traceback.format_exc())
return flavor
def setUp(self):
super(HeatBaseTest, self).setUp()
self.check_clients_state()
if not self.testvm_flavor:
LOG.debug("Creating a flavor for Heat tests.")
flavor_name = rand_name('ostf-heat-flavor-')
self.testvm_flavor = (
self.compute_client.flavors.create(flavor_name,
disk=1, ram=64, vcpus=1))
self.flavors.append(self.testvm_flavor)
def create_flavor(self, ram=256, vcpus=1, disk=2):
"""This method creates a flavor for Heat tests."""
LOG.debug('Creation of Heat tests flavor...')
name = rand_name('ost1_test-heat-flavor-')
flavor = self.compute_client.flavors.create(name, ram, vcpus, disk)
self.addCleanup(self.compute_client.flavors.delete, flavor.id)
LOG.debug('Flavor for Heat tests has been created.')
return flavor
def test_008_check_public_instance_connectivity_from_instance(self):
"""Check network connectivity from instance via floating IP
Scenario:
1. Create a new security group (if it doesn`t exist yet).
2. Create an instance using the new security group.
(if it doesn`t exist yet).
3. Create a new floating IP (if it doesn`t exist yet).
4. Assign the new floating IP to the instance.
5. Check that public IP 8.8.8.8 can be pinged from instance.
Duration: 200 s.
Deployment tags: nova_network
"""
if not self.floating_ips:
if not self.servers:
if not self.security_groups:
self.security_groups[self.tenant_id] = self.verify(
25, self._create_security_group, 1,
"Security group can not be created.",
'security group creation', self.compute_client)
name = rand_name('ost1_test-server-smoke-')
security_groups = [self.security_groups[self.tenant_id].name]
server = self.verify(
200, self._create_server, 2,
"Server can not be created.",
'server creation',
self.compute_client, name, security_groups)
self.servers.append(server)
floating_ip = self.verify(
20, self._create_floating_ip, 3,
"Floating IP can not be created.",
'floating IP creation')
self.floating_ips.append(floating_ip)
if self.servers and self.floating_ips:
self.verify(10, self._assign_floating_ip_to_instance, 4,
"Floating IP can not be assigned.",
"floating IP assignment",
self.compute_client,
self.servers[0],
self.floating_ips[0])
if self.floating_ips:
ip_address = self.floating_ips[0].ip
LOG.debug(ip_address)
self.verify(100, self._check_connectivity_from_vm,
5, ("Connectivity to 8.8.8.8 from the VM doesn`t "
"function properly."),
'public connectivity checking from VM', ip_address)
def _create_nano_flavor(cls):
name = rand_name('ost1_test-flavor-nano')
flavorid = rand_int_id(999, 10000)
flavor = None
try:
flavor = cls.compute_client.flavors.create(name, 64, 1, 1,
flavorid)
except Exception:
LOG.debug("OSTF test flavor cannot be created.")
LOG.debug(traceback.format_exc())
return flavor
def _create_network(self, label='ost1_test-network-smoke-'):
n_label = rand_name(label)
cidr = self.config.network.tenant_network_cidr
networks = self.compute_client.networks.create(
label=n_label, cidr=cidr)
self.set_resource(n_label, networks)
self.network.append(networks)
self.verify_response_body_content(networks.label,
n_label,
"Network creation failed")
return networks
def glance_helper(self):
image = self.glance_client.images.create(
name=rand_name('ostf-ceilo-image'))
self.objects_for_delete.append((self.glance_client.images.delete,
image.id))
self.glance_client.images.update(image.id, data='data',
disk_format='qcow2',
container_format='bare')
self.glance_client.images.upload(image.id, 'upload_data')
self.glance_client.images.data(image.id)
self.glance_client.images.delete(image.id)
return image
def test_008_check_public_instance_connectivity_from_instance(self):
"""Check network connectivity from instance via floating IP
Scenario:
1. Create a new security group (if it doesn`t exist yet).
2. Create an instance using the new security group.
(if it doesn`t exist yet).
3. Create a new floating IP (if it doesn`t exist yet).
4. Assign the new floating IP to the instance.
5. Check that public IP 8.8.8.8 can be pinged from instance.
Duration: 200 s.
"""
if not self.floating_ips:
if not self.servers:
if not self.security_groups:
self.security_groups[self.tenant_id] = self.verify(
25, self._create_security_group, 1,
"Security group can not be created.",
'security group creation', self.compute_client)
name = rand_name('ost1_test-server-smoke-')
security_groups = [self.security_groups[self.tenant_id].name]
server = self.verify(
200, self._create_server, 2,
"Server can not be created.",
'server creation',
self.compute_client, name, security_groups)
self.servers.append(server)
floating_ip = self.verify(
20, self._create_floating_ip, 3,
"Floating IP can not be created.",
'floating IP creation')
self.floating_ips.append(floating_ip)
if self.servers and self.floating_ips:
self.verify(10, self._assign_floating_ip_to_instance, 4,
"Floating IP can not be assigned.",
"floating IP assignment",
self.compute_client,
self.servers[0],
self.floating_ips[0])
if self.floating_ips:
ip_address = self.floating_ips[0].ip
LOG.debug(ip_address)
self.verify(100, self._check_connectivity_from_vm,
5, ("Connectivity to 8.8.8.8 from the VM doesn`t "
"function properly."),
'public connectivity checking from VM', ip_address)
def _create_image(self, server):
snapshot_name = rand_name('ost1_test-snapshot-')
create_image_client = self.compute_client.servers.create_image
image_id = create_image_client(server, snapshot_name)
self.addCleanup(self.compute_client.images.delete, image_id)
self._wait_for_server_status(server, 'ACTIVE')
self._wait_for_image_status(image_id, 'ACTIVE')
snapshot_image = self.compute_client.images.get(image_id)
self.verify_response_body_content(
snapshot_name, snapshot_image.name,
msg="Please refer to OpenStack logs for more details.")
return image_id
def test_2_vcenter_check_internet_connectivity_without_floatingIP(self):
"""vCenter: Check network connectivity from instance without floating \
IP
Target component: Nova
Scenario:
1. Create a new security group (if it doesn`t exist yet).
2. Create an instance using the new security group.
(if it doesn`t exist yet).
3. Check that public IP 8.8.8.8 can be pinged from instance.
4. Delete server.
Duration: 300 s.
Available since release: 2014.2-6.1
Deployment tags: nova_network, use_vcenter
"""
self.check_image_exists()
if not self.security_groups:
self.security_groups[self.tenant_id] = self.verify(
25, self._create_security_group, 1,
"Security group can not be created.",
'security group creation', self.compute_client)
name = rand_name('ost1_test-server-smoke-')
security_groups = [self.security_groups[self.tenant_id].name]
img_name = 'TestVM-VMDK'
compute = None
server = self.verify(
250, self._create_server, 2,
"Server can not be created.",
'server creation',
self.compute_client, name, security_groups, None, None, img_name)
try:
for addr in server.addresses:
if addr.startswith('novanetwork'):
instance_ip = server.addresses[addr][0]['addr']
except Exception:
LOG.exception()
self.fail("Step 3 failed: cannot get instance details. "
"Please refer to OpenStack logs for more details.")
self.verify(400, self._check_connectivity_from_vm,
3, ("Connectivity to 8.8.8.8 from the VM doesn`t "
"function properly."),
'public connectivity checking from VM',
instance_ip, 30, (6, 30), compute)
self.verify(30, self._delete_server, 4,
"Server can not be deleted. ",
"server deletion", server)
def create_flavor(self, ram=1024, vcpus=1, disk=20):
"""This method creates a flavor for Sahara tests.
All resources created by this method will be automatically deleted.
"""
LOG.debug('Creating flavor for Sahara tests...')
name = rand_name('sahara-flavor-')
flavor = self.compute_client.flavors.create(name, ram, vcpus, disk)
self.addCleanup(self.compute_client.flavors.delete, flavor.id)
LOG.debug('Flavor for Sahara tests has been created.')
return flavor.id
def _create_node_group_template(
cls, client, name, plugin_name, plugin_version, description,
volumes_per_node, volume_size, node_processes, node_configs,
floating_ip_pool=None):
body = client.node_group_templates.create(
rand_name(name), plugin_name, plugin_version, cls.sahara_flavor,
description, volumes_per_node, volume_size, node_processes,
node_configs, floating_ip_pool)
if body:
cls.node_groups.append(body.id)
return body
def _boot_image(self, image_id):
if not self.find_micro_flavor():
self.fail("Flavor for tests was not created. Seems that "
"something is wrong with nova services.")
else:
flavor_id = self.micro_flavors[0]
disk = self.glance_client_v1.images.get(image_id).disk_format
if disk == 'vmdk':
az_name = 'vcenter'
else:
az_name = 'nova'
name = rand_name('ost1_test-image')
client = self.compute_client
LOG.debug("name:%s, image:%s" % (name, image_id))
if 'neutron' in self.config.network.network_provider:
network = [
net.id for net in self.compute_client.networks.list()
if net.label == self.private_net
]
if network:
create_kwargs = {
'nics': [
{
'net-id': network[0]
},
],
}
else:
self.fail("Default private network '{0}' isn't present. "
"Please verify it is properly created.".format(
self.private_net))
server = client.servers.create(name=name,
image=image_id,
flavor=flavor_id,
availability_zone=az_name,
**create_kwargs)
else:
server = client.servers.create(name=name,
image=image_id,
flavor=flavor_id,
availability_zone=az_name)
self.set_resource(name, server)
self.verify_response_body_content(
name,
server.name,
msg="Please refer to OpenStack logs for more details.")
self._wait_for_server_status(server, 'ACTIVE')
server = client.servers.get(server) # getting network information
LOG.debug("server:%s" % server)
return server
