functest/opnfv_tests/vnf/router/cloudify_vrouter.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2017 Okinawa Open Laboratory 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 """vrouter testcase implementation."""
  11
  12 import logging
  13 import os
  14 import time
  15
  16 from cloudify_rest_client import CloudifyClient
  17 from cloudify_rest_client.executions import Execution
  18 from scp import SCPClient
  19 import yaml
  20
  21 from functest.opnfv_tests.openstack.snaps import snaps_utils
  22 import functest.opnfv_tests.vnf.router.vrouter_base as vrouter_base
  23 from functest.utils.constants import CONST
  24 import functest.utils.openstack_utils as os_utils
  25
  26 from git import Repo
  27
  28 from snaps.openstack.create_network import (NetworkSettings, SubnetSettings,
  29                                             OpenStackNetwork)
  30 from snaps.openstack.create_security_group import (SecurityGroupSettings,
  31                                                    SecurityGroupRuleSettings,
  32                                                    Direction, Protocol,
  33                                                    OpenStackSecurityGroup)
  34 from snaps.openstack.create_router import RouterSettings, OpenStackRouter
  35 from snaps.openstack.create_instance import (VmInstanceSettings,
  36                                              FloatingIpSettings,
  37                                              OpenStackVmInstance)
  38 from snaps.openstack.create_flavor import FlavorSettings, OpenStackFlavor
  39 from snaps.openstack.create_image import ImageSettings, OpenStackImage
  40 from snaps.openstack.create_keypairs import KeypairSettings, OpenStackKeypair
  41 from snaps.openstack.create_network import PortSettings
  42 import snaps.openstack.utils.glance_utils as glance_utils
  43
  44 from functest.opnfv_tests.vnf.router.utilvnf import Utilvnf
  45
  46 __author__ = "Shuya Nakama <shuya.nakama@okinawaopenlabs.org>"
  47
  48
  49 class CloudifyVrouter(vrouter_base.VrouterOnBoardingBase):
  50     """vrouter testcase deployed with Cloudify Orchestrator."""
  51
  52     __logger = logging.getLogger(__name__)
  53     name = __name__
  54
  55     def __init__(self, **kwargs):
  56         if "case_name" not in kwargs:
  57             kwargs["case_name"] = "vyos_vrouter"
  58         super(CloudifyVrouter, self).__init__(**kwargs)
  59
  60         # Retrieve the configuration
  61         try:
  62             self.config = CONST.__getattribute__(
  63                 'vnf_{}_config'.format(self.case_name))
  64         except Exception:
  65             raise Exception("VNF config file not found")
  66
  67         self.snaps_creds = ''
  68         self.created_object = []
  69
  70         self.cfy_manager_ip = ''
  71         self.util_info = {}
  72         self.deployment_name = ''
  73
  74         config_file = os.path.join(self.case_dir, self.config)
  75         self.orchestrator = dict(
  76             requirements=get_config("orchestrator.requirements", config_file),
  77         )
  78         self.details['orchestrator'] = dict(
  79             name=get_config("orchestrator.name", config_file),
  80             version=get_config("orchestrator.version", config_file),
  81             status='ERROR',
  82             result=''
  83         )
  84         self.__logger.debug("Orchestrator configuration %s", self.orchestrator)
  85         self.__logger.debug("name = %s", self.name)
  86         self.vnf = dict(
  87             descriptor=get_config("vnf.descriptor", config_file),
  88             inputs=get_config("vnf.inputs", config_file),
  89             requirements=get_config("vnf.requirements", config_file)
  90         )
  91         self.details['vnf'] = dict(
  92             descriptor_version=self.vnf['descriptor']['version'],
  93             name=get_config("vnf.name", config_file),
  94             version=get_config("vnf.version", config_file),
  95         )
  96         self.__logger.debug("VNF configuration: %s", self.vnf)
  97
  98         self.util = Utilvnf()
  99
 100         self.details['test_vnf'] = dict(
 101             name=get_config("vnf_test_suite.name", config_file),
 102             version=get_config("vnf_test_suite.version", config_file)
 103         )
 104         self.images = get_config("tenant_images", config_file)
 105         self.__logger.info("Images needed for vrouter: %s", self.images)
 106
 107     def prepare(self):
 108         super(CloudifyVrouter, self).prepare()
 109
 110         self.__logger.info("Additional pre-configuration steps")
 111
 112         self.util.set_credentials(self.snaps_creds.username,
 113                                   self.snaps_creds.password,
 114                                   self.snaps_creds.auth_url,
 115                                   self.snaps_creds.project_name)
 116
 117         # needs some images
 118         self.__logger.info("Upload some OS images if it doesn't exist")
 119         for image_name, image_file in self.images.iteritems():
 120             self.__logger.info("image: %s, file: %s", image_name, image_file)
 121             if image_file and image_name:
 122                 image_creator = OpenStackImage(
 123                     self.snaps_creds,
 124                     ImageSettings(name=image_name,
 125                                   image_user='cloud',
 126                                   img_format='qcow2',
 127                                   image_file=image_file))
 128                 image_creator.create()
 129                 self.created_object.append(image_creator)
 130
 131     def deploy_orchestrator(self):
 132         """
 133         Deploy Cloudify Manager.
 134         network, security group, fip, VM creation
 135         """
 136         # network creation
 137
 138         start_time = time.time()
 139         self.__logger.info("Creating keypair ...")
 140         kp_file = os.path.join(self.data_dir, "cloudify_vrouter.pem")
 141         keypair_settings = KeypairSettings(name='cloudify_vrouter_kp',
 142                                            private_filepath=kp_file)
 143         keypair_creator = OpenStackKeypair(self.snaps_creds, keypair_settings)
 144         keypair_creator.create()
 145         self.created_object.append(keypair_creator)
 146
 147         self.__logger.info("Creating full network ...")
 148         subnet_settings = SubnetSettings(name='cloudify_vrouter_subnet',
 149                                          cidr='10.67.79.0/24')
 150         network_settings = NetworkSettings(name='cloudify_vrouter_network',
 151                                            subnet_settings=[subnet_settings])
 152         network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
 153         network_creator.create()
 154         self.created_object.append(network_creator)
 155         ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
 156         router_creator = OpenStackRouter(
 157             self.snaps_creds,
 158             RouterSettings(
 159                 name='cloudify_vrouter_router',
 160                 external_gateway=ext_net_name,
 161                 internal_subnets=[subnet_settings.name]))
 162         router_creator.create()
 163         self.created_object.append(router_creator)
 164
 165         # security group creation
 166         self.__logger.info("Creating security group for cloudify manager vm")
 167         sg_rules = list()
 168         sg_rules.append(
 169             SecurityGroupRuleSettings(sec_grp_name="sg-cloudify-manager",
 170                                       direction=Direction.ingress,
 171                                       protocol=Protocol.tcp, port_range_min=1,
 172                                       port_range_max=65535))
 173         sg_rules.append(
 174             SecurityGroupRuleSettings(sec_grp_name="sg-cloudify-manager",
 175                                       direction=Direction.ingress,
 176                                       protocol=Protocol.udp, port_range_min=1,
 177                                       port_range_max=65535))
 178
 179         security_group_creator = OpenStackSecurityGroup(
 180             self.snaps_creds,
 181             SecurityGroupSettings(
 182                 name="sg-cloudify-manager",
 183                 rule_settings=sg_rules))
 184
 185         security_group_creator.create()
 186         self.created_object.append(security_group_creator)
 187
 188         # orchestrator VM flavor
 189         self.__logger.info("Get or create flavor for cloudify manager vm ...")
 190
 191         flavor_settings = FlavorSettings(
 192             name=self.orchestrator['requirements']['flavor']['name'],
 193             ram=self.orchestrator['requirements']['flavor']['ram_min'],
 194             disk=50,
 195             vcpus=2)
 196         flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
 197         flavor_creator.create()
 198         self.created_object.append(flavor_creator)
 199         image_settings = ImageSettings(
 200             name=self.orchestrator['requirements']['os_image'],
 201             image_user='centos',
 202             exists=True)
 203
 204         port_settings = PortSettings(name='cloudify_manager_port',
 205                                      network_name=network_settings.name)
 206
 207         manager_settings = VmInstanceSettings(
 208             name='cloudify_manager',
 209             flavor=flavor_settings.name,
 210             port_settings=[port_settings],
 211             security_group_names=[
 212                 security_group_creator.sec_grp_settings.name],
 213             floating_ip_settings=[FloatingIpSettings(
 214                 name='cloudify_manager_fip',
 215                 port_name=port_settings.name,
 216                 router_name=router_creator.router_settings.name)])
 217
 218         manager_creator = OpenStackVmInstance(self.snaps_creds,
 219                                               manager_settings,
 220                                               image_settings,
 221                                               keypair_settings)
 222
 223         self.__logger.info("Creating cloudify manager VM")
 224         manager_creator.create()
 225         self.created_object.append(manager_creator)
 226
 227         public_auth_url = os_utils.get_endpoint('identity')
 228
 229         self.__logger.info("Set creds for cloudify manager")
 230         cfy_creds = dict(keystone_username=self.tenant_name,
 231                          keystone_password=self.tenant_name,
 232                          keystone_tenant_name=self.tenant_name,
 233                          keystone_url=public_auth_url)
 234
 235         cfy_client = CloudifyClient(host=manager_creator.get_floating_ip().ip,
 236                                     username='admin',
 237                                     password='admin',
 238                                     tenant='default_tenant')
 239
 240         self.orchestrator['object'] = cfy_client
 241
 242         self.cfy_manager_ip = manager_creator.get_floating_ip().ip
 243
 244         self.__logger.info("Attemps running status of the Manager")
 245         cfy_status = None
 246         retry = 10
 247         while str(cfy_status) != 'running' and retry:
 248             try:
 249                 cfy_status = cfy_client.manager.get_status()['status']
 250                 self.__logger.debug("The current manager status is %s",
 251                                     cfy_status)
 252             except Exception:  # pylint: disable=broad-except
 253                 self.__logger.warning("Cloudify Manager isn't " +
 254                                       "up and running. Retrying ...")
 255             retry = retry - 1
 256             time.sleep(30)
 257
 258         if str(cfy_status) == 'running':
 259             self.__logger.info("Cloudify Manager is up and running")
 260         else:
 261             raise Exception("Cloudify Manager isn't up and running")
 262
 263         self.__logger.info("Put OpenStack creds in manager")
 264         secrets_list = cfy_client.secrets.list()
 265         for k, val in cfy_creds.iteritems():
 266             if not any(d.get('key', None) == k for d in secrets_list):
 267                 cfy_client.secrets.create(k, val)
 268             else:
 269                 cfy_client.secrets.update(k, val)
 270
 271         duration = time.time() - start_time
 272
 273         self.__logger.info("Put private keypair in manager")
 274         if manager_creator.vm_ssh_active(block=True):
 275             ssh = manager_creator.ssh_client()
 276             scp = SCPClient(ssh.get_transport(), socket_timeout=15.0)
 277             scp.put(kp_file, '~/')
 278             cmd = "sudo cp ~/cloudify_vrouter.pem /etc/cloudify/"
 279             run_blocking_ssh_command(ssh, cmd)
 280             cmd = "sudo chmod 444 /etc/cloudify/cloudify_vrouter.pem"
 281             run_blocking_ssh_command(ssh, cmd)
 282             cmd = "sudo yum install -y gcc python-devel"
 283             run_blocking_ssh_command(
 284                 ssh, cmd, "Unable to install packages on manager")
 285
 286         self.details['orchestrator'].update(status='PASS', duration=duration)
 287
 288         self.vnf['inputs'].update(dict(external_network_name=ext_net_name))
 289
 290         return True
 291
 292     def deploy_vnf(self):
 293         start_time = time.time()
 294
 295         self.__logger.info("Upload VNFD")
 296         cfy_client = self.orchestrator['object']
 297         descriptor = self.vnf['descriptor']
 298         self.deployment_name = descriptor.get('name')
 299
 300         vrouter_blueprint_dir = os.path.join(self.data_dir,
 301                                              self.util.blueprint_dir)
 302         if not os.path.exists(vrouter_blueprint_dir):
 303             Repo.clone_from(descriptor.get('url'),
 304                             vrouter_blueprint_dir,
 305                             branch=descriptor.get('version'))
 306
 307         cfy_client.blueprints.upload(vrouter_blueprint_dir +
 308                                      self.util.blueprint_file_name,
 309                                      descriptor.get('name'))
 310
 311         self.__logger.info("Get or create flavor for vrouter")
 312         flavor_settings = FlavorSettings(
 313             name=self.vnf['requirements']['flavor']['name'],
 314             ram=self.vnf['requirements']['flavor']['ram_min'],
 315             disk=25,
 316             vcpus=1)
 317         flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
 318         flavor = flavor_creator.create()
 319         self.created_object.append(flavor_creator)
 320
 321         # set image name
 322         glance = glance_utils.glance_client(self.snaps_creds)
 323         image = glance_utils.get_image(glance,
 324                                        "vyos1.1.7")
 325         self.vnf['inputs'].update(dict(target_vnf_image_id=image.id))
 326         self.vnf['inputs'].update(dict(reference_vnf_image_id=image.id))
 327
 328         # set flavor id
 329         self.vnf['inputs'].update(dict(target_vnf_flavor_id=flavor.id))
 330         self.vnf['inputs'].update(dict(reference_vnf_flavor_id=flavor.id))
 331
 332         self.vnf['inputs'].update(dict(keystone_username=self.tenant_name))
 333         self.vnf['inputs'].update(dict(keystone_password=self.tenant_name))
 334         self.vnf['inputs'].update(dict(keystone_tenant_name=self.tenant_name))
 335         self.vnf['inputs'].update(
 336             dict(keystone_url=os_utils.get_endpoint('identity')))
 337
 338         self.__logger.info("Create VNF Instance")
 339         cfy_client.deployments.create(descriptor.get('name'),
 340                                       descriptor.get('name'),
 341                                       self.vnf.get('inputs'))
 342
 343         wait_for_execution(cfy_client,
 344                            get_execution_id(
 345                                cfy_client, descriptor.get('name')),
 346                            self.__logger,
 347                            timeout=7200)
 348
 349         self.__logger.info("Start the VNF Instance deployment")
 350         execution = cfy_client.executions.start(descriptor.get('name'),
 351                                                 'install')
 352         # Show execution log
 353         execution = wait_for_execution(cfy_client, execution, self.__logger)
 354
 355         duration = time.time() - start_time
 356
 357         self.__logger.info(execution)
 358         if execution.status == 'terminated':
 359             self.details['vnf'].update(status='PASS', duration=duration)
 360             result = True
 361         else:
 362             self.details['vnf'].update(status='FAIL', duration=duration)
 363             result = False
 364         return result
 365
 366     def test_vnf(self):
 367         cfy_client = self.orchestrator['object']
 368         credentials = {"username": self.snaps_creds.username,
 369                        "password": self.snaps_creds.password,
 370                        "auth_url": self.snaps_creds.auth_url,
 371                        "tenant_name": self.snaps_creds.project_name,
 372                        "region_name": os.environ['OS_REGION_NAME']}
 373
 374         self.util_info = {"credentials": credentials,
 375                           "cfy": cfy_client,
 376                           "vnf_data_dir": self.util.vnf_data_dir}
 377
 378         start_time = time.time()
 379
 380         result, test_result_data = super(CloudifyVrouter, self).test_vnf()
 381
 382         duration = time.time() - start_time
 383
 384         if result:
 385             self.details['test_vnf'].update(status='PASS',
 386                                             result='OK',
 387                                             full_result=test_result_data,
 388                                             duration=duration)
 389         else:
 390             self.details['test_vnf'].update(status='FAIL',
 391                                             result='NG',
 392                                             full_result=test_result_data,
 393                                             duration=duration)
 394
 395         return True
 396
 397     def clean(self):
 398         try:
 399             cfy_client = self.orchestrator['object']
 400             dep_name = self.vnf['descriptor'].get('name')
 401             # kill existing execution
 402             self.__logger.info('Deleting the current deployment')
 403             exec_list = cfy_client.executions.list(dep_name)
 404             for execution in exec_list:
 405                 if execution['status'] == "started":
 406                     try:
 407                         cfy_client.executions.cancel(execution['id'],
 408                                                      force=True)
 409                     except:  # pylint: disable=broad-except
 410                         self.__logger.warn("Can't cancel the current exec")
 411
 412             execution = cfy_client.executions.start(
 413                 dep_name,
 414                 'uninstall',
 415                 parameters=dict(ignore_failure=True))
 416
 417             wait_for_execution(cfy_client, execution, self.__logger)
 418             cfy_client.deployments.delete(self.vnf['descriptor'].get('name'))
 419             cfy_client.blueprints.delete(self.vnf['descriptor'].get('name'))
 420         except:  # pylint: disable=broad-except
 421             self.__logger.warn("Some issue during the undeployment ..")
 422             self.__logger.warn("Tenant clean continue ..")
 423
 424         self.__logger.info('Remove the cloudify manager OS object ..')
 425         for creator in reversed(self.created_object):
 426             try:
 427                 creator.clean()
 428             except Exception as exc:
 429                 self.logger.error('Unexpected error cleaning - %s', exc)
 430
 431         super(CloudifyVrouter, self).clean()
 432
 433     def run(self, **kwargs):
 434         """Execute CloudifyVrouter test case."""
 435         return super(CloudifyVrouter, self).run(**kwargs)
 436
 437     def get_vnf_info_list(self, target_vnf_name):
 438         return self.util.get_vnf_info_list(self.cfy_manager_ip,
 439                                            self.deployment_name,
 440                                            target_vnf_name)
 441
 442
 443 # ----------------------------------------------------------
 444 #
 445 #               YAML UTILS
 446 #
 447 # -----------------------------------------------------------
 448 def get_config(parameter, file_path):
 449     """
 450     Get config parameter.
 451     Returns the value of a given parameter in file.yaml
 452     parameter must be given in string format with dots
 453     Example: general.openstack.image_name
 454     """
 455     with open(file_path) as config_file:
 456         file_yaml = yaml.safe_load(config_file)
 457     config_file.close()
 458     value = file_yaml
 459     for element in parameter.split("."):
 460         value = value.get(element)
 461         if value is None:
 462             raise ValueError("The parameter %s is not defined in"
 463                              " reporting.yaml" % parameter)
 464     return value
 465
 466
 467 def wait_for_execution(client, execution, logger, timeout=7200, ):
 468     """Wait for a workflow execution on Cloudify Manager."""
 469     # if execution already ended - return without waiting
 470     if execution.status in Execution.END_STATES:
 471         return execution
 472
 473     if timeout is not None:
 474         deadline = time.time() + timeout
 475
 476     # Poll for execution status and execution logs, until execution ends
 477     # and we receive an event of type in WORKFLOW_END_TYPES
 478     offset = 0
 479     batch_size = 50
 480     event_list = []
 481     execution_ended = False
 482     while True:
 483         event_list = client.events.list(
 484             execution_id=execution.id,
 485             _offset=offset,
 486             _size=batch_size,
 487             include_logs=False,
 488             sort='@timestamp').items
 489
 490         offset = offset + len(event_list)
 491         for event in event_list:
 492             logger.debug(event.get('message'))
 493
 494         if timeout is not None:
 495             if time.time() > deadline:
 496                 raise RuntimeError(
 497                     'execution of operation {0} for deployment {1} '
 498                     'timed out'.format(execution.workflow_id,
 499                                        execution.deployment_id))
 500             else:
 501                 # update the remaining timeout
 502                 timeout = deadline - time.time()
 503
 504         if not execution_ended:
 505             execution = client.executions.get(execution.id)
 506             execution_ended = execution.status in Execution.END_STATES
 507
 508         if execution_ended:
 509             break
 510
 511         time.sleep(5)
 512
 513     return execution
 514
 515
 516 def get_execution_id(client, deployment_id):
 517     """
 518     Get the execution id of a env preparation.
 519     network, security group, fip, VM creation
 520     """
 521     executions = client.executions.list(deployment_id=deployment_id)
 522     for execution in executions:
 523         if execution.workflow_id == 'create_deployment_environment':
 524             return execution
 525     raise RuntimeError('Failed to get create_deployment_environment '
 526                        'workflow execution.'
 527                        'Available executions: {0}'.format(executions))
 528
 529
 530 def run_blocking_ssh_command(ssh, cmd, error_msg="Unable to run this command"):
 531     """Command to run ssh command with the exit status."""
 532     (_, stdout, _) = ssh.exec_command(cmd)
 533     if stdout.channel.recv_exit_status() != 0:
 534         raise Exception(error_msg)