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