X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=functest%2Fopnfv_tests%2Fopenstack%2Fvping%2Fvping_base.py;h=edc78482b17fe3d3cc8703b4e6f22b0b287c1d62;hb=530c678677cc314c159936fdf5e121e83fc1d0cc;hp=856d5f22093301e9210d14cece89edfde506e4d6;hpb=ec97f28675daea3b3221c196764c58c3c9bd65d4;p=functest.git diff --git a/functest/opnfv_tests/openstack/vping/vping_base.py b/functest/opnfv_tests/openstack/vping/vping_base.py index 856d5f220..edc78482b 100644 --- a/functest/opnfv_tests/openstack/vping/vping_base.py +++ b/functest/opnfv_tests/openstack/vping/vping_base.py @@ -1,138 +1,159 @@ #!/usr/bin/env python + +# Copyright (c) 2017 Cable Television Laboratories, Inc. and others. # -# Copyright (c) 2015 All rights reserved # This program and the accompanying materials # are made available under the terms of the Apache License, Version 2.0 # which accompanies this distribution, and is available at # # http://www.apache.org/licenses/LICENSE-2.0 +"""Define the parent class of vping_ssh and vping_userdata testcases.""" + from datetime import datetime import logging -import os import time import uuid -from functest.core import testcase -from functest.utils import functest_utils -from functest.utils.constants import CONST - +from snaps.config.flavor import FlavorConfig +from snaps.config.network import NetworkConfig, SubnetConfig +from snaps.config.router import RouterConfig from snaps.openstack import create_flavor -from snaps.openstack.create_flavor import FlavorSettings, OpenStackFlavor -from snaps.openstack.create_network import NetworkSettings, SubnetSettings +from snaps.openstack.create_flavor import OpenStackFlavor from snaps.openstack.tests import openstack_tests -from snaps.openstack.utils import deploy_utils, nova_utils +from snaps.openstack.utils import deploy_utils +from xtesting.core import testcase + +from functest.opnfv_tests.openstack.snaps import snaps_utils +from functest.utils import config +from functest.utils import env -class VPingBase(testcase.OSGCTestCase): +class VPingBase(testcase.TestCase): """ Base class for vPing tests that check connectivity between two VMs shared internal network. This class is responsible for creating the image, internal network. """ + # pylint: disable=too-many-instance-attributes def __init__(self, **kwargs): super(VPingBase, self).__init__(**kwargs) - - self.logger = logging.getLogger(self.__class__.__name__) - - self.functest_repo = CONST.__getattribute__('dir_repo_functest') - self.guid = '' - if CONST.__getattribute__('vping_unique_names'): - self.guid = '-' + str(uuid.uuid4()) - - self.os_creds = openstack_tests.get_credentials( - os_env_file=CONST.__getattribute__('openstack_creds')) - - self.repo = CONST.__getattribute__('dir_vping') - + self.logger = logging.getLogger(__name__) + self.os_creds = kwargs.get('os_creds') or snaps_utils.get_credentials() self.creators = list() self.image_creator = None self.network_creator = None self.vm1_creator = None self.vm2_creator = None - - self.self_cleanup = CONST.__getattribute__('vping_cleanup_objects') - - # Image constants - self.image_name =\ - CONST.__getattribute__('vping_image_name') + self.guid - - # VM constants - self.vm1_name = CONST.__getattribute__('vping_vm_name_1') + self.guid - self.vm2_name = CONST.__getattribute__('vping_vm_name_2') + self.guid - self.vm_boot_timeout = CONST.__getattribute__('vping_vm_boot_timeout') - self.vm_delete_timeout =\ - CONST.__getattribute__('vping_vm_delete_timeout') - self.vm_ssh_connect_timeout = CONST.vping_vm_ssh_connect_timeout - self.ping_timeout = CONST.__getattribute__('vping_ping_timeout') + self.router_creator = None + + # Shared metadata + self.guid = '-' + str(uuid.uuid4()) + + self.router_name = getattr( + config.CONF, 'vping_router_name') + self.guid + self.vm1_name = getattr( + config.CONF, 'vping_vm_name_1') + self.guid + self.vm2_name = getattr(config.CONF, 'vping_vm_name_2') + self.guid + + self.vm_boot_timeout = getattr(config.CONF, 'vping_vm_boot_timeout') + self.vm_delete_timeout = getattr( + config.CONF, 'vping_vm_delete_timeout') + self.vm_ssh_connect_timeout = getattr( + config.CONF, 'vping_vm_ssh_connect_timeout') + self.ping_timeout = getattr(config.CONF, 'vping_ping_timeout') self.flavor_name = 'vping-flavor' + self.guid - # NEUTRON Private Network parameters - self.private_net_name =\ - CONST.__getattribute__('vping_private_net_name') + self.guid - self.private_subnet_name =\ - CONST.__getattribute__('vping_private_subnet_name') + self.guid - self.private_subnet_cidr =\ - CONST.__getattribute__('vping_private_subnet_cidr') - - scenario = functest_utils.get_scenario() - - self.flavor_metadata = None - if 'ovs' in scenario or 'fdio' in scenario: - self.flavor_metadata = create_flavor.MEM_PAGE_SIZE_LARGE - - self.cirros_image_config = None - # Move this configuration option up for all tests to leverage - if hasattr(CONST, 'snaps_images_cirros'): - self.cirros_image_config = CONST.__getattribute__( - 'snaps_images_cirros') + if hasattr(config.CONF, 'snaps_images_cirros'): + self.cirros_image_config = getattr( + config.CONF, 'snaps_images_cirros') + else: + self.cirros_image_config = None - def run(self): + def run(self, **kwargs): # pylint: disable=too-many-locals """ Begins the test execution which should originate from the subclass """ - - if not os.path.exists(self.functest_repo): - raise Exception( - "Functest repository not found '%s'" % self.functest_repo) - self.logger.info('Begin virtual environment setup') self.start_time = time.time() - self.logger.info("vPing Start Time:'%s'" % ( + self.logger.info( + "vPing Start Time:'%s'", datetime.fromtimestamp(self.start_time).strftime( - '%Y-%m-%d %H:%M:%S'))) - - self.__delete_exist_vms() + '%Y-%m-%d %H:%M:%S')) - image_base_name = self.image_name + '-' + str(self.guid) + image_base_name = '{}-{}'.format( + getattr(config.CONF, 'vping_image_name'), + str(self.guid)) os_image_settings = openstack_tests.cirros_image_settings( image_base_name, image_metadata=self.cirros_image_config) - self.logger.info("Creating image with name: '%s'" % self.image_name) + self.logger.info("Creating image with name: '%s'", image_base_name) self.image_creator = deploy_utils.create_image( self.os_creds, os_image_settings) self.creators.append(self.image_creator) + private_net_name = getattr( + config.CONF, 'vping_private_net_name') + self.guid + private_subnet_name = getattr( + config.CONF, 'vping_private_subnet_name') + self.guid + private_subnet_cidr = getattr(config.CONF, 'vping_private_subnet_cidr') + + vping_network_type = None + vping_physical_network = None + vping_segmentation_id = None + + if hasattr(config.CONF, 'vping_network_type'): + vping_network_type = getattr(config.CONF, 'vping_network_type') + if hasattr(config.CONF, 'vping_physical_network'): + vping_physical_network = getattr( + config.CONF, 'vping_physical_network') + if hasattr(config.CONF, 'vping_segmentation_id'): + vping_segmentation_id = getattr( + config.CONF, 'vping_segmentation_id') + self.logger.info( - "Creating network with name: '%s'" % self.private_net_name) + "Creating network with name: '%s'", private_net_name) self.network_creator = deploy_utils.create_network( self.os_creds, - NetworkSettings(name=self.private_net_name, - subnet_settings=[SubnetSettings( - name=self.private_subnet_name, - cidr=self.private_subnet_cidr)])) + NetworkConfig( + name=private_net_name, + network_type=vping_network_type, + physical_network=vping_physical_network, + segmentation_id=vping_segmentation_id, + subnet_settings=[SubnetConfig( + name=private_subnet_name, + cidr=private_subnet_cidr, + dns_nameservers=[env.get('NAMESERVER')])])) self.creators.append(self.network_creator) + # Creating router to external network + log = "Creating router with name: '%s'" % self.router_name + self.logger.info(log) + ext_net_name = snaps_utils.get_ext_net_name(self.os_creds) + self.router_creator = deploy_utils.create_router( + self.os_creds, + RouterConfig( + name=self.router_name, + external_gateway=ext_net_name, + internal_subnets=[private_subnet_name])) + self.creators.append(self.router_creator) + self.logger.info( - "Creating flavor with name: '%s'" % self.flavor_name) + "Creating flavor with name: '%s'", self.flavor_name) + scenario = env.get('DEPLOY_SCENARIO') + flavor_metadata = None + flavor_ram = 512 + if 'ovs' in scenario or 'fdio' in scenario: + flavor_metadata = create_flavor.MEM_PAGE_SIZE_LARGE + flavor_ram = 1024 flavor_creator = OpenStackFlavor( self.os_creds, - FlavorSettings(name=self.flavor_name, ram=512, disk=1, vcpus=1, - metadata=self.flavor_metadata)) + FlavorConfig(name=self.flavor_name, ram=flavor_ram, disk=1, + vcpus=1, metadata=flavor_metadata)) flavor_creator.create() self.creators.append(flavor_creator) @@ -152,10 +173,12 @@ class VPingBase(testcase.OSGCTestCase): else: raise Exception('VMs never became active') - if result == testcase.TestCase.EX_RUN_ERROR: + self.stop_time = time.time() + + if result != testcase.TestCase.EX_OK: + self.result = 0 return testcase.TestCase.EX_RUN_ERROR - self.stop_time = time.time() self.result = 100 return testcase.TestCase.EX_OK @@ -164,12 +187,12 @@ class VPingBase(testcase.OSGCTestCase): Cleanup all OpenStack objects. Should be called on completion :return: """ - if self.self_cleanup: + if getattr(config.CONF, 'vping_cleanup_objects') == 'True': for creator in reversed(self.creators): try: creator.clean() - except Exception as e: - self.logger.error('Unexpected error cleaning - %s', e) + except Exception as error: # pylint: disable=broad-except + self.logger.error('Unexpected error cleaning - %s', error) def _do_vping(self, vm_creator, test_ip): """ @@ -180,30 +203,3 @@ class VPingBase(testcase.OSGCTestCase): :return: T/F """ raise NotImplementedError('vping execution is not implemented') - - def __delete_exist_vms(self): - """ - Cleans any existing VMs using the same name. - """ - nova_client = nova_utils.nova_client(self.os_creds) - servers = nova_client.servers.list() - for server in servers: - if server.name == self.vm1_name or server.name == self.vm2_name: - self.logger.info("Deleting instance %s..." % server.name) - server.delete() - - -class VPingMain(object): - - def __init__(self, vping_cls): - self.vping = vping_cls() - - def main(self, **kwargs): - try: - result = self.vping.run(**kwargs) - if result != VPingBase.EX_OK: - return result - if kwargs['report']: - return self.vping.publish_report() - except: - return VPingBase.EX_RUN_ERROR