functest/opnfv_tests/vnf/ims/cloudify_ims.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2017 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 """CloudifyIms testcase implementation."""
  11
  12 from __future__ import division
  13
  14 import logging
  15 import os
  16 import time
  17
  18 import pkg_resources
  19 import six
  20
  21 from functest.core import cloudify
  22 from functest.opnfv_tests.vnf.ims import clearwater
  23 from functest.utils import config
  24 from functest.utils import env
  25 from functest.utils import functest_utils
  26
  27 __author__ = "Valentin Boucher <valentin.boucher@orange.com>"
  28
  29
  30 class CloudifyIms(cloudify.Cloudify):
  31     """Clearwater vIMS deployed with Cloudify Orchestrator Case."""
  32
  33     __logger = logging.getLogger(__name__)
  34
  35     filename_alt = ('/home/opnfv/functest/images/'
  36                     'ubuntu-14.04-server-cloudimg-amd64-disk1.img')
  37
  38     flavor_alt_ram = 1024
  39     flavor_alt_vcpus = 1
  40     flavor_alt_disk = 3
  41
  42     quota_security_group = 20
  43     quota_security_group_rule = 100
  44     quota_port = 50
  45
  46     cop_yaml = ("https://github.com/cloudify-cosmo/cloudify-openstack-plugin/"
  47                 "releases/download/2.14.7/plugin.yaml")
  48     cop_wgn = ("https://github.com/cloudify-cosmo/cloudify-openstack-plugin/"
  49                "releases/download/2.14.7/cloudify_openstack_plugin-2.14.7-py27"
  50                "-none-linux_x86_64-centos-Core.wgn")
  51
  52     def __init__(self, **kwargs):
  53         """Initialize CloudifyIms testcase object."""
  54         if "case_name" not in kwargs:
  55             kwargs["case_name"] = "cloudify_ims"
  56         super().__init__(**kwargs)
  57
  58         # Retrieve the configuration
  59         try:
  60             self.config = getattr(
  61                 config.CONF, 'vnf_{}_config'.format(self.case_name))
  62         except Exception as exc:
  63             raise Exception("VNF config file not found") from exc
  64
  65         self.case_dir = pkg_resources.resource_filename(
  66             'functest', 'opnfv_tests/vnf/ims')
  67         config_file = os.path.join(self.case_dir, self.config)
  68
  69         self.details['orchestrator'] = dict(
  70             name=functest_utils.get_parameter_from_yaml(
  71                 "orchestrator.name", config_file),
  72             version=functest_utils.get_parameter_from_yaml(
  73                 "orchestrator.version", config_file),
  74             status='ERROR',
  75             result=''
  76         )
  77
  78         self.vnf = dict(
  79             descriptor=functest_utils.get_parameter_from_yaml(
  80                 "vnf.descriptor", config_file),
  81             inputs=functest_utils.get_parameter_from_yaml(
  82                 "vnf.inputs", config_file)
  83         )
  84         self.details['vnf'] = dict(
  85             descriptor_version=self.vnf['descriptor']['version'],
  86             name=functest_utils.get_parameter_from_yaml(
  87                 "vnf.name", config_file),
  88             version=functest_utils.get_parameter_from_yaml(
  89                 "vnf.version", config_file),
  90         )
  91         self.__logger.debug("VNF configuration: %s", self.vnf)
  92
  93         self.details['test_vnf'] = dict(
  94             name=functest_utils.get_parameter_from_yaml(
  95                 "vnf_test_suite.name", config_file),
  96             version=functest_utils.get_parameter_from_yaml(
  97                 "vnf_test_suite.version", config_file)
  98         )
  99
 100         self.image_alt = None
 101         self.flavor_alt = None
 102         self.clearwater = None
 103
 104     def check_requirements(self):
 105         if env.get('NEW_USER_ROLE').lower() == "admin":
 106             self.__logger.warning(
 107                 "Defining NEW_USER_ROLE=admin will easily break the testcase "
 108                 "because Cloudify doesn't manage tenancy (e.g. subnet "
 109                 "overlapping)")
 110
 111     def execute(self):
 112         """
 113         Deploy Cloudify Manager.
 114
 115         network, security group, fip, VM creation
 116         """
 117         assert super().execute() == 0
 118         start_time = time.time()
 119         self.orig_cloud.set_network_quotas(
 120             self.project.project.name,
 121             security_group=self.quota_security_group,
 122             security_group_rule=self.quota_security_group_rule,
 123             port=self.quota_port)
 124         self.__logger.info("Put OpenStack creds in manager")
 125         cfy_creds = dict(
 126             keystone_username=self.project.user.name,
 127             keystone_password=self.project.password,
 128             keystone_tenant_name=self.project.project.name,
 129             keystone_url=self.get_public_auth_url(self.orig_cloud),
 130             region=os.environ.get('OS_REGION_NAME', 'RegionOne'),
 131             user_domain_name=os.environ.get(
 132                 'OS_USER_DOMAIN_NAME', 'Default'),
 133             project_domain_name=os.environ.get(
 134                 'OS_PROJECT_DOMAIN_NAME', 'Default'))
 135         self.__logger.info("Set creds for cloudify manager %s", cfy_creds)
 136
 137         for loop in range(10):
 138             try:
 139                 secrets_list = self.cfy_client.secrets.list()
 140                 for k, val in six.iteritems(cfy_creds):
 141                     if not any(d.get('key', None) == k for d in secrets_list):
 142                         self.cfy_client.secrets.create(k, val)
 143                     else:
 144                         self.cfy_client.secrets.update(k, val)
 145                 break
 146             except Exception:  # pylint: disable=broad-except
 147                 self.__logger.info(
 148                     "try %s: Cannot create secrets", loop + 1)
 149                 time.sleep(30)
 150         else:
 151             self.__logger.error("Cannot create secrets")
 152             return 1
 153
 154         duration = time.time() - start_time
 155
 156         self.put_private_key()
 157         self.upload_cfy_plugins(self.cop_yaml, self.cop_wgn)
 158
 159         self.details['orchestrator'].update(status='PASS', duration=duration)
 160
 161         self.vnf['inputs'].update(dict(
 162             external_network_name=self.ext_net.name,
 163             network_name=self.network.name,
 164             key_pair_name=self.keypair.name
 165         ))
 166         if self.deploy_vnf() and self.test_vnf():
 167             self.result = 100
 168             return 0
 169         self.result = 1/3 * 100
 170         return 1
 171
 172     def deploy_vnf(self):
 173         """Deploy Clearwater IMS."""
 174         start_time = time.time()
 175
 176         secgroups = self.cloud.list_security_groups(
 177             filters={'name': 'default',
 178                      'project_id': self.project.project.id})
 179         if secgroups:
 180             secgroup = secgroups[0]
 181         else:
 182             self.__logger.error("No 'default' security group in project %s",
 183                                 self.project.project.name)
 184             return False
 185
 186         self.cloud.create_security_group_rule(
 187             secgroup.id, port_range_min=22, port_range_max=22,
 188             protocol='tcp', direction='ingress')
 189
 190         self.__logger.info("Upload VNFD")
 191         descriptor = self.vnf['descriptor']
 192         self.cfy_client.blueprints.upload(
 193             descriptor.get('file_name'), descriptor.get('name'))
 194
 195         self.image_alt = self.publish_image_alt()
 196         self.flavor_alt = self.create_flavor_alt()
 197         self.vnf['inputs'].update(dict(
 198             image_id=self.image_alt.id,
 199             flavor_id=self.flavor_alt.id,
 200         ))
 201
 202         self.__logger.info("Create VNF Instance")
 203         self.cfy_client.deployments.create(
 204             descriptor.get('name'), descriptor.get('name'),
 205             self.vnf.get('inputs'))
 206
 207         cloudify.wait_for_execution(
 208             self.cfy_client,
 209             cloudify.get_execution_id(self.cfy_client, descriptor.get('name')),
 210             self.__logger, timeout=300)
 211
 212         self.__logger.info("Start the VNF Instance deployment")
 213         execution = self.cfy_client.executions.start(
 214             descriptor.get('name'), 'install')
 215         # Show execution log
 216         execution = cloudify.wait_for_execution(
 217             self.cfy_client, execution, self.__logger, timeout=3600)
 218
 219         self.__logger.info(execution)
 220         if execution.status != 'terminated':
 221             self.details['vnf'].update(status='FAIL',
 222                                        duration=time.time() - start_time)
 223             return False
 224
 225         ellis_ip = self.cfy_client.deployments.outputs.get(
 226             self.vnf['descriptor'].get('name'))['outputs']['ellis_ip']
 227         bono_ip = self.cfy_client.deployments.outputs.get(
 228             self.vnf['descriptor'].get('name'))['outputs']['bono_ip']
 229         self.clearwater = clearwater.ClearwaterTesting(
 230             self.case_name, bono_ip, ellis_ip)
 231         self.clearwater.availability_check()
 232
 233         self.details['vnf'].update(status='PASS',
 234                                    duration=time.time() - start_time)
 235         self.result += 1/3 * 100
 236         return True
 237
 238     def test_vnf(self):
 239         """Run test on clearwater ims instance."""
 240         start_time = time.time()
 241         dns_ip = self.cfy_client.deployments.outputs.get(
 242             self.vnf['descriptor'].get('name'))['outputs']['dns_ip']
 243         if not dns_ip:
 244             return False
 245         short_result, vnf_test_rate = self.clearwater.run_clearwater_live_test(
 246             public_domain=self.vnf['inputs']["public_domain"])
 247         duration = time.time() - start_time
 248         self.__logger.info(short_result)
 249         self.details['test_vnf'].update(result=short_result, duration=duration)
 250         self.result += vnf_test_rate / 3 * 100
 251         if vnf_test_rate == 0:
 252             self.details['test_vnf'].update(status='FAIL')
 253         return bool(vnf_test_rate > 0)
 254
 255     def clean(self):
 256         """Clean created objects/functions."""
 257         self.kill_existing_execution(self.vnf['descriptor'].get('name'))
 258         if self.image_alt:
 259             self.cloud.delete_image(self.image_alt)
 260         if self.flavor_alt:
 261             self.orig_cloud.delete_flavor(self.flavor_alt.id)
 262         super().clean()