X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=functest%2Fopnfv_tests%2Fvnf%2Frouter%2Fcloudify_vrouter.py;h=e8c8632bdd7bc66feb8cfde602f4f2727292d232;hb=65b9318ffcb4b12e0aa4aa08027a35ff1e2d285d;hp=020085ba915ac414f2000b12ae027bfae0fb7691;hpb=8e416aee220bf6959e2e21f18a5ebfec1421858b;p=functest.git diff --git a/functest/opnfv_tests/vnf/router/cloudify_vrouter.py b/functest/opnfv_tests/vnf/router/cloudify_vrouter.py index 020085ba9..e8c8632bd 100644 --- a/functest/opnfv_tests/vnf/router/cloudify_vrouter.py +++ b/functest/opnfv_tests/vnf/router/cloudify_vrouter.py @@ -15,48 +15,31 @@ import logging import os import time -from cloudify_rest_client import CloudifyClient from cloudify_rest_client.executions import Execution -from scp import SCPClient +import pkg_resources +import scp -from functest.opnfv_tests.openstack.snaps import snaps_utils -import functest.opnfv_tests.vnf.router.vrouter_base as vrouter_base +from functest.core import cloudify +from functest.opnfv_tests.vnf.router import vrouter_base from functest.opnfv_tests.vnf.router.utilvnf import Utilvnf -from functest.utils.constants import CONST +from functest.utils import config from functest.utils import functest_utils -from git import Repo - -from snaps.config.flavor import FlavorConfig -from snaps.config.image import ImageConfig -from snaps.config.keypair import KeypairConfig -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.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 -from snaps.openstack.create_keypairs import OpenStackKeypair -from snaps.openstack.create_network import OpenStackNetwork -from snaps.openstack.create_security_group import OpenStackSecurityGroup -from snaps.openstack.create_router import OpenStackRouter - -import snaps.openstack.utils.glance_utils as glance_utils -from snaps.openstack.utils import keystone_utils - __author__ = "Shuya Nakama " -class CloudifyVrouter(vrouter_base.VrouterOnBoardingBase): +class CloudifyVrouter(cloudify.Cloudify): # pylint: disable=too-many-instance-attributes """vrouter testcase deployed with Cloudify Orchestrator.""" __logger = logging.getLogger(__name__) - name = __name__ + + filename_alt = '/home/opnfv/functest/images/vyos-1.1.7.img' + + flavor_alt_ram = 2048 + flavor_alt_vcpus = 1 + flavor_alt_disk = 50 def __init__(self, **kwargs): if "case_name" not in kwargs: @@ -65,18 +48,13 @@ class CloudifyVrouter(vrouter_base.VrouterOnBoardingBase): # 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 = '' - self.created_object = [] - - self.cfy_manager_ip = '' - self.util_info = {} - self.deployment_name = '' - + self.case_dir = pkg_resources.resource_filename( + 'functest', 'opnfv_tests/vnf/router') config_file = os.path.join(self.case_dir, self.config) self.orchestrator = dict( requirements=functest_utils.get_parameter_from_yaml( @@ -91,7 +69,7 @@ class CloudifyVrouter(vrouter_base.VrouterOnBoardingBase): result='' ) self.__logger.debug("Orchestrator configuration %s", self.orchestrator) - self.__logger.debug("name = %s", self.name) + self.__logger.debug("name = %s", __name__) self.vnf = dict( descriptor=functest_utils.get_parameter_from_yaml( "vnf.descriptor", config_file), @@ -110,6 +88,10 @@ class CloudifyVrouter(vrouter_base.VrouterOnBoardingBase): self.__logger.debug("VNF configuration: %s", self.vnf) self.util = Utilvnf() + self.util.set_credentials(self.cloud) + credentials = {"cloud": self.cloud} + self.util_info = {"credentials": credentials, + "vnf_data_dir": self.util.vnf_data_dir} self.details['test_vnf'] = dict( name=functest_utils.get_parameter_from_yaml( @@ -121,253 +103,95 @@ class CloudifyVrouter(vrouter_base.VrouterOnBoardingBase): "tenant_images", config_file) self.__logger.info("Images needed for vrouter: %s", self.images) - def prepare(self): - super(CloudifyVrouter, self).prepare() - - self.__logger.info("Additional pre-configuration steps") - - self.util.set_credentials(self.snaps_creds) + self.image_alt = None + self.flavor_alt = None - # 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): + def execute(self): # pylint: disable=too-many-locals,too-many-statements """ Deploy Cloudify Manager. network, security group, fip, VM creation """ # network creation - + super(CloudifyVrouter, self).execute() start_time = time.time() - self.__logger.info("Creating keypair ...") - kp_file = os.path.join(self.data_dir, "cloudify_vrouter.pem") - keypair_settings = KeypairConfig(name='cloudify_vrouter_kp', - private_filepath=kp_file) - keypair_creator = OpenStackKeypair(self.snaps_creds, keypair_settings) - keypair_creator.create() - self.created_object.append(keypair_creator) - - self.__logger.info("Creating full network ...") - subnet_settings = SubnetConfig(name='cloudify_vrouter_subnet', - cidr='10.67.79.0/24') - network_settings = NetworkConfig(name='cloudify_vrouter_network', - subnet_settings=[subnet_settings]) - network_creator = OpenStackNetwork(self.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) - router_creator = OpenStackRouter( - self.snaps_creds, - RouterConfig( - name='cloudify_vrouter_router', - external_gateway=ext_net_name, - internal_subnets=[subnet_settings.name])) - router_creator.create() - self.created_object.append(router_creator) - - # security group creation - self.__logger.info("Creating security group for cloudify manager vm") - sg_rules = list() - sg_rules.append( - SecurityGroupRuleConfig(sec_grp_name="sg-cloudify-manager", - direction=Direction.ingress, - protocol=Protocol.tcp, port_range_min=1, - port_range_max=65535)) - sg_rules.append( - SecurityGroupRuleConfig(sec_grp_name="sg-cloudify-manager", - direction=Direction.ingress, - protocol=Protocol.udp, port_range_min=1, - port_range_max=65535)) - - security_group_creator = OpenStackSecurityGroup( - self.snaps_creds, - SecurityGroupConfig( - name="sg-cloudify-manager", - rule_settings=sg_rules)) - - security_group_creator.create() - self.created_object.append(security_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) - - manager_settings = VmInstanceConfig( - name='cloudify_manager', - flavor=flavor_settings.name, - port_settings=[port_settings], - security_group_names=[ - security_group_creator.sec_grp_settings.name], - floating_ip_settings=[FloatingIpConfig( - name='cloudify_manager_fip', - port_name=port_settings.name, - router_name=router_creator.router_settings.name)]) - - manager_creator = OpenStackVmInstance(self.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 = keystone_utils.get_endpoint( - self.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_client = CloudifyClient(host=manager_creator.get_floating_ip().ip, - username='admin', - password='admin', - tenant='default_tenant') - - self.orchestrator['object'] = cfy_client - - self.cfy_manager_ip = manager_creator.get_floating_ip().ip - - self.__logger.info("Attemps running status of the Manager") - cfy_status = None - retry = 10 - while str(cfy_status) != 'running' and retry: - try: - cfy_status = cfy_client.manager.get_status()['status'] - self.__logger.debug("The current manager status is %s", - cfy_status) - 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") - 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) - - duration = time.time() - start_time - self.__logger.info("Put private keypair in manager") - if manager_creator.vm_ssh_active(block=True): - ssh = manager_creator.ssh_client() - scp = SCPClient(ssh.get_transport(), socket_timeout=15.0) - scp.put(kp_file, '~/') - cmd = "sudo cp ~/cloudify_vrouter.pem /etc/cloudify/" - run_blocking_ssh_command(ssh, cmd) - cmd = "sudo chmod 444 /etc/cloudify/cloudify_vrouter.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") + scpc = scp.SCPClient(self.ssh.get_transport()) + scpc.put(self.key_filename, remote_path='~/cloudify_ims.pem') + (_, stdout, stderr) = self.ssh.exec_command( + "sudo cp ~/cloudify_ims.pem /etc/cloudify/ && " + "sudo chmod 444 /etc/cloudify/cloudify_ims.pem && " + "sudo yum install -y gcc python-devel python-cmd2 && " + "cfy status") + self.__logger.info("output:\n%s", stdout.read()) + self.__logger.info("error:\n%s", stderr.read()) + + self.image_alt = self.publish_image_alt() + self.flavor_alt = self.create_flavor_alt() + duration = time.time() - start_time self.details['orchestrator'].update(status='PASS', duration=duration) - self.vnf['inputs'].update(dict(external_network_name=ext_net_name)) - - return True + self.vnf['inputs'].update(dict( + external_network_name=self.ext_net.name)) + self.vnf['inputs'].update(dict( + target_vnf_image_id=self.image_alt.id)) + self.vnf['inputs'].update(dict( + reference_vnf_image_id=self.image_alt.id)) + self.vnf['inputs'].update(dict( + target_vnf_flavor_id=self.flavor_alt.id)) + self.vnf['inputs'].update(dict( + reference_vnf_flavor_id=self.flavor_alt.id)) + self.vnf['inputs'].update(dict( + keystone_username=self.project.user.name)) + self.vnf['inputs'].update(dict( + keystone_password=self.project.password)) + self.vnf['inputs'].update(dict( + keystone_tenant_name=self.project.project.name)) + self.vnf['inputs'].update(dict( + keystone_user_domain_name=os.environ.get( + 'OS_USER_DOMAIN_NAME', 'Default'))) + self.vnf['inputs'].update(dict( + keystone_project_domain_name=os.environ.get( + 'OS_PROJECT_DOMAIN_NAME', 'Default'))) + self.vnf['inputs'].update(dict( + region=os.environ.get('OS_REGION_NAME', 'RegionOne'))) + self.vnf['inputs'].update(dict( + keystone_url=self.get_public_auth_url(self.orig_cloud))) + + if self.deploy_vnf() and self.test_vnf(): + self.result = 100 + return 0 + self.result = 1/3 * 100 + return 1 def deploy_vnf(self): start_time = time.time() - self.__logger.info("Upload VNFD") - cfy_client = self.orchestrator['object'] descriptor = self.vnf['descriptor'] - self.deployment_name = descriptor.get('name') - - vrouter_blueprint_dir = os.path.join(self.data_dir, - self.util.blueprint_dir) - if not os.path.exists(vrouter_blueprint_dir): - Repo.clone_from(descriptor.get('url'), - vrouter_blueprint_dir, - branch=descriptor.get('version')) - - cfy_client.blueprints.upload(vrouter_blueprint_dir + - self.util.blueprint_file_name, - descriptor.get('name')) - - self.__logger.info("Get or create flavor for vrouter") - flavor_settings = FlavorConfig( - name=self.vnf['requirements']['flavor']['name'], - ram=self.vnf['requirements']['flavor']['ram_min'], - disk=25, - vcpus=1) - flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) - flavor = flavor_creator.create() - self.created_object.append(flavor_creator) - - # set image name - glance = glance_utils.glance_client(self.snaps_creds) - image = glance_utils.get_image(glance, - "vyos1.1.7") - self.vnf['inputs'].update(dict(target_vnf_image_id=image.id)) - self.vnf['inputs'].update(dict(reference_vnf_image_id=image.id)) - - # set flavor id - self.vnf['inputs'].update(dict(target_vnf_flavor_id=flavor.id)) - self.vnf['inputs'].update(dict(reference_vnf_flavor_id=flavor.id)) - - self.vnf['inputs'].update(dict(keystone_username=self.tenant_name)) - self.vnf['inputs'].update(dict(keystone_password=self.tenant_name)) - self.vnf['inputs'].update(dict(keystone_tenant_name=self.tenant_name)) - self.vnf['inputs'].update( - dict(keystone_url=keystone_utils.get_endpoint( - self.snaps_creds, 'identity'))) + self.util_info["cfy"] = self.cfy_client + self.util_info["cfy_manager_ip"] = self.fip.floating_ip_address + self.util_info["deployment_name"] = descriptor.get('name') + + self.cfy_client.blueprints.upload( + descriptor.get('file_name'), descriptor.get('name')) self.__logger.info("Create VNF Instance") - cfy_client.deployments.create(descriptor.get('name'), - descriptor.get('name'), - self.vnf.get('inputs')) + self.cfy_client.deployments.create( + descriptor.get('name'), descriptor.get('name'), + self.vnf.get('inputs')) - wait_for_execution(cfy_client, - get_execution_id( - cfy_client, descriptor.get('name')), - self.__logger, - timeout=7200) + wait_for_execution( + self.cfy_client, get_execution_id( + self.cfy_client, descriptor.get('name')), + self.__logger, timeout=7200) self.__logger.info("Start the VNF Instance deployment") - execution = cfy_client.executions.start(descriptor.get('name'), - 'install') + execution = self.cfy_client.executions.start( + descriptor.get('name'), 'install') # Show execution log - execution = wait_for_execution(cfy_client, execution, self.__logger) + execution = wait_for_execution( + self.cfy_client, execution, self.__logger) duration = time.time() - start_time @@ -381,68 +205,51 @@ class CloudifyVrouter(vrouter_base.VrouterOnBoardingBase): return result def test_vnf(self): - cfy_client = self.orchestrator['object'] - credentials = {"snaps_creds": self.snaps_creds, - "username": self.snaps_creds.username, - "password": self.snaps_creds.password, - "auth_url": self.snaps_creds.auth_url, - "tenant_name": self.snaps_creds.project_name} - - self.util_info = {"credentials": credentials, - "cfy": cfy_client, - "vnf_data_dir": self.util.vnf_data_dir} - start_time = time.time() - - result, test_result_data = super(CloudifyVrouter, self).test_vnf() - + testing = vrouter_base.VrouterOnBoardingBase( + self.case_name, self.util, self.util_info) + result, test_result_data = testing.test_vnf() duration = time.time() - start_time - if result: - self.details['test_vnf'].update(status='PASS', - result='OK', - full_result=test_result_data, - duration=duration) + self.details['test_vnf'].update( + status='PASS', result='OK', full_result=test_result_data, + duration=duration) else: - self.details['test_vnf'].update(status='FAIL', - result='NG', - full_result=test_result_data, - duration=duration) - + self.details['test_vnf'].update( + status='FAIL', result='NG', full_result=test_result_data, + duration=duration) return True def clean(self): try: - cfy_client = self.orchestrator['object'] dep_name = self.vnf['descriptor'].get('name') # kill existing execution self.__logger.info('Deleting the current deployment') - exec_list = cfy_client.executions.list(dep_name) + exec_list = self.cfy_client.executions.list() for execution in exec_list: if execution['status'] == "started": try: - cfy_client.executions.cancel(execution['id'], - force=True) + self.cfy_client.executions.cancel( + execution['id'], force=True) except Exception: # pylint: disable=broad-except self.__logger.warn("Can't cancel the current exec") - execution = cfy_client.executions.start( - dep_name, - 'uninstall', - parameters=dict(ignore_failure=True)) + execution = self.cfy_client.executions.start( + dep_name, 'uninstall', parameters=dict(ignore_failure=True)) - 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')) + wait_for_execution(self.cfy_client, execution, self.__logger) + self.cfy_client.deployments.delete( + self.vnf['descriptor'].get('name')) + self.cfy_client.blueprints.delete( + self.vnf['descriptor'].get('name')) except Exception: # pylint: disable=broad-except - self.__logger.warn("Some issue during the undeployment ..") - self.__logger.warn("Tenant clean continue ..") + self.__logger.exception("Some issue during the undeployment ..") + if self.image_alt: + self.cloud.delete_image(self.image_alt) + if self.flavor_alt: + self.orig_cloud.delete_flavor(self.flavor_alt.id) super(CloudifyVrouter, self).clean() - def get_vnf_info_list(self, target_vnf_name): - return self.util.get_vnf_info_list( - self.cfy_manager_ip, self.deployment_name, target_vnf_name) - def wait_for_execution(client, execution, logger, timeout=7200, ): """Wait for a workflow execution on Cloudify Manager.""" @@ -461,11 +268,8 @@ def wait_for_execution(client, execution, logger, timeout=7200, ): execution_ended = False while True: event_list = client.events.list( - execution_id=execution.id, - _offset=offset, - _size=batch_size, - include_logs=False, - sort='@timestamp').items + execution_id=execution.id, _offset=offset, _size=batch_size, + include_logs=True, sort='@timestamp').items offset = offset + len(event_list) for event in event_list: @@ -505,10 +309,3 @@ def get_execution_id(client, deployment_id): raise RuntimeError('Failed to get create_deployment_environment ' 'workflow execution.' 'Available executions: {0}'.format(executions)) - - -def run_blocking_ssh_command(ssh, cmd, error_msg="Unable to run this command"): - """Command to run ssh command with the exit status.""" - (_, stdout, _) = ssh.exec_command(cmd) - if stdout.channel.recv_exit_status() != 0: - raise Exception(error_msg)