functest/opnfv_tests/vnf/ims/clearwater_ims_base.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (c) 2017 All rights reserved
   4 # This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 #
   8 # http://www.apache.org/licenses/LICENSE-2.0
   9 import json
  10 import logging
  11 import os
  12 import pkg_resources
  13 import shutil
  14 import time
  15
  16 import requests
  17
  18 import functest.core.vnf as vnf
  19 from functest.utils.constants import CONST
  20 import functest.utils.functest_utils as ft_utils
  21
  22 __author__ = ("Valentin Boucher <valentin.boucher@orange.com>, "
  23               "Helen Yao <helanyao@gmail.com>")
  24
  25
  26 class ClearwaterOnBoardingBase(vnf.VnfOnBoarding):
  27     """ vIMS clearwater base usable by several orchestrators"""
  28
  29     def __init__(self, **kwargs):
  30         self.logger = logging.getLogger(__name__)
  31         super(ClearwaterOnBoardingBase, self).__init__(**kwargs)
  32         self.case_dir = pkg_resources.resource_filename(
  33             'functest', 'opnfv_tests/vnf/ims')
  34         self.data_dir = CONST.__getattribute__('dir_ims_data')
  35         self.result_dir = os.path.join(CONST.__getattribute__('dir_results'),
  36                                        self.case_name)
  37         self.test_dir = CONST.__getattribute__('dir_repo_vims_test')
  38
  39         if not os.path.exists(self.data_dir):
  40             os.makedirs(self.data_dir)
  41         if not os.path.exists(self.result_dir):
  42             os.makedirs(self.result_dir)
  43
  44     def config_ellis(self, ellis_ip, signup_code='secret', two_numbers=False):
  45         output_dict = {}
  46         self.logger.debug('Configure Ellis: %s', ellis_ip)
  47         output_dict['ellis_ip'] = ellis_ip
  48         account_url = 'http://{0}/accounts'.format(ellis_ip)
  49         params = {"password": "functest",
  50                   "full_name": "opnfv functest user",
  51                   "email": "functest@opnfv.org",
  52                   "signup_code": signup_code}
  53         rq = requests.post(account_url, data=params)
  54         output_dict['login'] = params
  55         if rq.status_code != 201 and rq.status_code != 409:
  56             raise Exception("Unable to create an account for number provision")
  57         self.logger.debug('Account is created on Ellis: %s', params)
  58
  59         session_url = 'http://{0}/session'.format(ellis_ip)
  60         session_data = {
  61             'username': params['email'],
  62             'password': params['password'],
  63             'email': params['email']
  64         }
  65         rq = requests.post(session_url, data=session_data)
  66         if rq.status_code != 201:
  67             raise Exception('Failed to get cookie for Ellis')
  68         cookies = rq.cookies
  69         self.logger.debug('Cookies: %s', cookies)
  70
  71         number_url = 'http://{0}/accounts/{1}/numbers'.format(
  72                      ellis_ip,
  73                      params['email'])
  74         self.logger.debug('Create 1st calling number on Ellis')
  75         i = 30
  76         while rq.status_code != 200 and i > 0:
  77             try:
  78                 number_res = self.create_ellis_number(number_url, cookies)
  79                 break
  80             except:
  81                 if i == 1:
  82                     raise Exception("Unable to create a number")
  83                 self.logger.warn("Unable to create a number. Retry ..")
  84                 time.sleep(25)
  85             i = i - 1
  86         output_dict['number'] = number_res
  87
  88         if two_numbers:
  89             self.logger.debug('Create 2nd calling number on Ellis')
  90             number_res = self.create_ellis_number(number_url, cookies)
  91             output_dict['number2'] = number_res
  92
  93         return output_dict
  94
  95     def create_ellis_number(self, number_url, cookies):
  96         rq = requests.post(number_url, cookies=cookies)
  97
  98         if rq.status_code != 200:
  99             if rq and rq.json():
 100                 reason = rq.json()['reason']
 101             else:
 102                 reason = rq
 103             raise Exception("Unable to create a number: %s" % reason)
 104         number_res = rq.json()
 105         self.logger.info('Calling number is created: %s', number_res)
 106         return number_res
 107
 108     def run_clearwater_live_test(self, dns_ip, public_domain,
 109                                  bono_ip=None, ellis_ip=None,
 110                                  signup_code='secret'):
 111         self.logger.info('Run Clearwater live test')
 112         nameservers = ft_utils.get_resolvconf_ns()
 113         resolvconf = ['{0}{1}{2}'.format(os.linesep, 'nameserver ', ns)
 114                       for ns in nameservers]
 115         self.logger.debug('resolvconf: %s', resolvconf)
 116         dns_file = '/etc/resolv.conf'
 117         dns_file_bak = '/etc/resolv.conf.bak'
 118         shutil.copy(dns_file, dns_file_bak)
 119         script = ('echo -e "nameserver {0}{1}" > {2};'
 120                   'source /etc/profile.d/rvm.sh;'
 121                   'cd {3};'
 122                   'rake test[{4}] SIGNUP_CODE={5}'
 123                   .format(dns_ip,
 124                           ''.join(resolvconf),
 125                           dns_file,
 126                           self.test_dir,
 127                           public_domain,
 128                           signup_code))
 129         if bono_ip and ellis_ip:
 130             subscript = ' PROXY={0} ELLIS={1}'.format(bono_ip, ellis_ip)
 131             script = '{0}{1}'.format(script, subscript)
 132         script = ('{0}{1}'.format(script, ' --trace'))
 133         cmd = "/bin/bash -c '{0}'".format(script)
 134         self.logger.debug('Live test cmd: %s', cmd)
 135         output_file = os.path.join(self.result_dir, "ims_test_output.txt")
 136         ft_utils.execute_command(cmd,
 137                                  error_msg='Clearwater live test failed',
 138                                  output_file=output_file)
 139
 140         with open(dns_file_bak, 'r') as bak_file:
 141             result = bak_file.read()
 142             with open(dns_file, 'w') as f:
 143                 f.write(result)
 144
 145         f = open(output_file, 'r')
 146         result = f.read()
 147         if result != "":
 148             self.logger.debug(result)
 149
 150         vims_test_result = ""
 151         tempFile = os.path.join(self.test_dir, "temp.json")
 152         try:
 153             self.logger.debug("Trying to load test results")
 154             with open(tempFile) as f:
 155                 vims_test_result = json.load(f)
 156             f.close()
 157         except Exception:
 158             self.logger.error("Unable to retrieve test results")
 159
 160         try:
 161             os.remove(tempFile)
 162         except Exception:
 163             self.logger.error("Deleting file failed")
 164
 165         return vims_test_result