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 scp
  20 import six
  21
  22 from functest.core import cloudify
  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@orange.com>"
  29
  30
  31 class CloudifyIms(cloudify.Cloudify):
  32     """Clearwater vIMS deployed with Cloudify Orchestrator Case."""
  33
  34     __logger = logging.getLogger(__name__)
  35
  36     filename_alt = ('/home/opnfv/functest/images/'
  37                     'ubuntu-14.04-server-cloudimg-amd64-disk1.img')
  38
  39     flavor_alt_ram = 1024
  40     flavor_alt_vcpus = 1
  41     flavor_alt_disk = 3
  42
  43     quota_security_group = 20
  44     quota_security_group_rule = 100
  45     quota_port = 50
  46
  47     cop_yaml = ("https://github.com/cloudify-cosmo/cloudify-openstack-plugin/"
  48                 "releases/download/2.14.7/plugin.yaml")
  49     cop_wgn = ("https://github.com/cloudify-cosmo/cloudify-openstack-plugin/"
  50                "releases/download/2.14.7/cloudify_openstack_plugin-2.14.7-py27"
  51                "-none-linux_x86_64-centos-Core.wgn")
  52
  53     def __init__(self, **kwargs):
  54         """Initialize CloudifyIms testcase object."""
  55         if "case_name" not in kwargs:
  56             kwargs["case_name"] = "cloudify_ims"
  57         super(CloudifyIms, self).__init__(**kwargs)
  58
  59         # Retrieve the configuration
  60         try:
  61             self.config = getattr(
  62                 config.CONF, 'vnf_{}_config'.format(self.case_name))
  63         except Exception:
  64             raise Exception("VNF config file not found")
  65
  66         self.case_dir = pkg_resources.resource_filename(
  67             'functest', 'opnfv_tests/vnf/ims')
  68         config_file = os.path.join(self.case_dir, self.config)
  69
  70         self.details['orchestrator'] = dict(
  71             name=functest_utils.get_parameter_from_yaml(
  72                 "orchestrator.name", config_file),
  73             version=functest_utils.get_parameter_from_yaml(
  74                 "orchestrator.version", config_file),
  75             status='ERROR',
  76             result=''
  77         )
  78
  79         self.vnf = dict(
  80             descriptor=functest_utils.get_parameter_from_yaml(
  81                 "vnf.descriptor", config_file),
  82             inputs=functest_utils.get_parameter_from_yaml(
  83                 "vnf.inputs", config_file)
  84         )
  85         self.details['vnf'] = dict(
  86             descriptor_version=self.vnf['descriptor']['version'],
  87             name=functest_utils.get_parameter_from_yaml(
  88                 "vnf.name", config_file),
  89             version=functest_utils.get_parameter_from_yaml(
  90                 "vnf.version", config_file),
  91         )
  92         self.__logger.debug("VNF configuration: %s", self.vnf)
  93
  94         self.details['test_vnf'] = dict(
  95             name=functest_utils.get_parameter_from_yaml(
  96                 "vnf_test_suite.name", config_file),
  97             version=functest_utils.get_parameter_from_yaml(
  98                 "vnf_test_suite.version", config_file)
  99         )
 100
 101         self.image_alt = None
 102         self.flavor_alt = None
 103         self.clearwater = None
 104
 105     def check_requirements(self):
 106         if env.get('NEW_USER_ROLE').lower() == "admin":
 107             self.__logger.warn(
 108                 "Defining NEW_USER_ROLE=admin will easily break the testcase "
 109                 "because Cloudify doesn't manage tenancy (e.g. subnet  "
 110                 "overlapping)")
 111
 112     def execute(self):
 113         """
 114         Deploy Cloudify Manager.
 115
 116         network, security group, fip, VM creation
 117         """
 118         assert super(CloudifyIms, self).execute() == 0
 119         start_time = time.time()
 120         self.orig_cloud.set_network_quotas(
 121             self.project.project.name,
 122             security_group=self.quota_security_group,
 123             security_group_rule=self.quota_security_group_rule,
 124             port=self.quota_port)
 125         self.__logger.info("Put OpenStack creds in manager")
 126         cfy_creds = dict(
 127             keystone_username=self.project.user.name,
 128             keystone_password=self.project.password,
 129             keystone_tenant_name=self.project.project.name,
 130             keystone_url=self.get_public_auth_url(self.orig_cloud),
 131             region=os.environ.get('OS_REGION_NAME', 'RegionOne'),
 132             user_domain_name=os.environ.get(
 133                 'OS_USER_DOMAIN_NAME', 'Default'),
 134             project_domain_name=os.environ.get(
 135                 'OS_PROJECT_DOMAIN_NAME', 'Default'))
 136         self.__logger.info("Set creds for cloudify manager %s", cfy_creds)
 137
 138         for loop in range(10):
 139             try:
 140                 secrets_list = self.cfy_client.secrets.list()
 141                 for k, val in six.iteritems(cfy_creds):
 142                     if not any(d.get('key', None) == k for d in secrets_list):
 143                         self.cfy_client.secrets.create(k, val)
 144                     else:
 145                         self.cfy_client.secrets.update(k, val)
 146                 break
 147             except Exception:  # pylint: disable=broad-except
 148                 self.__logger.info(
 149                     "try %s: Cannot create secrets", loop + 1)
 150                 time.sleep(30)
 151         else:
 152             self.__logger.error("Cannot create secrets")
 153             return 1
 154
 155         duration = time.time() - start_time
 156
 157         self.__logger.info("Put private keypair in manager")
 158         scpc = scp.SCPClient(self.ssh.get_transport())
 159         scpc.put(self.key_filename, remote_path='~/cloudify_ims.pem')
 160         (_, stdout, stderr) = self.ssh.exec_command(
 161             "sudo docker exec cfy_manager_local "
 162             "cfy plugins upload -y {} {} && "
 163             "sudo docker cp ~/cloudify_ims.pem "
 164             "cfy_manager_local:/etc/cloudify/ && "
 165             "sudo docker exec cfy_manager_local "
 166             "chmod 444 /etc/cloudify/cloudify_ims.pem && "
 167             "sudo docker exec cfy_manager_local cfy status".format(
 168                 self.cop_yaml, self.cop_wgn))
 169         self.__logger.info("output:\n%s", stdout.read())
 170         self.__logger.info("error:\n%s", stderr.read())
 171
 172         self.details['orchestrator'].update(status='PASS', duration=duration)
 173
 174         self.vnf['inputs'].update(dict(
 175             external_network_name=self.ext_net.name,
 176             network_name=self.network.name,
 177             key_pair_name=self.keypair.name
 178         ))
 179         if self.deploy_vnf() and self.test_vnf():
 180             self.result = 100
 181             return 0
 182         self.result = 1/3 * 100
 183         return 1
 184
 185     def deploy_vnf(self):
 186         """Deploy Clearwater IMS."""
 187         start_time = time.time()
 188
 189         secgroups = self.cloud.list_security_groups(
 190             filters={'name': 'default',
 191                      'project_id': self.project.project.id})
 192         if secgroups:
 193             secgroup = secgroups[0]
 194         else:
 195             self.__logger.error("No 'default' security group in project %s",
 196                                 self.project.project.name)
 197             return False
 198
 199         self.cloud.create_security_group_rule(
 200             secgroup.id, port_range_min=22, port_range_max=22,
 201             protocol='tcp', direction='ingress')
 202
 203         self.__logger.info("Upload VNFD")
 204         descriptor = self.vnf['descriptor']
 205         self.cfy_client.blueprints.upload(
 206             descriptor.get('file_name'), descriptor.get('name'))
 207
 208         self.image_alt = self.publish_image_alt()
 209         self.flavor_alt = self.create_flavor_alt()
 210         self.vnf['inputs'].update(dict(
 211             image_id=self.image_alt.id,
 212             flavor_id=self.flavor_alt.id,
 213         ))
 214
 215         self.__logger.info("Create VNF Instance")
 216         self.cfy_client.deployments.create(
 217             descriptor.get('name'), descriptor.get('name'),
 218             self.vnf.get('inputs'))
 219
 220         cloudify.wait_for_execution(
 221             self.cfy_client,
 222             cloudify.get_execution_id(self.cfy_client, descriptor.get('name')),
 223             self.__logger, timeout=300)
 224
 225         self.__logger.info("Start the VNF Instance deployment")
 226         execution = self.cfy_client.executions.start(
 227             descriptor.get('name'), 'install')
 228         # Show execution log
 229         execution = cloudify.wait_for_execution(
 230             self.cfy_client, execution, self.__logger, timeout=3600)
 231
 232         self.__logger.info(execution)
 233         if execution.status != 'terminated':
 234             self.details['vnf'].update(status='FAIL',
 235                                        duration=time.time() - start_time)
 236             return False
 237
 238         ellis_ip = self.cfy_client.deployments.outputs.get(
 239             self.vnf['descriptor'].get('name'))['outputs']['ellis_ip']
 240         self.clearwater = clearwater.ClearwaterTesting(self.case_name,
 241                                                        ellis_ip)
 242         self.clearwater.availability_check()
 243
 244         self.details['vnf'].update(status='PASS',
 245                                    duration=time.time() - start_time)
 246         self.result += 1/3 * 100
 247         return True
 248
 249     def test_vnf(self):
 250         """Run test on clearwater ims instance."""
 251         start_time = time.time()
 252
 253         dns_ip = self.cfy_client.deployments.outputs.get(
 254             self.vnf['descriptor'].get('name'))['outputs']['dns_ip']
 255
 256         if not dns_ip:
 257             return False
 258
 259         short_result = self.clearwater.run_clearwater_live_test(
 260             dns_ip=dns_ip,
 261             public_domain=self.vnf['inputs']["public_domain"])
 262         duration = time.time() - start_time
 263         self.__logger.info(short_result)
 264         self.details['test_vnf'].update(result=short_result,
 265                                         duration=duration)
 266         try:
 267             vnf_test_rate = short_result['passed'] / (
 268                 short_result['total'] - short_result['skipped'])
 269             # orchestrator + vnf + test_vnf
 270             self.result += vnf_test_rate / 3 * 100
 271         except ZeroDivisionError:
 272             self.__logger.error("No test has been executed")
 273             self.details['test_vnf'].update(status='FAIL')
 274             return False
 275         except Exception:  # pylint: disable=broad-except
 276             self.__logger.exception("Cannot calculate results")
 277             self.details['test_vnf'].update(status='FAIL')
 278             return False
 279         return True if vnf_test_rate > 0 else False
 280
 281     def clean(self):
 282         """Clean created objects/functions."""
 283         try:
 284             dep_name = self.vnf['descriptor'].get('name')
 285             # kill existing execution
 286             self.__logger.info('Deleting the current deployment')
 287             exec_list = self.cfy_client.executions.list()
 288             for execution in exec_list:
 289                 if execution['status'] == "started":
 290                     try:
 291                         self.cfy_client.executions.cancel(
 292                             execution['id'], force=True)
 293                     except Exception:  # pylint: disable=broad-except
 294                         self.__logger.warn("Can't cancel the current exec")
 295
 296             execution = self.cfy_client.executions.start(
 297                 dep_name,
 298                 'uninstall',
 299                 parameters=dict(ignore_failure=True),
 300                 force=True)
 301
 302             cloudify.wait_for_execution(
 303                 self.cfy_client, execution, self.__logger)
 304             self.cfy_client.deployments.delete(
 305                 self.vnf['descriptor'].get('name'))
 306             time.sleep(10)
 307             self.cfy_client.blueprints.delete(
 308                 self.vnf['descriptor'].get('name'))
 309         except Exception:  # pylint: disable=broad-except
 310             self.__logger.exception("Some issue during the undeployment ..")
 311         if self.image_alt:
 312             self.cloud.delete_image(self.image_alt)
 313         if self.flavor_alt:
 314             self.orig_cloud.delete_flavor(self.flavor_alt.id)
 315         super(CloudifyIms, self).clean()