#!/usr/bin/env python
-# Copyright (c) 2016 Orange and others.
+# Copyright (c) 2017 Orange and others.
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
-import json
-import os
-import requests
-import subprocess
-import time
-
-import functest.core.vnf_base as vnf_base
-import functest.utils.functest_logger as ft_logger
-import functest.utils.functest_utils as ft_utils
-import functest.utils.openstack_utils as os_utils
-
-from clearwater import Clearwater
-from functest.utils.constants import CONST
-from orchestrator_cloudify import Orchestrator
-
+"""CloudifyIms testcase implementation."""
-class ImsVnf(vnf_base.VnfOnBoardingBase):
+from __future__ import division
- def __init__(self, project='functest', case='cloudify_ims',
- repo='', cmd=''):
- super(ImsVnf, self).__init__(project, case, repo, cmd)
- self.logger = ft_logger.Logger("vIMS").getLogger()
- self.case_dir = os.path.join(CONST.functest_test, 'vnf/ims/')
- self.data_dir = CONST.dir_vIMS_data
- self.test_dir = CONST.dir_repo_vims_test
+import logging
+import os
+import time
+import uuid
+
+from cloudify_rest_client import CloudifyClient
+from cloudify_rest_client.executions import Execution
+from scp import SCPClient
+import six
+from snaps.config.flavor import FlavorConfig
+from snaps.config.image import ImageConfig
+from snaps.config.keypair import KeypairConfig
+from snaps.config.network import NetworkConfig, PortConfig, SubnetConfig
+from snaps.config.router import RouterConfig
+from snaps.config.security_group import (
+ Direction, Protocol, SecurityGroupConfig, SecurityGroupRuleConfig)
+from snaps.config.user import UserConfig
+from snaps.config.vm_inst import FloatingIpConfig, VmInstanceConfig
+from snaps.openstack.create_flavor import OpenStackFlavor
+from snaps.openstack.create_image import OpenStackImage
+from snaps.openstack.create_instance import OpenStackVmInstance
+from snaps.openstack.create_keypairs import OpenStackKeypair
+from snaps.openstack.create_network import OpenStackNetwork
+from snaps.openstack.create_router import OpenStackRouter
+from snaps.openstack.create_security_group import OpenStackSecurityGroup
+from snaps.openstack.create_user import OpenStackUser
+from snaps.openstack.utils import keystone_utils
+from xtesting.energy import energy
+import yaml
+
+from functest.opnfv_tests.openstack.snaps import snaps_utils
+from functest.opnfv_tests.vnf.ims import clearwater_ims_base
+from functest.utils import config
+from functest.utils import env
+
+__author__ = "Valentin Boucher <valentin.boucher@orange.com>"
+
+
+class CloudifyIms(clearwater_ims_base.ClearwaterOnBoardingBase):
+ """Clearwater vIMS deployed with Cloudify Orchestrator Case."""
+
+ __logger = logging.getLogger(__name__)
+
+ def __init__(self, **kwargs):
+ """Initialize CloudifyIms testcase object."""
+ if "case_name" not in kwargs:
+ kwargs["case_name"] = "cloudify_ims"
+ super(CloudifyIms, self).__init__(**kwargs)
+
+ # Retrieve the configuration
+ try:
+ self.config = getattr(
+ config.CONF, 'vnf_{}_config'.format(self.case_name))
+ except Exception:
+ raise Exception("VNF config file not found")
+ config_file = os.path.join(self.case_dir, self.config)
self.orchestrator = dict(
- requirements=CONST.cloudify_requirements,
- blueprint=CONST.cloudify_blueprint,
- inputs=CONST.cloudify_inputs
+ requirements=get_config("orchestrator.requirements", config_file),
)
-
+ self.details['orchestrator'] = dict(
+ name=get_config("orchestrator.name", config_file),
+ version=get_config("orchestrator.version", config_file),
+ status='ERROR',
+ result=''
+ )
+ self.__logger.debug("Orchestrator configuration %s", self.orchestrator)
self.vnf = dict(
- blueprint=CONST.clearwater_blueprint,
- deployment_name=CONST.clearwater_deployment_name,
- inputs=CONST.clearwater_inputs,
- requirements=CONST.clearwater_requirements
+ descriptor=get_config("vnf.descriptor", config_file),
+ inputs=get_config("vnf.inputs", config_file),
+ requirements=get_config("vnf.requirements", config_file)
+ )
+ self.details['vnf'] = dict(
+ descriptor_version=self.vnf['descriptor']['version'],
+ name=get_config("vnf.name", config_file),
+ version=get_config("vnf.version", config_file),
)
+ self.__logger.debug("VNF configuration: %s", self.vnf)
- # vIMS Data directory creation
- if not os.path.exists(self.data_dir):
- os.makedirs(self.data_dir)
+ self.details['test_vnf'] = dict(
+ name=get_config("vnf_test_suite.name", config_file),
+ version=get_config("vnf_test_suite.version", config_file)
+ )
+ self.images = get_config("tenant_images", config_file)
+ self.__logger.info("Images needed for vIMS: %s", self.images)
- def deploy_orchestrator(self, **kwargs):
- public_auth_url = os_utils.get_endpoint('identity')
+ def prepare(self):
+ """Prepare testscase (Additional pre-configuration steps)."""
+ super(CloudifyIms, self).prepare()
- cfy = Orchestrator(self.data_dir, self.orchestrator.inputs)
- self.orchestrator.object = cfy
+ self.__logger.info("Additional pre-configuration steps")
- if 'tenant_name' in self.creds.keys():
- tenant_name = self.creds['tenant_name']
- elif 'project_name' in self.creds.keys():
- tenant_name = self.creds['project_name']
+ compute_quotas = self.os_project.get_compute_quotas()
+ network_quotas = self.os_project.get_network_quotas()
- cfy.set_credentials(username=self.creds['username'],
- password=self.creds['password'],
- tenant_name=tenant_name,
- auth_url=public_auth_url)
+ for key, value in (
+ self.vnf['requirements']['compute_quotas'].items()):
+ setattr(compute_quotas, key, value)
- # orchestrator VM flavor
- flavor_id = self.get_flavor("m1.large", self.orchestrator.requirements)
- if not flavor_id:
- self.logger.info("Available flavors are: ")
- self.pMsg(self.nova_client.flavor.list())
- self.step_failure("Failed to find required flavor"
- "for this deployment")
- cfy.set_flavor_id(flavor_id)
-
- # orchestrator VM image
- if 'os_image' in self.orchestrator.requirements.keys():
- image_id = os_utils.get_image_id(
- self.glance_client, self.orchestrator.requirements['os_image'])
- if image_id == '':
- self.step_failure("Failed to find required OS image"
- " for cloudify manager")
- else:
- self.step_failure("Failed to find required OS image"
- " for cloudify manager")
+ for key, value in (
+ self.vnf['requirements']['network_quotas'].items()):
+ setattr(network_quotas, key, value)
- cfy.set_image_id(image_id)
+ compute_quotas = self.os_project.update_compute_quotas(compute_quotas)
+ network_quotas = self.os_project.update_network_quotas(network_quotas)
- ext_net = os_utils.get_external_net(self.neutron_client)
- if not ext_net:
- self.step_failure("Failed to get external network")
+ def deploy_orchestrator(self):
+ # pylint: disable=too-many-locals,too-many-statements
+ """
+ Deploy Cloudify Manager.
- cfy.set_external_network_name(ext_net)
+ network, security group, fip, VM creation
+ """
+ start_time = time.time()
- ns = ft_utils.get_resolvconf_ns()
- if ns:
- cfy.set_nameservers(ns)
-
- if 'compute' in self.nova_client.client.services_url:
- cfy.set_nova_url(self.nova_client.client.services_url['compute'])
- if self.neutron_client.httpclient.endpoint_url is not None:
- cfy.set_neutron_url(self.neutron_client.httpclient.endpoint_url)
-
- self.logger.info("Prepare virtualenv for cloudify-cli")
- cmd = "chmod +x " + self.case_dir + "create_venv.sh"
- ft_utils.execute_command(cmd)
- time.sleep(3)
- cmd = self.case_dir + "create_venv.sh " + self.data_dir
- ft_utils.execute_command(cmd)
+ # orchestrator VM flavor
+ self.__logger.info("Get or create flavor for cloudify manager vm ...")
+ flavor_settings = FlavorConfig(
+ name="{}-{}".format(
+ self.orchestrator['requirements']['flavor']['name'],
+ self.uuid),
+ ram=self.orchestrator['requirements']['flavor']['ram_min'],
+ disk=50,
+ vcpus=2)
+ flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
+ flavor_creator.create()
+ self.created_object.append(flavor_creator)
+
+ self.__logger.info("Creating a second user to bypass issues ...")
+ user_creator = OpenStackUser(
+ self.snaps_creds,
+ UserConfig(
+ name='cloudify_network_bug-{}'.format(self.uuid),
+ password=str(uuid.uuid4()),
+ project_name=self.tenant_name,
+ domain_name=self.snaps_creds.user_domain_name,
+ roles={'_member_': self.tenant_name}))
+ user_creator.create()
+ self.created_object.append(user_creator)
+
+ snaps_creds = user_creator.get_os_creds(self.snaps_creds.project_name)
+ self.__logger.debug("snaps creds: %s", snaps_creds)
+
+ self.__logger.info("Creating keypair ...")
+ kp_file = os.path.join(self.data_dir, "cloudify_ims.pem")
+ keypair_settings = KeypairConfig(
+ name='cloudify_ims_kp-{}'.format(self.uuid),
+ private_filepath=kp_file)
+ keypair_creator = OpenStackKeypair(snaps_creds, keypair_settings)
+ keypair_creator.create()
+ self.created_object.append(keypair_creator)
+
+ # needs some images
+ self.__logger.info("Upload some OS images if it doesn't exist")
+ for image_name, image_file in six.iteritems(self.images):
+ self.__logger.info("image: %s, file: %s", image_name, image_file)
+ if image_file and image_name:
+ image_creator = OpenStackImage(
+ snaps_creds,
+ ImageConfig(
+ name=image_name, image_user='cloud',
+ img_format='qcow2', image_file=image_file))
+ image_creator.create()
+ self.created_object.append(image_creator)
+
+ # network creation
+ self.__logger.info("Creating full network ...")
+ subnet_settings = SubnetConfig(
+ name='cloudify_ims_subnet-{}'.format(self.uuid),
+ cidr='10.67.79.0/24',
+ dns_nameservers=[env.get('NAMESERVER')])
+ network_settings = NetworkConfig(
+ name='cloudify_ims_network-{}'.format(self.uuid),
+ subnet_settings=[subnet_settings])
+ network_creator = OpenStackNetwork(snaps_creds, network_settings)
+ network_creator.create()
+ self.created_object.append(network_creator)
+ ext_net_name = snaps_utils.get_ext_net_name(snaps_creds)
+ router_creator = OpenStackRouter(
+ snaps_creds,
+ RouterConfig(
+ name='cloudify_ims_router-{}'.format(self.uuid),
+ external_gateway=ext_net_name,
+ internal_subnets=[subnet_settings.name]))
+ router_creator.create()
+ self.created_object.append(router_creator)
+
+ # security group creation
+ self.__logger.info("Creating security group for cloudify manager vm")
+ sg_rules = list()
+ sg_rules.append(
+ SecurityGroupRuleConfig(
+ sec_grp_name="sg-cloudify-manager-{}".format(self.uuid),
+ direction=Direction.ingress, protocol=Protocol.tcp,
+ port_range_min=1, port_range_max=65535))
+ sg_rules.append(
+ SecurityGroupRuleConfig(
+ sec_grp_name="sg-cloudify-manager-{}".format(self.uuid),
+ direction=Direction.ingress, protocol=Protocol.udp,
+ port_range_min=1, port_range_max=65535))
+ security_group_creator = OpenStackSecurityGroup(
+ snaps_creds,
+ SecurityGroupConfig(
+ name="sg-cloudify-manager-{}".format(self.uuid),
+ rule_settings=sg_rules))
+ security_group_creator.create()
+ self.created_object.append(security_group_creator)
+
+ image_settings = ImageConfig(
+ name=self.orchestrator['requirements']['os_image'],
+ image_user='centos',
+ exists=True)
+ port_settings = PortConfig(
+ name='cloudify_manager_port-{}'.format(self.uuid),
+ network_name=network_settings.name)
+ manager_settings = VmInstanceConfig(
+ name='cloudify_manager-{}'.format(self.uuid),
+ flavor=flavor_settings.name,
+ port_settings=[port_settings],
+ security_group_names=[
+ security_group_creator.sec_grp_settings.name],
+ floating_ip_settings=[FloatingIpConfig(
+ name='cloudify_manager_fip-{}'.format(self.uuid),
+ port_name=port_settings.name,
+ router_name=router_creator.router_settings.name)])
+ manager_creator = OpenStackVmInstance(
+ snaps_creds, manager_settings, image_settings,
+ keypair_settings)
+ self.__logger.info("Creating cloudify manager VM")
+ manager_creator.create()
+ self.created_object.append(manager_creator)
+
+ public_auth_url = keystone_utils.get_endpoint(snaps_creds, 'identity')
+
+ cfy_creds = dict(
+ keystone_username=snaps_creds.username,
+ keystone_password=snaps_creds.password,
+ keystone_tenant_name=snaps_creds.project_name,
+ keystone_url=public_auth_url,
+ region=snaps_creds.region_name if snaps_creds.region_name else (
+ 'RegionOne'),
+ user_domain_name=snaps_creds.user_domain_name,
+ project_domain_name=snaps_creds.project_domain_name)
+ self.__logger.info("Set creds for cloudify manager %s", cfy_creds)
+
+ cfy_client = CloudifyClient(
+ host=manager_creator.get_floating_ip().ip,
+ username='admin', password='admin', tenant='default_tenant',
+ api_version='v3')
+
+ self.orchestrator['object'] = cfy_client
+
+ self.__logger.info("Attemps running status of the Manager")
+ for loop in range(10):
+ try:
+ self.__logger.debug(
+ "status %s", cfy_client.manager.get_status())
+ cfy_status = cfy_client.manager.get_status()['status']
+ self.__logger.info(
+ "The current manager status is %s", cfy_status)
+ if str(cfy_status) != 'running':
+ raise Exception("Cloudify Manager isn't up and running")
+ self.__logger.info("Put OpenStack creds in manager")
+ secrets_list = cfy_client.secrets.list()
+ for k, val in six.iteritems(cfy_creds):
+ if not any(d.get('key', None) == k for d in secrets_list):
+ cfy_client.secrets.create(k, val)
+ else:
+ cfy_client.secrets.update(k, val)
+ break
+ except Exception: # pylint: disable=broad-except
+ self.logger.info(
+ "try %s: Cloudify Manager isn't up and running", loop + 1)
+ time.sleep(30)
+ else:
+ self.logger.error("Cloudify Manager isn't up and running")
+ return False
+
+ duration = time.time() - start_time
+
+ if manager_creator.vm_ssh_active(block=True):
+ self.__logger.info("Put private keypair in manager")
+ ssh = manager_creator.ssh_client()
+ scp = SCPClient(ssh.get_transport(), socket_timeout=15.0)
+ scp.put(kp_file, '~/')
+ cmd = "sudo cp ~/cloudify_ims.pem /etc/cloudify/"
+ self.run_blocking_ssh_command(ssh, cmd)
+ cmd = "sudo chmod 444 /etc/cloudify/cloudify_ims.pem"
+ self.run_blocking_ssh_command(ssh, cmd)
+ # cmd2 is badly unpinned by Cloudify
+ cmd = "sudo yum install -y gcc python-devel python-cmd2"
+ self.run_blocking_ssh_command(
+ ssh, cmd, "Unable to install packages on manager")
+ self.run_blocking_ssh_command(ssh, 'cfy status')
+ else:
+ self.__logger.error("Cannot connect to manager")
+ return False
- cfy.download_manager_blueprint(self.orchestrator.blueprint['url'],
- self.orchestrator.blueprint['branch'])
+ self.details['orchestrator'].update(status='PASS', duration=duration)
- cfy.deploy_manager()
- return {'status': 'PASS', 'result': ''}
+ self.vnf['inputs'].update(dict(
+ external_network_name=ext_net_name,
+ network_name=network_settings.name,
+ key_pair_name=keypair_settings.name
+ ))
+ self.result = 1/3 * 100
+ return True
def deploy_vnf(self):
- cw = Clearwater(self.vnf.inputs, self.orchestrator.object, self.logger)
- self.vnf.object = cw
-
- self.logger.info("Collect flavor id for all clearwater vm")
- flavor_id = self.get_flavor("m1.small", self.vnf.requirements)
- if not flavor_id:
- self.logger.info("Available flavors are: ")
- self.pMsg(self.nova_client.flavor.list())
- self.step_failure("Failed to find required flavor"
- " for this deployment")
-
- cw.set_flavor_id(flavor_id)
-
- # VMs image
- if 'os_image' in self.vnf.requirements.keys():
- image_id = os_utils.get_image_id(
- self.glance_client, self.vnf.requirements['os_image'])
- if image_id == '':
- self.step_failure("Failed to find required OS image"
- " for clearwater VMs")
+ """Deploy Clearwater IMS."""
+ start_time = time.time()
+
+ self.__logger.info("Upload VNFD")
+ cfy_client = self.orchestrator['object']
+ descriptor = self.vnf['descriptor']
+ cfy_client.blueprints.upload(
+ descriptor.get('file_name'), descriptor.get('name'))
+ self.__logger.info("Get or create flavor for all clearwater vm")
+ flavor_settings = FlavorConfig(
+ name="{}-{}".format(
+ self.vnf['requirements']['flavor']['name'],
+ self.uuid),
+ ram=self.vnf['requirements']['flavor']['ram_min'],
+ disk=25,
+ vcpus=2)
+ flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
+ flavor_creator.create()
+ self.created_object.append(flavor_creator)
+
+ self.vnf['inputs'].update(dict(
+ flavor_id=flavor_settings.name,
+ ))
+
+ self.__logger.info("Create VNF Instance")
+ cfy_client.deployments.create(descriptor.get('name'),
+ descriptor.get('name'),
+ self.vnf.get('inputs'))
+
+ wait_for_execution(
+ cfy_client,
+ get_execution_id(cfy_client, descriptor.get('name')),
+ self.__logger, timeout=300)
+
+ self.__logger.info("Start the VNF Instance deployment")
+ execution = cfy_client.executions.start(descriptor.get('name'),
+ 'install')
+ # Show execution log
+ execution = wait_for_execution(
+ cfy_client, execution, self.__logger, timeout=3600)
+
+ duration = time.time() - start_time
+
+ self.__logger.info(execution)
+ if execution.status == 'terminated':
+ self.details['vnf'].update(status='PASS', duration=duration)
+ self.result += 1/3 * 100
+ result = True
else:
- self.step_failure("Failed to find required OS image"
- " for clearwater VMs")
-
- cw.set_image_id(image_id)
+ self.details['vnf'].update(status='FAIL', duration=duration)
+ result = False
+ return result
- ext_net = os_utils.get_external_net(self.neutron_client)
- if not ext_net:
- self.step_failure("Failed to get external network")
+ def test_vnf(self):
+ """Run test on clearwater ims instance."""
+ start_time = time.time()
+
+ cfy_client = self.orchestrator['object']
+
+ outputs = cfy_client.deployments.outputs.get(
+ self.vnf['descriptor'].get('name'))['outputs']
+ dns_ip = outputs['dns_ip']
+ ellis_ip = outputs['ellis_ip']
+ self.config_ellis(ellis_ip)
+
+ if not dns_ip:
+ return False
+
+ short_result = self.run_clearwater_live_test(
+ dns_ip=dns_ip,
+ public_domain=self.vnf['inputs']["public_domain"])
+ duration = time.time() - start_time
+ self.__logger.info(short_result)
+ self.details['test_vnf'].update(result=short_result,
+ duration=duration)
+ try:
+ vnf_test_rate = short_result['passed'] / (
+ short_result['total'] - short_result['skipped'])
+ # orchestrator + vnf + test_vnf
+ self.result += vnf_test_rate / 3 * 100
+ except ZeroDivisionError:
+ self.__logger.error("No test has been executed")
+ self.details['test_vnf'].update(status='FAIL')
+ return False
+ except Exception: # pylint: disable=broad-except
+ self.__logger.exception("Cannot calculate results")
+ self.details['test_vnf'].update(status='FAIL')
+ return False
+ return True if vnf_test_rate > 0 else False
- cw.set_external_network_name(ext_net)
+ def clean(self):
+ """Clean created objects/functions."""
+ try:
+ cfy_client = self.orchestrator['object']
+ dep_name = self.vnf['descriptor'].get('name')
+ # kill existing execution
+ self.__logger.info('Deleting the current deployment')
+ exec_list = cfy_client.executions.list(dep_name)
+ for execution in exec_list:
+ if execution['status'] == "started":
+ try:
+ cfy_client.executions.cancel(execution['id'],
+ force=True)
+ except Exception: # pylint: disable=broad-except
+ self.__logger.warn("Can't cancel the current exec")
+
+ execution = cfy_client.executions.start(
+ dep_name,
+ 'uninstall',
+ parameters=dict(ignore_failure=True),
+ force=True)
+
+ wait_for_execution(cfy_client, execution, self.__logger)
+ cfy_client.deployments.delete(self.vnf['descriptor'].get('name'))
+ cfy_client.blueprints.delete(self.vnf['descriptor'].get('name'))
+ except Exception: # pylint: disable=broad-except
+ self.__logger.exception("Some issue during the undeployment ..")
+
+ super(CloudifyIms, self).clean()
+
+ @staticmethod
+ def run_blocking_ssh_command(ssh, cmd,
+ error_msg="Unable to run this command"):
+ """Command to run ssh command with the exit status."""
+ _, stdout, stderr = ssh.exec_command(cmd)
+ CloudifyIms.__logger.debug("SSH %s stdout: %s", cmd, stdout.read())
+ if stdout.channel.recv_exit_status() != 0:
+ CloudifyIms.__logger.error("SSH %s stderr: %s", cmd, stderr.read())
+ raise Exception(error_msg)
+
+ @energy.enable_recording
+ def run(self, **kwargs):
+ """Execute CloudifyIms test case."""
+ return super(CloudifyIms, self).run(**kwargs)
+
+
+# ----------------------------------------------------------
+#
+# YAML UTILS
+#
+# -----------------------------------------------------------
+def get_config(parameter, file_path):
+ """
+ Get config parameter.
+
+ Returns the value of a given parameter in file.yaml
+ parameter must be given in string format with dots
+ Example: general.openstack.image_name
+ """
+ with open(file_path) as config_file:
+ file_yaml = yaml.safe_load(config_file)
+ config_file.close()
+ value = file_yaml
+ for element in parameter.split("."):
+ value = value.get(element)
+ if value is None:
+ raise ValueError("The parameter %s is not defined in"
+ " reporting.yaml" % parameter)
+ return value
+
+
+def wait_for_execution(client, execution, logger, timeout=3600, ):
+ """Wait for a workflow execution on Cloudify Manager."""
+ # if execution already ended - return without waiting
+ if execution.status in Execution.END_STATES:
+ return execution
+
+ if timeout is not None:
+ deadline = time.time() + timeout
+
+ # Poll for execution status and execution logs, until execution ends
+ # and we receive an event of type in WORKFLOW_END_TYPES
+ offset = 0
+ batch_size = 50
+ event_list = []
+ execution_ended = False
+ while True:
+ event_list = client.events.list(
+ execution_id=execution.id,
+ _offset=offset,
+ _size=batch_size,
+ include_logs=True,
+ sort='@timestamp').items
+
+ offset = offset + len(event_list)
+ for event in event_list:
+ logger.debug(event.get('message'))
+
+ if timeout is not None:
+ if time.time() > deadline:
+ raise RuntimeError(
+ 'execution of operation {0} for deployment {1} '
+ 'timed out'.format(execution.workflow_id,
+ execution.deployment_id))
+ else:
+ # update the remaining timeout
+ timeout = deadline - time.time()
- cw.deploy_vnf()
- return {'status': 'PASS', 'result': ''}
+ if not execution_ended:
+ execution = client.executions.get(execution.id)
+ execution_ended = execution.status in Execution.END_STATES
- def test_vnf(self):
- script = "source {0}venv_cloudify/bin/activate; "
- script += "cd {0}; "
- script += "cfy status | grep -Eo \"([0-9]{{1,3}}\.){{3}}[0-9]{{1,3}}\""
- cmd = "/bin/bash -c '" + script.format(self.data_dir) + "'"
+ if execution_ended:
+ break
- try:
- self.logger.debug("Trying to get clearwater manager IP ... ")
- mgr_ip = os.popen(cmd).read()
- mgr_ip = mgr_ip.splitlines()[0]
- except:
- self.step_failure("Unable to retrieve the IP of the "
- "cloudify manager server !")
-
- api_url = "http://" + mgr_ip + "/api/v2"
- dep_outputs = requests.get(api_url + "/deployments/" +
- self.vnf.deployment_name + "/outputs")
- dns_ip = dep_outputs.json()['outputs']['dns_ip']
- ellis_ip = dep_outputs.json()['outputs']['ellis_ip']
-
- ellis_url = "http://" + ellis_ip + "/"
- url = ellis_url + "accounts"
-
- params = {"password": "functest",
- "full_name": "opnfv functest user",
- "email": "functest@opnfv.fr",
- "signup_code": "secret"}
-
- rq = requests.post(url, data=params)
- i = 20
- while rq.status_code != 201 and i > 0:
- rq = requests.post(url, data=params)
- i = i - 1
- time.sleep(10)
-
- if rq.status_code == 201:
- url = ellis_url + "session"
- rq = requests.post(url, data=params)
- cookies = rq.cookies
-
- url = ellis_url + "accounts/" + params['email'] + "/numbers"
- if cookies != "":
- rq = requests.post(url, cookies=cookies)
- i = 24
- while rq.status_code != 200 and i > 0:
- rq = requests.post(url, cookies=cookies)
- i = i - 1
- time.sleep(25)
-
- if rq.status_code != 200:
- self.step_failure("Unable to create a number: %s"
- % rq.json()['reason'])
-
- nameservers = ft_utils.get_resolvconf_ns()
- resolvconf = ""
- for ns in nameservers:
- resolvconf += "\nnameserver " + ns
-
- if dns_ip != "":
- script = ('echo -e "nameserver ' + dns_ip + resolvconf +
- '" > /etc/resolv.conf; ')
- script += 'source /etc/profile.d/rvm.sh; '
- script += 'cd {0}; '
- script += ('rake test[{1}] SIGNUP_CODE="secret"')
-
- cmd = ("/bin/bash -c '" +
- script.format(self.data_dir, self.inputs["public_domain"]) +
- "'")
- output_file = "output.txt"
- f = open(output_file, 'w+')
- subprocess.call(cmd, shell=True, stdout=f,
- stderr=subprocess.STDOUT)
- f.close()
-
- f = open(output_file, 'r')
- result = f.read()
- if result != "":
- self.logger.debug(result)
-
- vims_test_result = ""
- tempFile = os.path.join(self.test_dir, "temp.json")
- try:
- self.logger.debug("Trying to load test results")
- with open(tempFile) as f:
- vims_test_result = json.load(f)
- f.close()
- except:
- self.logger.error("Unable to retrieve test results")
+ time.sleep(5)
- try:
- os.remove(tempFile)
- except:
- self.logger.error("Deleting file failed")
+ return execution
- if vims_test_result != '':
- return {'status': 'PASS', 'result': vims_test_result}
- else:
- return {'status': 'FAIL', 'result': ''}
- def clean(self):
- self.vnf.object.undeploy_vnf()
- self.orchestrator.object.undeploy_manager()
- super(ImsVnf, self).clean()
+def get_execution_id(client, deployment_id):
+ """
+ Get the execution id of a env preparation.
- def get_flavor(self, flavor_name, requirements):
- try:
- flavor_id = os_utils.get_flavor_id(self.nova_client, flavor_name)
- if 'ram_min' in requirements.keys():
- flavor_id = os_utils.get_flavor_id_by_ram_range(
- self.nova_client, requirements['ram_min'], 7500)
-
- if flavor_id == '':
- self.logger.error(
- "Failed to find %s flavor. "
- "Try with ram range default requirement !" % flavor_name)
- flavor_id = os_utils.get_flavor_id_by_ram_range(
- self.nova_client,
- 4000, 10000)
- return flavor_id
- except:
- self.logger.error("Flavor '%s' not found." % self.flavor_name)
- self.logger.info("Available flavors are: ")
- self.pMsg(self.nova_client.flavor.list())
- return None
+ network, security group, fip, VM creation
+ """
+ executions = client.executions.list(deployment_id=deployment_id)
+ for execution in executions:
+ if execution.workflow_id == 'create_deployment_environment':
+ return execution
+ raise RuntimeError('Failed to get create_deployment_environment '
+ 'workflow execution.'
+ 'Available executions: {0}'.format(executions))
Code Review / functest.git / blobdiff