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 os
  11 import shutil
  12
  13 import requests
  14
  15 import functest.core.vnf_base as vnf_base
  16 from functest.utils.constants import CONST
  17 import functest.utils.functest_logger as ft_logger
  18 import functest.utils.functest_utils as ft_utils
  19
  20
  21 class ClearwaterOnBoardingBase(vnf_base.VnfOnBoardingBase):
  22
  23     def __init__(self, project='functest', case='', repo='', cmd=''):
  24         self.logger = ft_logger.Logger(__name__).getLogger()
  25         super(ClearwaterOnBoardingBase, self).__init__(
  26             project, case, repo, cmd)
  27         self.case_dir = os.path.join(CONST.dir_functest_test, 'vnf', 'ims')
  28         self.data_dir = CONST.dir_ims_data
  29         self.result_dir = os.path.join(CONST.dir_results, case)
  30         self.test_dir = CONST.dir_repo_vims_test
  31
  32         if not os.path.exists(self.data_dir):
  33             os.makedirs(self.data_dir)
  34         if not os.path.exists(self.result_dir):
  35             os.makedirs(self.result_dir)
  36
  37     def config_ellis(self, ellis_ip, signup_code='secret', two_numbers=False):
  38         output_dict = {}
  39         self.logger.info('Configure Ellis: %s', ellis_ip)
  40         output_dict['ellis_ip'] = ellis_ip
  41         account_url = 'http://{0}/accounts'.format(ellis_ip)
  42         params = {"password": "functest",
  43                   "full_name": "opnfv functest user",
  44                   "email": "functest@opnfv.org",
  45                   "signup_code": signup_code}
  46         rq = requests.post(account_url, data=params)
  47         output_dict['login'] = params
  48         if rq.status_code != 201 and rq.status_code != 409:
  49             raise Exception("Unable to create an account for number"
  50                             " provision: %s" % rq.json()['reason'])
  51         self.logger.info('Account is created on Ellis: %s', params)
  52
  53         session_url = 'http://{0}/session'.format(ellis_ip)
  54         session_data = {
  55             'username': params['email'],
  56             'password': params['password'],
  57             'email': params['email']
  58         }
  59         rq = requests.post(session_url, data=session_data)
  60         if rq.status_code != 201:
  61             raise Exception('Failed to get cookie for Ellis')
  62         cookies = rq.cookies
  63         self.logger.info('Cookies: %s' % cookies)
  64
  65         number_url = 'http://{0}/accounts/{1}/numbers'.format(
  66                      ellis_ip,
  67                      params['email'])
  68         self.logger.info('Create 1st calling number on Ellis')
  69         number_res = self.create_ellis_number(number_url, cookies)
  70         output_dict['number'] = number_res
  71
  72         if two_numbers:
  73             self.logger.info('Create 2nd calling number on Ellis')
  74             number_res = self.create_ellis_number(number_url, cookies)
  75             output_dict['number2'] = number_res
  76
  77         return output_dict
  78
  79     def create_ellis_number(self, number_url, cookies):
  80         rq = requests.post(number_url, cookies=cookies)
  81
  82         if rq.status_code != 200:
  83             if rq and rq.json():
  84                 reason = rq.json()['reason']
  85             else:
  86                 reason = rq
  87             raise Exception("Unable to create a number: %s" % reason)
  88         number_res = rq.json()
  89         self.logger.info('Calling number is created: %s', number_res)
  90         return number_res
  91
  92     def run_clearwater_live_test(self, dns_ip, public_domain,
  93                                  bono_ip=None, ellis_ip=None,
  94                                  signup_code='secret'):
  95         self.logger.info('Run Clearwater live test')
  96         nameservers = ft_utils.get_resolvconf_ns()
  97         resolvconf = ['{0}{1}{2}'.format(os.linesep, 'nameserver ', ns)
  98                       for ns in nameservers]
  99         self.logger.debug('resolvconf: %s', resolvconf)
 100         dns_file = '/etc/resolv.conf'
 101         dns_file_bak = '/etc/resolv.conf.bak'
 102         shutil.copy(dns_file, dns_file_bak)
 103         script = ('echo -e "nameserver {0}{1}" > {2};'
 104                   'source /etc/profile.d/rvm.sh;'
 105                   'cd {3};'
 106                   'rake test[{4}] SIGNUP_CODE={5}'
 107                   .format(dns_ip,
 108                           ''.join(resolvconf),
 109                           dns_file,
 110                           self.test_dir,
 111                           public_domain,
 112                           signup_code))
 113         if bono_ip and ellis_ip:
 114             subscript = ' PROXY={0} ELLIS={1}'.format(bono_ip, ellis_ip)
 115             script = '{0}{1}'.format(script, subscript)
 116         script = ('{0}{1}'.format(script, ' --trace'))
 117         cmd = "/bin/bash -c '{0}'".format(script)
 118         self.logger.info('Live test cmd: %s', cmd)
 119         output_file = os.path.join(self.result_dir, "ims_test_output.txt")
 120         ft_utils.execute_command(cmd,
 121                                  error_msg='Clearwater live test failed',
 122                                  output_file=output_file)
 123
 124         with open(dns_file_bak, 'r') as bak_file:
 125             result = bak_file.read()
 126             with open(dns_file, 'w') as f:
 127                 f.write(result)
 128
 129         f = open(output_file, 'r')
 130         result = f.read()
 131         if result != "":
 132             self.logger.debug(result)
 133
 134         vims_test_result = ""
 135         tempFile = os.path.join(self.test_dir, "temp.json")
 136         try:
 137             self.logger.debug("Trying to load test results")
 138             with open(tempFile) as f:
 139                 vims_test_result = json.load(f)
 140             f.close()
 141         except Exception:
 142             self.logger.error("Unable to retrieve test results")
 143
 144         try:
 145             os.remove(tempFile)
 146         except Exception:
 147             self.logger.error("Deleting file failed")
 148
 149         return vims_test_result