functest/opnfv_tests/vnf/ims/cloudify_ims.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2016 Orange 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 import json
  11 import os
  12 import requests
  13 import subprocess
  14 import time
  15
  16 import functest.core.vnf_base as vnf_base
  17 import functest.utils.functest_logger as ft_logger
  18 import functest.utils.functest_utils as ft_utils
  19 import functest.utils.openstack_utils as os_utils
  20
  21 from clearwater import Clearwater
  22 from functest.utils.constants import CONST
  23 from orchestrator_cloudify import Orchestrator
  24
  25
  26 class ImsVnf(vnf_base.VnfOnBoardingBase):
  27
  28     def __init__(self, project='functest', case='', repo='', cmd=''):
  29         super(ImsVnf, self).__init__(project, case, repo, cmd)
  30         self.logger = ft_logger.Logger("vIMS").getLogger()
  31         self.case_dir = os.path.join(CONST.functest_test, 'vnf/ims/')
  32         self.data_dir = CONST.dir_vIMS_data
  33         self.test_dir = CONST.dir_repo_vims_test
  34
  35         self.orchestrator = dict(
  36             requirements=CONST.cloudify_requirements,
  37             blueprint=CONST.cloudify_blueprint,
  38             inputs=CONST.cloudify_inputs
  39         )
  40
  41         self.vnf = dict(
  42             blueprint=CONST.clearwater_blueprint,
  43             deployment_name=CONST.clearwater_deployment_name,
  44             inputs=CONST.clearwater_inputs,
  45             requirements=CONST.clearwater_requirements
  46         )
  47
  48         # vIMS Data directory creation
  49         if not os.path.exists(self.data_dir):
  50             os.makedirs(self.data_dir)
  51
  52     def deploy_orchestrator(self, **kwargs):
  53         public_auth_url = os_utils.get_endpoint('identity')
  54
  55         cfy = Orchestrator(self.data_dir, self.orchestrator.inputs)
  56         self.orchestrator.object = cfy
  57
  58         if 'tenant_name' in self.creds.keys():
  59             tenant_name = self.creds['tenant_name']
  60         elif 'project_name' in self.creds.keys():
  61             tenant_name = self.creds['project_name']
  62
  63         cfy.set_credentials(username=self.creds['username'],
  64                             password=self.creds['password'],
  65                             tenant_name=tenant_name,
  66                             auth_url=public_auth_url)
  67
  68         # orchestrator VM flavor
  69         flavor_id = self.get_flavor("m1.large", self.orchestrator.requirements)
  70         if not flavor_id:
  71             self.logger.info("Available flavors are: ")
  72             self.pMsg(self.nova_client.flavor.list())
  73             self.step_failure("Failed to find required flavor"
  74                               "for this deployment")
  75         cfy.set_flavor_id(flavor_id)
  76
  77         # orchestrator VM image
  78         if 'os_image' in self.orchestrator.requirements.keys():
  79             image_id = os_utils.get_image_id(
  80                 self.glance_client, self.orchestrator.requirements['os_image'])
  81             if image_id == '':
  82                 self.step_failure("Failed to find required OS image"
  83                                   " for cloudify manager")
  84         else:
  85             self.step_failure("Failed to find required OS image"
  86                               " for cloudify manager")
  87
  88         cfy.set_image_id(image_id)
  89
  90         ext_net = os_utils.get_external_net(self.neutron_client)
  91         if not ext_net:
  92             self.step_failure("Failed to get external network")
  93
  94         cfy.set_external_network_name(ext_net)
  95
  96         ns = ft_utils.get_resolvconf_ns()
  97         if ns:
  98             cfy.set_nameservers(ns)
  99
 100         if 'compute' in self.nova_client.client.services_url:
 101             cfy.set_nova_url(self.nova_client.client.services_url['compute'])
 102         if self.neutron_client.httpclient.endpoint_url is not None:
 103             cfy.set_neutron_url(self.neutron_client.httpclient.endpoint_url)
 104
 105         self.logger.info("Prepare virtualenv for cloudify-cli")
 106         cmd = "chmod +x " + self.case_dir + "create_venv.sh"
 107         ft_utils.execute_command(cmd)
 108         time.sleep(3)
 109         cmd = self.case_dir + "create_venv.sh " + self.data_dir
 110         ft_utils.execute_command(cmd)
 111
 112         cfy.download_manager_blueprint(self.orchestrator.blueprint['url'],
 113                                        self.orchestrator.blueprint['branch'])
 114
 115         cfy.deploy_manager()
 116         return {'status': 'PASS', 'result': ''}
 117
 118     def deploy_vnf(self):
 119         cw = Clearwater(self.vnf.inputs, self.orchestrator.object, self.logger)
 120         self.vnf.object = cw
 121
 122         self.logger.info("Collect flavor id for all clearwater vm")
 123         flavor_id = self.get_flavor("m1.small", self.vnf.requirements)
 124         if not flavor_id:
 125             self.logger.info("Available flavors are: ")
 126             self.pMsg(self.nova_client.flavor.list())
 127             self.step_failure("Failed to find required flavor"
 128                               " for this deployment")
 129
 130         cw.set_flavor_id(flavor_id)
 131
 132         # VMs image
 133         if 'os_image' in self.vnf.requirements.keys():
 134             image_id = os_utils.get_image_id(
 135                 self.glance_client, self.vnf.requirements['os_image'])
 136             if image_id == '':
 137                 self.step_failure("Failed to find required OS image"
 138                                   " for clearwater VMs")
 139         else:
 140             self.step_failure("Failed to find required OS image"
 141                               " for clearwater VMs")
 142
 143         cw.set_image_id(image_id)
 144
 145         ext_net = os_utils.get_external_net(self.neutron_client)
 146         if not ext_net:
 147             self.step_failure("Failed to get external network")
 148
 149         cw.set_external_network_name(ext_net)
 150
 151         cw.deploy_vnf()
 152         return {'status': 'PASS', 'result': ''}
 153
 154     def test_vnf(self):
 155         script = "source {0}venv_cloudify/bin/activate; "
 156         script += "cd {0}; "
 157         script += "cfy status | grep -Eo \"([0-9]{{1,3}}\.){{3}}[0-9]{{1,3}}\""
 158         cmd = "/bin/bash -c '" + script.format(self.data_dir) + "'"
 159
 160         try:
 161             self.logger.debug("Trying to get clearwater manager IP ... ")
 162             mgr_ip = os.popen(cmd).read()
 163             mgr_ip = mgr_ip.splitlines()[0]
 164         except:
 165             self.step_failure("Unable to retrieve the IP of the "
 166                               "cloudify manager server !")
 167
 168         api_url = "http://" + mgr_ip + "/api/v2"
 169         dep_outputs = requests.get(api_url + "/deployments/" +
 170                                    self.vnf.deployment_name + "/outputs")
 171         dns_ip = dep_outputs.json()['outputs']['dns_ip']
 172         ellis_ip = dep_outputs.json()['outputs']['ellis_ip']
 173
 174         ellis_url = "http://" + ellis_ip + "/"
 175         url = ellis_url + "accounts"
 176
 177         params = {"password": "functest",
 178                   "full_name": "opnfv functest user",
 179                   "email": "functest@opnfv.fr",
 180                   "signup_code": "secret"}
 181
 182         rq = requests.post(url, data=params)
 183         i = 20
 184         while rq.status_code != 201 and i > 0:
 185             rq = requests.post(url, data=params)
 186             i = i - 1
 187             time.sleep(10)
 188
 189         if rq.status_code == 201:
 190             url = ellis_url + "session"
 191             rq = requests.post(url, data=params)
 192             cookies = rq.cookies
 193
 194         url = ellis_url + "accounts/" + params['email'] + "/numbers"
 195         if cookies != "":
 196             rq = requests.post(url, cookies=cookies)
 197             i = 24
 198             while rq.status_code != 200 and i > 0:
 199                 rq = requests.post(url, cookies=cookies)
 200                 i = i - 1
 201                 time.sleep(25)
 202
 203         if rq.status_code != 200:
 204             self.step_failure("Unable to create a number: %s"
 205                               % rq.json()['reason'])
 206
 207         nameservers = ft_utils.get_resolvconf_ns()
 208         resolvconf = ""
 209         for ns in nameservers:
 210             resolvconf += "\nnameserver " + ns
 211
 212         if dns_ip != "":
 213             script = ('echo -e "nameserver ' + dns_ip + resolvconf +
 214                       '" > /etc/resolv.conf; ')
 215             script += 'source /etc/profile.d/rvm.sh; '
 216             script += 'cd {0}; '
 217             script += ('rake test[{1}] SIGNUP_CODE="secret"')
 218
 219             cmd = ("/bin/bash -c '" +
 220                    script.format(self.data_dir, self.inputs["public_domain"]) +
 221                    "'")
 222             output_file = "output.txt"
 223             f = open(output_file, 'w+')
 224             subprocess.call(cmd, shell=True, stdout=f,
 225                             stderr=subprocess.STDOUT)
 226             f.close()
 227
 228             f = open(output_file, 'r')
 229             result = f.read()
 230             if result != "":
 231                 self.logger.debug(result)
 232
 233             vims_test_result = ""
 234             tempFile = os.path.join(self.test_dir, "temp.json")
 235             try:
 236                 self.logger.debug("Trying to load test results")
 237                 with open(tempFile) as f:
 238                     vims_test_result = json.load(f)
 239                 f.close()
 240             except:
 241                 self.logger.error("Unable to retrieve test results")
 242
 243             try:
 244                 os.remove(tempFile)
 245             except:
 246                 self.logger.error("Deleting file failed")
 247
 248             if vims_test_result != '':
 249                 return {'status': 'PASS', 'result': vims_test_result}
 250             else:
 251                 return {'status': 'FAIL', 'result': ''}
 252
 253     def clean(self):
 254         self.vnf.object.undeploy_vnf()
 255         self.orchestrator.object.undeploy_manager()
 256         super(ImsVnf, self).clean()
 257
 258     def get_flavor(self, flavor_name, requirements):
 259         try:
 260             flavor_id = os_utils.get_flavor_id(self.nova_client, flavor_name)
 261             if 'ram_min' in requirements.keys():
 262                 flavor_id = os_utils.get_flavor_id_by_ram_range(
 263                     self.nova_client, requirements['ram_min'], 7500)
 264
 265             if flavor_id == '':
 266                 self.logger.error(
 267                     "Failed to find %s flavor. "
 268                     "Try with ram range default requirement !" % flavor_name)
 269                 flavor_id = os_utils.get_flavor_id_by_ram_range(
 270                                     self.nova_client,
 271                                     4000, 10000)
 272             return flavor_id
 273         except:
 274             self.logger.error("Flavor '%s' not found." % self.flavor_name)
 275             self.logger.info("Available flavors are: ")
 276             self.pMsg(self.nova_client.flavor.list())
 277             return None