X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=functest%2Fopnfv_tests%2Fvnf%2Fims%2Fcloudify_ims.py;h=786c535ed4f76044956b7b89828ade37033acb9b;hb=refs%2Fchanges%2F33%2F59633%2F2;hp=d97a0bcdaad785090b168da05f4b8c6fb080fc53;hpb=01a5192428eb99afcb94047e6faa54e1d57114d1;p=functest.git diff --git a/functest/opnfv_tests/vnf/ims/cloudify_ims.py b/functest/opnfv_tests/vnf/ims/cloudify_ims.py index d97a0bcda..786c535ed 100644 --- a/functest/opnfv_tests/vnf/ims/cloudify_ims.py +++ b/functest/opnfv_tests/vnf/ims/cloudify_ims.py @@ -9,21 +9,17 @@ """CloudifyIms testcase implementation.""" +from __future__ import division + import logging import os import time +import uuid from cloudify_rest_client import CloudifyClient from cloudify_rest_client.executions import Execution from scp import SCPClient -import yaml - -from functest.energy import energy -from functest.opnfv_tests.openstack.snaps import snaps_utils -import functest.opnfv_tests.vnf.ims.clearwater_ims_base as clearwater_ims_base -from functest.utils.constants import CONST -import functest.utils.openstack_utils as os_utils - +import six from snaps.config.flavor import FlavorConfig from snaps.config.image import ImageConfig from snaps.config.keypair import KeypairConfig @@ -31,8 +27,8 @@ from snaps.config.network import NetworkConfig, PortConfig, SubnetConfig from snaps.config.router import RouterConfig from snaps.config.security_group import ( Direction, Protocol, SecurityGroupConfig, SecurityGroupRuleConfig) +from snaps.config.user import UserConfig from snaps.config.vm_inst import FloatingIpConfig, VmInstanceConfig - from snaps.openstack.create_flavor import OpenStackFlavor from snaps.openstack.create_image import OpenStackImage from snaps.openstack.create_instance import OpenStackVmInstance @@ -40,7 +36,15 @@ from snaps.openstack.create_keypairs import OpenStackKeypair from snaps.openstack.create_network import OpenStackNetwork from snaps.openstack.create_router import OpenStackRouter from snaps.openstack.create_security_group import OpenStackSecurityGroup +from snaps.openstack.create_user import OpenStackUser +from snaps.openstack.utils import keystone_utils +from xtesting.energy import energy +import yaml +from functest.opnfv_tests.openstack.snaps import snaps_utils +from functest.opnfv_tests.vnf.ims import clearwater_ims_base +from functest.utils import config +from functest.utils import env __author__ = "Valentin Boucher " @@ -58,13 +62,11 @@ class CloudifyIms(clearwater_ims_base.ClearwaterOnBoardingBase): # Retrieve the configuration try: - self.config = CONST.__getattribute__( - 'vnf_{}_config'.format(self.case_name)) + self.config = getattr( + config.CONF, 'vnf_{}_config'.format(self.case_name)) except Exception: raise Exception("VNF config file not found") - self.snaps_creds = '' - config_file = os.path.join(self.case_dir, self.config) self.orchestrator = dict( requirements=get_config("orchestrator.requirements", config_file), @@ -115,49 +117,82 @@ class CloudifyIms(clearwater_ims_base.ClearwaterOnBoardingBase): compute_quotas = self.os_project.update_compute_quotas(compute_quotas) network_quotas = self.os_project.update_network_quotas(network_quotas) - # needs some images - self.__logger.info("Upload some OS images if it doesn't exist") - for image_name, image_file in self.images.iteritems(): - self.__logger.info("image: %s, file: %s", image_name, image_file) - if image_file and image_name: - image_creator = OpenStackImage( - self.snaps_creds, - ImageConfig( - name=image_name, image_user='cloud', - img_format='qcow2', image_file=image_file)) - image_creator.create() - # self.created_object.append(image_creator) - def deploy_orchestrator(self): + # pylint: disable=too-many-locals,too-many-statements """ Deploy Cloudify Manager. network, security group, fip, VM creation """ - # network creation - start_time = time.time() + + # orchestrator VM flavor + self.__logger.info("Get or create flavor for cloudify manager vm ...") + flavor_settings = FlavorConfig( + name="{}-{}".format( + self.orchestrator['requirements']['flavor']['name'], + self.uuid), + ram=self.orchestrator['requirements']['flavor']['ram_min'], + disk=50, + vcpus=2) + flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) + flavor_creator.create() + self.created_object.append(flavor_creator) + + self.__logger.info("Creating a second user to bypass issues ...") + user_creator = OpenStackUser( + self.snaps_creds, + UserConfig( + name='cloudify_network_bug-{}'.format(self.uuid), + password=str(uuid.uuid4()), + project_name=self.tenant_name, + domain_name=self.snaps_creds.user_domain_name, + roles={'_member_': self.tenant_name})) + user_creator.create() + self.created_object.append(user_creator) + + snaps_creds = user_creator.get_os_creds(self.snaps_creds.project_name) + self.__logger.debug("snaps creds: %s", snaps_creds) + self.__logger.info("Creating keypair ...") kp_file = os.path.join(self.data_dir, "cloudify_ims.pem") - keypair_settings = KeypairConfig(name='cloudify_ims_kp', - private_filepath=kp_file) - keypair_creator = OpenStackKeypair(self.snaps_creds, keypair_settings) + keypair_settings = KeypairConfig( + name='cloudify_ims_kp-{}'.format(self.uuid), + private_filepath=kp_file) + keypair_creator = OpenStackKeypair(snaps_creds, keypair_settings) keypair_creator.create() self.created_object.append(keypair_creator) + # needs some images + self.__logger.info("Upload some OS images if it doesn't exist") + for image_name, image_file in six.iteritems(self.images): + self.__logger.info("image: %s, file: %s", image_name, image_file) + if image_file and image_name: + image_creator = OpenStackImage( + snaps_creds, + ImageConfig( + name=image_name, image_user='cloud', + img_format='qcow2', image_file=image_file)) + image_creator.create() + self.created_object.append(image_creator) + + # network creation self.__logger.info("Creating full network ...") - subnet_settings = SubnetConfig(name='cloudify_ims_subnet', - cidr='10.67.79.0/24') - network_settings = NetworkConfig(name='cloudify_ims_network', - subnet_settings=[subnet_settings]) - network_creator = OpenStackNetwork(self.snaps_creds, network_settings) + subnet_settings = SubnetConfig( + name='cloudify_ims_subnet-{}'.format(self.uuid), + cidr='10.67.79.0/24', + dns_nameservers=[env.get('NAMESERVER')]) + network_settings = NetworkConfig( + name='cloudify_ims_network-{}'.format(self.uuid), + subnet_settings=[subnet_settings]) + network_creator = OpenStackNetwork(snaps_creds, network_settings) network_creator.create() self.created_object.append(network_creator) - ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds) + ext_net_name = snaps_utils.get_ext_net_name(snaps_creds) router_creator = OpenStackRouter( - self.snaps_creds, + snaps_creds, RouterConfig( - name='cloudify_ims_router', + name='cloudify_ims_router-{}'.format(self.uuid), external_gateway=ext_net_name, internal_subnets=[subnet_settings.name])) router_creator.create() @@ -168,124 +203,118 @@ class CloudifyIms(clearwater_ims_base.ClearwaterOnBoardingBase): sg_rules = list() sg_rules.append( SecurityGroupRuleConfig( - sec_grp_name="sg-cloudify-manager", + sec_grp_name="sg-cloudify-manager-{}".format(self.uuid), direction=Direction.ingress, protocol=Protocol.tcp, port_range_min=1, port_range_max=65535)) sg_rules.append( SecurityGroupRuleConfig( - sec_grp_name="sg-cloudify-manager", + sec_grp_name="sg-cloudify-manager-{}".format(self.uuid), direction=Direction.ingress, protocol=Protocol.udp, port_range_min=1, port_range_max=65535)) - - securit_group_creator = OpenStackSecurityGroup( - self.snaps_creds, + security_group_creator = OpenStackSecurityGroup( + snaps_creds, SecurityGroupConfig( - name="sg-cloudify-manager", + name="sg-cloudify-manager-{}".format(self.uuid), rule_settings=sg_rules)) + security_group_creator.create() + self.created_object.append(security_group_creator) - securit_group_creator.create() - self.created_object.append(securit_group_creator) - - # orchestrator VM flavor - self.__logger.info("Get or create flavor for cloudify manager vm ...") - - flavor_settings = FlavorConfig( - name=self.orchestrator['requirements']['flavor']['name'], - ram=self.orchestrator['requirements']['flavor']['ram_min'], - disk=50, - vcpus=2) - flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) - flavor_creator.create() - self.created_object.append(flavor_creator) image_settings = ImageConfig( name=self.orchestrator['requirements']['os_image'], image_user='centos', exists=True) - - port_settings = PortConfig(name='cloudify_manager_port', - network_name=network_settings.name) - + port_settings = PortConfig( + name='cloudify_manager_port-{}'.format(self.uuid), + network_name=network_settings.name) manager_settings = VmInstanceConfig( - name='cloudify_manager', + name='cloudify_manager-{}'.format(self.uuid), flavor=flavor_settings.name, port_settings=[port_settings], - security_group_names=[securit_group_creator.sec_grp_settings.name], + security_group_names=[ + security_group_creator.sec_grp_settings.name], floating_ip_settings=[FloatingIpConfig( - name='cloudify_manager_fip', + name='cloudify_manager_fip-{}'.format(self.uuid), port_name=port_settings.name, router_name=router_creator.router_settings.name)]) - - manager_creator = OpenStackVmInstance(self.snaps_creds, - manager_settings, - image_settings, - keypair_settings) - + manager_creator = OpenStackVmInstance( + snaps_creds, manager_settings, image_settings, + keypair_settings) self.__logger.info("Creating cloudify manager VM") manager_creator.create() self.created_object.append(manager_creator) - public_auth_url = os_utils.get_endpoint('identity') + public_auth_url = keystone_utils.get_endpoint(snaps_creds, 'identity') - self.__logger.info("Set creds for cloudify manager") - cfy_creds = dict(keystone_username=self.tenant_name, - keystone_password=self.tenant_name, - keystone_tenant_name=self.tenant_name, - keystone_url=public_auth_url) + cfy_creds = dict( + keystone_username=snaps_creds.username, + keystone_password=snaps_creds.password, + keystone_tenant_name=snaps_creds.project_name, + keystone_url=public_auth_url, + region=snaps_creds.region_name if snaps_creds.region_name else ( + 'RegionOne'), + user_domain_name=snaps_creds.user_domain_name, + project_domain_name=snaps_creds.project_domain_name) + self.__logger.info("Set creds for cloudify manager %s", cfy_creds) - cfy_client = CloudifyClient(host=manager_creator.get_floating_ip().ip, - username='admin', - password='admin', - tenant='default_tenant') + cfy_client = CloudifyClient( + host=manager_creator.get_floating_ip().ip, + username='admin', password='admin', tenant='default_tenant', + api_version='v3') self.orchestrator['object'] = cfy_client self.__logger.info("Attemps running status of the Manager") - cfy_status = None - retry = 10 - while str(cfy_status) != 'running' and retry: + for loop in range(10): try: + self.__logger.debug( + "status %s", cfy_client.manager.get_status()) cfy_status = cfy_client.manager.get_status()['status'] - self.__logger.debug("The current manager status is %s", - cfy_status) + self.__logger.info( + "The current manager status is %s", cfy_status) + if str(cfy_status) != 'running': + raise Exception("Cloudify Manager isn't up and running") + self.__logger.info("Put OpenStack creds in manager") + secrets_list = cfy_client.secrets.list() + for k, val in six.iteritems(cfy_creds): + if not any(d.get('key', None) == k for d in secrets_list): + cfy_client.secrets.create(k, val) + else: + cfy_client.secrets.update(k, val) + break except Exception: # pylint: disable=broad-except - self.__logger.warning("Cloudify Manager isn't " + - "up and running. Retrying ...") - retry = retry - 1 - time.sleep(30) - - if str(cfy_status) == 'running': - self.__logger.info("Cloudify Manager is up and running") + self.logger.info( + "try %s: Cloudify Manager isn't up and running", loop + 1) + time.sleep(30) else: - raise Exception("Cloudify Manager isn't up and running") - - self.__logger.info("Put OpenStack creds in manager") - secrets_list = cfy_client.secrets.list() - for k, val in cfy_creds.iteritems(): - if not any(d.get('key', None) == k for d in secrets_list): - cfy_client.secrets.create(k, val) - else: - cfy_client.secrets.update(k, val) + self.logger.error("Cloudify Manager isn't up and running") + return False duration = time.time() - start_time - self.__logger.info("Put private keypair in manager") if manager_creator.vm_ssh_active(block=True): + self.__logger.info("Put private keypair in manager") ssh = manager_creator.ssh_client() scp = SCPClient(ssh.get_transport(), socket_timeout=15.0) scp.put(kp_file, '~/') cmd = "sudo cp ~/cloudify_ims.pem /etc/cloudify/" - run_blocking_ssh_command(ssh, cmd) + self.run_blocking_ssh_command(ssh, cmd) cmd = "sudo chmod 444 /etc/cloudify/cloudify_ims.pem" - run_blocking_ssh_command(ssh, cmd) - cmd = "sudo yum install -y gcc python-devel" - run_blocking_ssh_command(ssh, cmd, "Unable to install packages \ - on manager") + self.run_blocking_ssh_command(ssh, cmd) + # cmd2 is badly unpinned by Cloudify + cmd = "sudo yum install -y gcc python-devel python-cmd2" + self.run_blocking_ssh_command( + ssh, cmd, "Unable to install packages on manager") + self.run_blocking_ssh_command(ssh, 'cfy status') + else: + self.__logger.error("Cannot connect to manager") + return False self.details['orchestrator'].update(status='PASS', duration=duration) self.vnf['inputs'].update(dict( external_network_name=ext_net_name, - network_name=network_settings.name + network_name=network_settings.name, + key_pair_name=keypair_settings.name )) self.result = 1/3 * 100 return True @@ -297,22 +326,22 @@ class CloudifyIms(clearwater_ims_base.ClearwaterOnBoardingBase): self.__logger.info("Upload VNFD") cfy_client = self.orchestrator['object'] descriptor = self.vnf['descriptor'] - cfy_client.blueprints.publish_archive(descriptor.get('url'), - descriptor.get('name'), - descriptor.get('file_name')) - + cfy_client.blueprints.upload( + descriptor.get('file_name'), descriptor.get('name')) self.__logger.info("Get or create flavor for all clearwater vm") flavor_settings = FlavorConfig( - name=self.vnf['requirements']['flavor']['name'], + name="{}-{}".format( + self.vnf['requirements']['flavor']['name'], + self.uuid), ram=self.vnf['requirements']['flavor']['ram_min'], disk=25, - vcpus=1) + vcpus=2) flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) flavor_creator.create() self.created_object.append(flavor_creator) self.vnf['inputs'].update(dict( - flavor_id=self.vnf['requirements']['flavor']['name'], + flavor_id=flavor_settings.name, )) self.__logger.info("Create VNF Instance") @@ -320,17 +349,17 @@ class CloudifyIms(clearwater_ims_base.ClearwaterOnBoardingBase): descriptor.get('name'), self.vnf.get('inputs')) - wait_for_execution(cfy_client, - _get_deployment_environment_creation_execution( - cfy_client, descriptor.get('name')), - self.__logger, - timeout=600) + wait_for_execution( + cfy_client, + get_execution_id(cfy_client, descriptor.get('name')), + self.__logger, timeout=300) self.__logger.info("Start the VNF Instance deployment") execution = cfy_client.executions.start(descriptor.get('name'), 'install') # Show execution log - execution = wait_for_execution(cfy_client, execution, self.__logger) + execution = wait_for_execution( + cfy_client, execution, self.__logger, timeout=3600) duration = time.time() - start_time @@ -359,25 +388,27 @@ class CloudifyIms(clearwater_ims_base.ClearwaterOnBoardingBase): if not dns_ip: return False - vims_test_result = self.run_clearwater_live_test( + short_result = self.run_clearwater_live_test( dns_ip=dns_ip, public_domain=self.vnf['inputs']["public_domain"]) duration = time.time() - start_time - short_result, nb_test = sig_test_format(vims_test_result) self.__logger.info(short_result) self.details['test_vnf'].update(result=short_result, - full_result=vims_test_result, duration=duration) try: - vnf_test_rate = short_result['passed'] / nb_test + vnf_test_rate = short_result['passed'] / ( + short_result['total'] - short_result['skipped']) # orchestrator + vnf + test_vnf self.result += vnf_test_rate / 3 * 100 except ZeroDivisionError: self.__logger.error("No test has been executed") self.details['test_vnf'].update(status='FAIL') return False - - return True + except Exception: # pylint: disable=broad-except + self.__logger.exception("Cannot calculate results") + self.details['test_vnf'].update(status='FAIL') + return False + return True if vnf_test_rate > 0 else False def clean(self): """Clean created objects/functions.""" @@ -392,7 +423,7 @@ class CloudifyIms(clearwater_ims_base.ClearwaterOnBoardingBase): try: cfy_client.executions.cancel(execution['id'], force=True) - except: # pylint: disable=broad-except + except Exception: # pylint: disable=broad-except self.__logger.warn("Can't cancel the current exec") execution = cfy_client.executions.start( @@ -404,12 +435,21 @@ class CloudifyIms(clearwater_ims_base.ClearwaterOnBoardingBase): wait_for_execution(cfy_client, execution, self.__logger) cfy_client.deployments.delete(self.vnf['descriptor'].get('name')) cfy_client.blueprints.delete(self.vnf['descriptor'].get('name')) - except: # pylint: disable=broad-except - self.__logger.warn("Some issue during the undeployment ..") - self.__logger.warn("Tenant clean continue ..") + except Exception: # pylint: disable=broad-except + self.__logger.exception("Some issue during the undeployment ..") super(CloudifyIms, self).clean() + @staticmethod + def run_blocking_ssh_command(ssh, cmd, + error_msg="Unable to run this command"): + """Command to run ssh command with the exit status.""" + _, stdout, stderr = ssh.exec_command(cmd) + CloudifyIms.__logger.debug("SSH %s stdout: %s", cmd, stdout.read()) + if stdout.channel.recv_exit_status() != 0: + CloudifyIms.__logger.error("SSH %s stderr: %s", cmd, stderr.read()) + raise Exception(error_msg) + @energy.enable_recording def run(self, **kwargs): """Execute CloudifyIms test case.""" @@ -441,7 +481,7 @@ def get_config(parameter, file_path): return value -def wait_for_execution(client, execution, logger, timeout=2400, ): +def wait_for_execution(client, execution, logger, timeout=3600, ): """Wait for a workflow execution on Cloudify Manager.""" # if execution already ended - return without waiting if execution.status in Execution.END_STATES: @@ -461,7 +501,7 @@ def wait_for_execution(client, execution, logger, timeout=2400, ): execution_id=execution.id, _offset=offset, _size=batch_size, - include_logs=False, + include_logs=True, sort='@timestamp').items offset = offset + len(event_list) @@ -490,7 +530,7 @@ def wait_for_execution(client, execution, logger, timeout=2400, ): return execution -def _get_deployment_environment_creation_execution(client, deployment_id): +def get_execution_id(client, deployment_id): """ Get the execution id of a env preparation. @@ -503,30 +543,3 @@ def _get_deployment_environment_creation_execution(client, deployment_id): raise RuntimeError('Failed to get create_deployment_environment ' 'workflow execution.' 'Available executions: {0}'.format(executions)) - - -def sig_test_format(sig_test): - """Process the signaling result to have a short result.""" - nb_passed = 0 - nb_failures = 0 - nb_skipped = 0 - for data_test in sig_test: - if data_test['result'] == "Passed": - nb_passed += 1 - elif data_test['result'] == "Failed": - nb_failures += 1 - elif data_test['result'] == "Skipped": - nb_skipped += 1 - short_sig_test_result = {} - short_sig_test_result['passed'] = nb_passed - short_sig_test_result['failures'] = nb_failures - short_sig_test_result['skipped'] = nb_skipped - nb_test = nb_passed + nb_skipped - return (short_sig_test_result, nb_test) - - -def run_blocking_ssh_command(ssh, cmd, error_msg="Unable to run this command"): - """Command to run ssh command with the exit status.""" - stdin, stdout, stderr = ssh.exec_command(cmd) - if stdout.channel.recv_exit_status() != 0: - raise Exception(error_msg)