functest/opnfv_tests/vnf/ims/heat_ims.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2018 Kontron, Orange and others.
   4 #
   5 # All rights reserved. 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 # http://www.apache.org/licenses/LICENSE-2.0
   9
  10 """HeatIms testcase implementation."""
  11
  12 from __future__ import division
  13
  14 import logging
  15 import os
  16 import re
  17 import time
  18
  19 import pkg_resources
  20 from xtesting.core import testcase
  21
  22 from functest.core import singlevm
  23 from functest.opnfv_tests.vnf.ims import clearwater
  24 from functest.utils import config
  25 from functest.utils import env
  26 from functest.utils import functest_utils
  27
  28 __author__ = "Valentin Boucher <valentin.boucher@kontron.com>"
  29
  30
  31 class HeatIms(singlevm.VmReady2):
  32     # pylint: disable=too-many-instance-attributes
  33     """Clearwater vIMS deployed with Heat Orchestrator Case."""
  34
  35     __logger = logging.getLogger(__name__)
  36
  37     filename = ('/home/opnfv/functest/images/'
  38                 'ubuntu-14.04-server-cloudimg-amd64-disk1.img')
  39
  40     flavor_ram = 1024
  41     flavor_vcpus = 1
  42     flavor_disk = 3
  43
  44     quota_security_group = 20
  45     quota_security_group_rule = 100
  46     quota_port = 50
  47
  48     parameters = {
  49         'private_mgmt_net_cidr': '192.168.100.0/24',
  50         'private_mgmt_net_gateway': '192.168.100.254',
  51         'private_mgmt_net_pool_start': '192.168.100.1',
  52         'private_mgmt_net_pool_end': '192.168.100.253'}
  53
  54     def __init__(self, **kwargs):
  55         """Initialize HeatIms testcase object."""
  56         if "case_name" not in kwargs:
  57             kwargs["case_name"] = "heat_ims"
  58         super(HeatIms, self).__init__(**kwargs)
  59
  60         # Retrieve the configuration
  61         try:
  62             self.config = getattr(
  63                 config.CONF, 'vnf_{}_config'.format(self.case_name))
  64         except Exception:
  65             raise Exception("VNF config file not found")
  66
  67         self.case_dir = pkg_resources.resource_filename(
  68             'functest', 'opnfv_tests/vnf/ims')
  69         config_file = os.path.join(self.case_dir, self.config)
  70
  71         self.vnf = dict(
  72             descriptor=functest_utils.get_parameter_from_yaml(
  73                 "vnf.descriptor", config_file),
  74             parameters=functest_utils.get_parameter_from_yaml(
  75                 "vnf.inputs", config_file)
  76         )
  77         self.details['vnf'] = dict(
  78             descriptor_version=self.vnf['descriptor']['version'],
  79             name=functest_utils.get_parameter_from_yaml(
  80                 "vnf.name", config_file),
  81             version=functest_utils.get_parameter_from_yaml(
  82                 "vnf.version", config_file),
  83         )
  84         self.__logger.debug("VNF configuration: %s", self.vnf)
  85         self.keypair = None
  86         self.stack = None
  87         self.clearwater = None
  88         self.role = None
  89
  90     def create_network_resources(self):
  91         pass
  92
  93     def execute(self):
  94         # pylint: disable=too-many-locals,too-many-statements
  95         """
  96         Prepare Tenant/User
  97
  98         network, security group, fip, VM creation
  99         """
 100         self.orig_cloud.set_network_quotas(
 101             self.project.project.name,
 102             security_group=self.quota_security_group,
 103             security_group_rule=self.quota_security_group_rule,
 104             port=self.quota_port)
 105         if not self.orig_cloud.get_role("heat_stack_owner"):
 106             self.role = self.orig_cloud.create_role("heat_stack_owner")
 107         self.orig_cloud.grant_role(
 108             "heat_stack_owner", user=self.project.user.id,
 109             project=self.project.project.id,
 110             domain=self.project.domain.id)
 111         self.keypair = self.cloud.create_keypair(
 112             '{}-kp_{}'.format(self.case_name, self.guid))
 113         self.__logger.info("keypair:\n%s", self.keypair.private_key)
 114
 115         if self.deploy_vnf() and self.test_vnf():
 116             self.result = 100
 117             return 0
 118         self.result = 1/3 * 100
 119         return 1
 120
 121     def run(self, **kwargs):
 122         """Deploy and test clearwater
 123
 124         Here are the main actions:
 125         - deploy clearwater stack via heat
 126         - test the vnf instance
 127
 128         Returns:
 129         - TestCase.EX_OK
 130         - TestCase.EX_RUN_ERROR on error
 131         """
 132         status = testcase.TestCase.EX_RUN_ERROR
 133         try:
 134             assert self.cloud
 135             assert super(HeatIms, self).run(
 136                 **kwargs) == testcase.TestCase.EX_OK
 137             self.result = 0
 138             if not self.execute():
 139                 self.result = 100
 140                 status = testcase.TestCase.EX_OK
 141         except Exception:  # pylint: disable=broad-except
 142             self.__logger.exception('Cannot run %s', self.case_name)
 143         finally:
 144             self.stop_time = time.time()
 145         return status
 146
 147     def deploy_vnf(self):
 148         """Deploy Clearwater IMS."""
 149         start_time = time.time()
 150         descriptor = self.vnf['descriptor']
 151         parameters = self.vnf['parameters']
 152
 153         parameters['public_mgmt_net_id'] = self.ext_net.id
 154         parameters['flavor'] = self.flavor.name
 155         parameters['image'] = self.image.name
 156         parameters['key_name'] = self.keypair.name
 157         parameters['external_mgmt_dns_ip'] = env.get('NAMESERVER')
 158         parameters.update(self.parameters)
 159
 160         self.__logger.info("Create Heat Stack")
 161         self.stack = self.cloud.create_stack(
 162             name=descriptor.get('name'),
 163             template_file=descriptor.get('file_name'),
 164             wait=True, **parameters)
 165         self.__logger.debug("stack: %s", self.stack)
 166
 167         servers = self.cloud.list_servers(detailed=True)
 168         self.__logger.debug("servers: %s", servers)
 169         for server in servers:
 170             if not self.check_regex_in_console(
 171                     server.name, regex='Cloud-init .* finished at ', loop=1):
 172                 return False
 173             if 'ellis' in server.name:
 174                 self.__logger.debug("server: %s", server)
 175                 ellis_ip = server.public_v4
 176
 177         assert ellis_ip
 178         self.clearwater = clearwater.ClearwaterTesting(self.case_name,
 179                                                        ellis_ip)
 180         # This call can take time and many retry because Heat is
 181         # an infrastructure orchestrator so when Heat say "stack created"
 182         # it means that all OpenStack ressources are created but not that
 183         # Clearwater are up and ready (Cloud-Init script still running)
 184         self.clearwater.availability_check()
 185
 186         duration = time.time() - start_time
 187
 188         self.details['vnf'].update(status='PASS', duration=duration)
 189         self.result += 1/3 * 100
 190
 191         return True
 192
 193     def test_vnf(self):
 194         """Run test on clearwater ims instance."""
 195         start_time = time.time()
 196
 197         outputs = self.cloud.get_stack(self.stack.id).outputs
 198         self.__logger.debug("stack outputs: %s", outputs)
 199         dns_ip = re.findall(r'[0-9]+(?:\.[0-9]+){3}', str(outputs))[0]
 200
 201         if not dns_ip:
 202             return False
 203
 204         short_result = self.clearwater.run_clearwater_live_test(
 205             dns_ip=dns_ip,
 206             public_domain=self.vnf['parameters']["zone"])
 207         duration = time.time() - start_time
 208         self.__logger.info(short_result)
 209         self.details['test_vnf'] = dict(result=short_result,
 210                                         duration=duration)
 211         try:
 212             vnf_test_rate = short_result['passed'] / (
 213                 short_result['total'] - short_result['skipped'])
 214             # orchestrator + vnf + test_vnf
 215             self.result += vnf_test_rate / 3 * 100
 216         except ZeroDivisionError:
 217             self.__logger.error("No test has been executed")
 218             self.details['test_vnf'].update(status='FAIL')
 219             return False
 220         except Exception:  # pylint: disable=broad-except
 221             self.__logger.exception("Cannot calculate results")
 222             self.details['test_vnf'].update(status='FAIL')
 223             return False
 224         return True if vnf_test_rate > 0 else False
 225
 226     def clean(self):
 227         """Clean created objects/functions."""
 228         assert self.cloud
 229         try:
 230             if self.stack:
 231                 self.cloud.delete_stack(self.stack.id, wait=True)
 232         except TypeError:
 233             # shade raises TypeError exceptions when checking stack status
 234             pass
 235         except Exception:  # pylint: disable=broad-except
 236             self.__logger.exception("Cannot clean stack ressources")
 237         super(HeatIms, self).clean()
 238         if self.role:
 239             self.orig_cloud.delete_role(self.role.id)