Add a new env var for nameserver

[functest.git] / functest / opnfv_tests / openstack / vping / vping_base.py

diff --git a/functest/opnfv_tests/openstack/vping/vping_base.py b/functest/opnfv_tests/openstack/vping/vping_base.py
index 7146067..edc7848 100644 (file)
--- 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
 #!/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
 
 # 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
 from datetime import datetime
 import logging

-import os
-import pkg_resources

 import time
 import uuid
 
 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 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.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.
     """
 
     """
     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)
 
     def __init__(self, **kwargs):
         super(VPingBase, self).__init__(**kwargs)

-
-        self.logger = logging.getLogger(self.__class__.__name__)
-
-        self.functest_repo = pkg_resources.resource_filename(
-            '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.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.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
 
         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
         # 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
         """
         """
         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('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(
             datetime.fromtimestamp(self.start_time).strftime(

-                '%Y-%m-%d %H:%M:%S')))
+                '%Y-%m-%d %H:%M:%S'))

 
 

-        self.__delete_exist_vms()
-
-        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)
         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)
 
 
         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(
         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,
         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)
 
         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(
         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,
         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)
 
         flavor_creator.create()
         self.creators.append(flavor_creator)
 


@@ -152,10 +173,12 @@ class VPingBase(testcase.OSGCTestCase):
         else:
             raise Exception('VMs never became active')
 
         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
 
             return testcase.TestCase.EX_RUN_ERROR
 

-        self.stop_time = time.time()

         self.result = 100
         return testcase.TestCase.EX_OK
 
         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:
         """
         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()
             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):
         """
 
     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')
         :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