-#!/usr/bin/python
-# coding: utf8
-#######################################################################
+#!/usr/bin/env python
#
-# Copyright (c) 2015 Orange
-# valentin.boucher@orange.com
-#
-# All rights reserved. This program and the accompanying materials
+# Copyright (c) 2017 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
-########################################################################
+"""Ease testing any Clearwater deployment"""
+
+import logging
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import time
+
+import pkg_resources
+import requests
+
+from functest.utils import config
+import functest.utils.functest_utils as ft_utils
+
+__author__ = ("Valentin Boucher <valentin.boucher@orange.com>, "
+ "Helen Yao <helanyao@gmail.com>")
+
+
+class ClearwaterTesting(object):
+ """vIMS clearwater base usable by several orchestrators"""
+
+ def __init__(self, case_name, ellis_ip):
+ self.logger = logging.getLogger(__name__)
+ self.case_dir = pkg_resources.resource_filename(
+ 'functest', 'opnfv_tests/vnf/ims')
+ self.data_dir = getattr(config.CONF, 'dir_ims_data')
+ self.result_dir = os.path.join(
+ getattr(config.CONF, 'dir_results'), case_name)
+ self.test_dir = getattr(config.CONF, 'dir_repo_vims_test')
+
+ if not os.path.exists(self.data_dir):
+ os.makedirs(self.data_dir)
+ if not os.path.exists(self.result_dir):
+ os.makedirs(self.result_dir)
+
+ self.ellis_ip = ellis_ip
+
+ def availability_check_by_creating_numbers(self,
+ signup_code='secret',
+ two_numbers=False):
+ """Create one or two numbers"""
+ assert self.ellis_ip
+ output_dict = {}
+ self.logger.debug('Ellis IP: %s', self.ellis_ip)
+ output_dict['ellis_ip'] = self.ellis_ip
+ account_url = 'http://{0}/accounts'.format(self.ellis_ip)
+ params = {"password": "functest",
+ "full_name": "opnfv functest user",
+ "email": "functest@opnfv.org",
+ "signup_code": signup_code}
+ output_dict['login'] = params
+
+ number_res = self._create_ellis_account(account_url, params)
+ output_dict['number'] = number_res
+
+ session_url = 'http://{0}/session'.format(self.ellis_ip)
+ session_data = {
+ 'username': params['email'],
+ 'password': params['password'],
+ 'email': params['email']
+ }
+ cookies = self._get_ellis_session_cookies(session_url, session_data)
-class Clearwater(object):
+ number_url = 'http://{0}/accounts/{1}/numbers'.format(
+ self.ellis_ip, params['email'])
+ self.logger.debug('Create 1st calling number on Ellis')
+ number_res = self._create_ellis_number(number_url, cookies)
- def __init__(self, inputs={}, orchestrator=None, logger=None):
- self.config = inputs
- self.orchestrator = orchestrator
- self.logger = logger
- self.deploy = False
+ if two_numbers:
+ self.logger.debug('Create 2nd calling number on Ellis')
+ number_res = self._create_ellis_number(number_url, cookies)
+ output_dict['number2'] = number_res
- def set_orchestrator(self, orchestrator):
- self.orchestrator = orchestrator
+ return output_dict
- def set_flavor_id(self, flavor_id):
- self.config['flavor_id'] = flavor_id
+ def _create_ellis_account(self, account_url, params):
+ i = 50
+ for iloop in range(i):
+ try:
+ req = requests.post(account_url, data=params)
+ if req.status_code == 201:
+ account_res = req.json()
+ self.logger.info(
+ 'Account %s is created on Ellis\n%s',
+ params.get('full_name'), account_res)
+ return account_res
+ else:
+ raise Exception("Cannot create ellis account")
+ except Exception: # pylint: disable=broad-except
+ self.logger.info(
+ "try %s: cannot create ellis account", iloop + 1)
+ time.sleep(25)
+ raise Exception(
+ "Unable to create an account {}".format(
+ params.get('full_name')))
- def set_image_id(self, image_id):
- self.config['image_id'] = image_id
+ def _get_ellis_session_cookies(self, session_url, params):
+ i = 15
+ for iloop in range(i):
+ try:
+ req = requests.post(session_url, data=params)
+ if req.status_code == 201:
+ cookies = req.cookies
+ self.logger.debug('cookies: %s', cookies)
+ return cookies
+ else:
+ raise Exception('Failed to get cookies for Ellis')
+ except Exception: # pylint: disable=broad-except
+ self.logger.info(
+ "try %s: cannot get cookies for Ellis", iloop + 1)
+ time.sleep(10)
+ raise Exception('Failed to get cookies for Ellis')
- def set_agent_user(self, agent_user):
- self.config['agent_user'] = agent_user
+ def _create_ellis_number(self, number_url, cookies):
+ i = 30
+ for iloop in range(i):
+ try:
+ req = requests.post(number_url, cookies=cookies)
+ if req.status_code == 200:
+ number_res = req.json()
+ self.logger.info(
+ 'Calling number is created: %s', number_res)
+ return number_res
+ else:
+ if req and req.json():
+ reason = req.json()['reason']
+ else:
+ reason = req
+ self.logger.info("cannot create a number: %s", reason)
+ raise Exception('Failed to create a number')
+ except Exception: # pylint: disable=broad-except
+ self.logger.info(
+ "try %s: cannot create a number", iloop + 1)
+ time.sleep(25)
+ raise Exception('Failed to create a number')
- def set_external_network_name(self, external_network_name):
- self.config['external_network_name'] = external_network_name
+ def run_clearwater_live_test(self, dns_ip, public_domain,
+ bono_ip=None, ellis_ip=None,
+ signup_code='secret'):
+ """Run the Clearwater live tests
- def set_public_domain(self, public_domain):
- self.config['public_domain'] = public_domain
+ It first runs dnsmasq to reach clearwater services by FQDN and then the
+ Clearwater live tests. All results are saved in ims_test_output.txt.
- def deploy_vnf(self, blueprint, bp_name='clearwater',
- dep_name='clearwater-opnfv'):
- if self.orchestrator:
- self.dep_name = dep_name
- error = self.orchestrator.download_upload_and_deploy_blueprint(
- blueprint, self.config, bp_name, dep_name)
- if error:
- return error
+ Returns:
+ - a dict containing the overall results
+ - None on error
+ """
+ # pylint: disable=too-many-locals,too-many-arguments
+ self.logger.info('Run Clearwater live test')
+ dns_file = '/etc/resolv.conf'
+ dns_file_bak = '/etc/resolv.conf.bak'
+ self.logger.debug('Backup %s -> %s', dns_file, dns_file_bak)
+ shutil.copy(dns_file, dns_file_bak)
+ cmd = ("dnsmasq -d -u root --server=/clearwater.opnfv/{0} "
+ "-r /etc/resolv.conf.bak".format(dns_ip))
+ dnsmasq_process = subprocess.Popen(shlex.split(cmd))
+ script = ('echo -e "nameserver {0}" > {1};'
+ 'cd {2};'
+ 'rake test[{3}] SIGNUP_CODE={4}'
+ .format('127.0.0.1',
+ dns_file,
+ self.test_dir,
+ public_domain,
+ signup_code))
+ if bono_ip and ellis_ip:
+ subscript = ' PROXY={0} ELLIS={1}'.format(bono_ip, ellis_ip)
+ script = '{0}{1}'.format(script, subscript)
+ script = ('{0}{1}'.format(script, ' --trace'))
+ cmd = "/bin/bash -c '{0}'".format(script)
+ self.logger.debug('Live test cmd: %s', cmd)
+ output_file = os.path.join(self.result_dir, "ims_test_output.txt")
+ ft_utils.execute_command(cmd,
+ error_msg='Clearwater live test failed',
+ output_file=output_file)
+ dnsmasq_process.kill()
+ with open(dns_file_bak, 'r') as bak_file:
+ result = bak_file.read()
+ with open(dns_file, 'w') as dfile:
+ dfile.write(result)
- self.deploy = True
+ with open(output_file, 'r') as ofile:
+ result = ofile.read()
- else:
- if self.logger:
- self.logger.error("Cloudify manager is down or not provide...")
+ if result != "":
+ self.logger.debug(result)
- def undeploy_vnf(self):
- if self.orchestrator:
- if self.deploy:
- self.deploy = False
- self.orchestrator.undeploy_deployment(self.dep_name)
- else:
- if self.logger:
- self.logger.error("Clearwater isn't already deploy...")
- else:
- if self.logger:
- self.logger.error("Cloudify manager is down or not provide...")
+ vims_test_result = {}
+ try:
+ grp = re.search(
+ r'(\d+) failures out of (\d+) tests run.*'
+ r'(\d+) tests skipped', result, re.MULTILINE | re.DOTALL)
+ assert grp
+ vims_test_result["failures"] = int(grp.group(1))
+ vims_test_result["total"] = int(grp.group(2))
+ vims_test_result["skipped"] = int(grp.group(3))
+ vims_test_result['passed'] = (
+ int(grp.group(2)) - int(grp.group(3)) - int(grp.group(1)))
+ except Exception: # pylint: disable=broad-except
+ self.logger.exception("Cannot parse live tests results")
+ return None
+ return vims_test_result
Code Review / functest.git / blobdiff