functest/opnfv_tests/openstack/vping/vping_base.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2017 Cable Television Laboratories, Inc. and others.
   4 #
   5 # This program and the accompanying materials
   6 # are made available under the terms of the Apache License, Version 2.0
   7 # which accompanies this distribution, and is available at
   8 #
   9 # http://www.apache.org/licenses/LICENSE-2.0
  10
  11 """Define the parent class of vping_ssh and vping_userdata testcases."""
  12
  13 from datetime import datetime
  14 import logging
  15 import time
  16 import uuid
  17
  18 from functest.core import testcase
  19 from functest.opnfv_tests.openstack.snaps import snaps_utils
  20 from functest.utils.constants import CONST
  21 from functest.utils import env
  22
  23 from snaps.config.flavor import FlavorConfig
  24 from snaps.config.network import NetworkConfig, SubnetConfig
  25 from snaps.config.router import RouterConfig
  26 from snaps.openstack import create_flavor
  27 from snaps.openstack.create_flavor import OpenStackFlavor
  28 from snaps.openstack.tests import openstack_tests
  29 from snaps.openstack.utils import deploy_utils
  30
  31
  32 class VPingBase(testcase.TestCase):
  33
  34     """
  35     Base class for vPing tests that check connectivity between two VMs shared
  36     internal network.
  37     This class is responsible for creating the image, internal network.
  38     """
  39     # pylint: disable=too-many-instance-attributes
  40
  41     def __init__(self, **kwargs):
  42         super(VPingBase, self).__init__(**kwargs)
  43         self.logger = logging.getLogger(__name__)
  44         self.os_creds = kwargs.get('os_creds') or snaps_utils.get_credentials()
  45         self.creators = list()
  46         self.image_creator = None
  47         self.network_creator = None
  48         self.vm1_creator = None
  49         self.vm2_creator = None
  50         self.router_creator = None
  51
  52         # Shared metadata
  53         self.guid = '-' + str(uuid.uuid4())
  54
  55         self.router_name = getattr(CONST, 'vping_router_name') + self.guid
  56         self.vm1_name = getattr(CONST, 'vping_vm_name_1') + self.guid
  57         self.vm2_name = getattr(CONST, 'vping_vm_name_2') + self.guid
  58
  59         self.vm_boot_timeout = getattr(CONST, 'vping_vm_boot_timeout')
  60         self.vm_delete_timeout = getattr(CONST, 'vping_vm_delete_timeout')
  61         self.vm_ssh_connect_timeout = getattr(
  62             CONST, 'vping_vm_ssh_connect_timeout')
  63         self.ping_timeout = getattr(CONST, 'vping_ping_timeout')
  64         self.flavor_name = 'vping-flavor' + self.guid
  65
  66         # Move this configuration option up for all tests to leverage
  67         if hasattr(CONST, 'snaps_images_cirros'):
  68             self.cirros_image_config = getattr(CONST, 'snaps_images_cirros')
  69         else:
  70             self.cirros_image_config = None
  71
  72     def run(self, **kwargs):  # pylint: disable=too-many-locals
  73         """
  74         Begins the test execution which should originate from the subclass
  75         """
  76         self.logger.info('Begin virtual environment setup')
  77
  78         self.start_time = time.time()
  79         self.logger.info(
  80             "vPing Start Time:'%s'",
  81             datetime.fromtimestamp(self.start_time).strftime(
  82                 '%Y-%m-%d %H:%M:%S'))
  83
  84         image_base_name = '{}-{}'.format(
  85             getattr(CONST, 'vping_image_name'),
  86             str(self.guid))
  87         os_image_settings = openstack_tests.cirros_image_settings(
  88             image_base_name, image_metadata=self.cirros_image_config)
  89         self.logger.info("Creating image with name: '%s'", image_base_name)
  90
  91         self.image_creator = deploy_utils.create_image(
  92             self.os_creds, os_image_settings)
  93         self.creators.append(self.image_creator)
  94
  95         private_net_name = getattr(CONST, 'vping_private_net_name') + self.guid
  96         private_subnet_name = getattr(
  97             CONST, 'vping_private_subnet_name') + self.guid
  98         private_subnet_cidr = getattr(CONST, 'vping_private_subnet_cidr')
  99
 100         vping_network_type = None
 101         vping_physical_network = None
 102         vping_segmentation_id = None
 103
 104         if hasattr(CONST, 'vping_network_type'):
 105             vping_network_type = getattr(CONST, 'vping_network_type')
 106         if hasattr(CONST, 'vping_physical_network'):
 107             vping_physical_network = getattr(CONST, 'vping_physical_network')
 108         if hasattr(CONST, 'vping_segmentation_id'):
 109             vping_segmentation_id = getattr(CONST, 'vping_segmentation_id')
 110
 111         self.logger.info(
 112             "Creating network with name: '%s'", private_net_name)
 113         self.network_creator = deploy_utils.create_network(
 114             self.os_creds,
 115             NetworkConfig(
 116                 name=private_net_name,
 117                 network_type=vping_network_type,
 118                 physical_network=vping_physical_network,
 119                 segmentation_id=vping_segmentation_id,
 120                 subnet_settings=[SubnetConfig(
 121                     name=private_subnet_name,
 122                     cidr=private_subnet_cidr)]))
 123         self.creators.append(self.network_creator)
 124
 125         # Creating router to external network
 126         log = "Creating router with name: '%s'" % self.router_name
 127         self.logger.info(log)
 128         ext_net_name = snaps_utils.get_ext_net_name(self.os_creds)
 129         self.router_creator = deploy_utils.create_router(
 130             self.os_creds,
 131             RouterConfig(
 132                 name=self.router_name,
 133                 external_gateway=ext_net_name,
 134                 internal_subnets=[private_subnet_name]))
 135         self.creators.append(self.router_creator)
 136
 137         self.logger.info(
 138             "Creating flavor with name: '%s'", self.flavor_name)
 139         scenario = env.get('DEPLOY_SCENARIO')
 140         flavor_metadata = None
 141         flavor_ram = 512
 142         if 'ovs' in scenario or 'fdio' in scenario:
 143             flavor_metadata = create_flavor.MEM_PAGE_SIZE_LARGE
 144             flavor_ram = 1024
 145         flavor_creator = OpenStackFlavor(
 146             self.os_creds,
 147             FlavorConfig(name=self.flavor_name, ram=flavor_ram, disk=1,
 148                          vcpus=1, metadata=flavor_metadata))
 149         flavor_creator.create()
 150         self.creators.append(flavor_creator)
 151
 152     def _execute(self):
 153         """
 154         Method called by subclasses after environment has been setup
 155         :return: the exit code
 156         """
 157         self.logger.info('Begin test execution')
 158
 159         test_ip = self.vm1_creator.get_port_ip(
 160             self.vm1_creator.instance_settings.port_settings[0].name)
 161
 162         if self.vm1_creator.vm_active(
 163                 block=True) and self.vm2_creator.vm_active(block=True):
 164             result = self._do_vping(self.vm2_creator, test_ip)
 165         else:
 166             raise Exception('VMs never became active')
 167
 168         self.stop_time = time.time()
 169
 170         if result != testcase.TestCase.EX_OK:
 171             self.result = 0
 172             return testcase.TestCase.EX_RUN_ERROR
 173
 174         self.result = 100
 175         return testcase.TestCase.EX_OK
 176
 177     def _cleanup(self):
 178         """
 179         Cleanup all OpenStack objects. Should be called on completion
 180         :return:
 181         """
 182         if getattr(CONST, 'vping_cleanup_objects') == 'True':
 183             for creator in reversed(self.creators):
 184                 try:
 185                     creator.clean()
 186                 except Exception as error:  # pylint: disable=broad-except
 187                     self.logger.error('Unexpected error cleaning - %s', error)
 188
 189     def _do_vping(self, vm_creator, test_ip):
 190         """
 191         Method to be implemented by subclasses
 192         Begins the real test after the OpenStack environment has been setup
 193         :param vm_creator: the SNAPS VM instance creator object
 194         :param test_ip: the IP to which the VM needs to issue the ping
 195         :return: T/F
 196         """
 197         raise NotImplementedError('vping execution is not implemented')