utils/functest_utils.py

   1 #!/usr/bin/env python
   2 #
   3 # jose.lausuch@ericsson.com
   4 # valentin.boucher@orange.com
   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
  11 """ global variables """
  12
  13 from datetime import datetime as dt
  14 import json
  15 import os
  16 import os.path
  17 import re
  18 import shutil
  19 import socket
  20 import subprocess
  21 import sys
  22 import urllib2
  23
  24 import functest.ci.tier_builder as tb
  25 from git import Repo
  26 import requests
  27 import yaml
  28
  29
  30 REPOS_DIR = os.getenv('repos_dir')
  31 FUNCTEST_REPO = ("%s/functest/" % REPOS_DIR)
  32
  33
  34 # ----------------------------------------------------------
  35 #
  36 #               INTERNET UTILS
  37 #
  38 # -----------------------------------------------------------
  39 def check_internet_connectivity(url='http://www.opnfv.org/'):
  40     """
  41     Check if there is access to the internet
  42     """
  43     try:
  44         urllib2.urlopen(url, timeout=5)
  45         return True
  46     except urllib2.URLError:
  47         return False
  48
  49
  50 def download_url(url, dest_path):
  51     """
  52     Download a file to a destination path given a URL
  53     """
  54     name = url.rsplit('/')[-1]
  55     dest = dest_path + "/" + name
  56     try:
  57         response = urllib2.urlopen(url)
  58     except (urllib2.HTTPError, urllib2.URLError):
  59         return False
  60
  61     with open(dest, 'wb') as f:
  62         shutil.copyfileobj(response, f)
  63     return True
  64
  65
  66 # ----------------------------------------------------------
  67 #
  68 #               CI UTILS
  69 #
  70 # -----------------------------------------------------------
  71 def get_git_branch(repo_path):
  72     """
  73     Get git branch name
  74     """
  75     repo = Repo(repo_path)
  76     branch = repo.active_branch
  77     return branch.name
  78
  79
  80 def get_installer_type(logger=None):
  81     """
  82     Get installer type (fuel, apex, joid, compass)
  83     """
  84     try:
  85         installer = os.environ['INSTALLER_TYPE']
  86     except KeyError:
  87         if logger:
  88             logger.error("Impossible to retrieve the installer type")
  89         installer = "Unknown_installer"
  90
  91     return installer
  92
  93
  94 def get_scenario(logger=None):
  95     """
  96     Get scenario
  97     """
  98     try:
  99         scenario = os.environ['DEPLOY_SCENARIO']
 100     except KeyError:
 101         if logger:
 102             logger.error("Impossible to retrieve the scenario")
 103         scenario = "Unknown_scenario"
 104
 105     return scenario
 106
 107
 108 def get_version(logger=None):
 109     """
 110     Get version
 111     """
 112     # Use the build tag to retrieve the version
 113     # By default version is unknown
 114     # if launched through CI the build tag has the following format
 115     # jenkins-<project>-<installer>-<pod>-<job>-<branch>-<id>
 116     # e.g. jenkins-functest-fuel-opnfv-jump-2-daily-master-190
 117     # use regex to match branch info
 118     rule = "daily-(.+?)-[0-9]*"
 119     build_tag = get_build_tag(logger)
 120     m = re.search(rule, build_tag)
 121     if m:
 122         return m.group(1)
 123     else:
 124         return "unknown"
 125
 126
 127 def get_pod_name(logger=None):
 128     """
 129     Get PoD Name from env variable NODE_NAME
 130     """
 131     try:
 132         return os.environ['NODE_NAME']
 133     except KeyError:
 134         if logger:
 135             logger.error(
 136                 "Unable to retrieve the POD name from environment. " +
 137                 "Using pod name 'unknown-pod'")
 138         return "unknown-pod"
 139
 140
 141 def get_build_tag(logger=None):
 142     """
 143     Get build tag of jenkins jobs
 144     """
 145     try:
 146         build_tag = os.environ['BUILD_TAG']
 147     except KeyError:
 148         if logger:
 149             logger.error("Impossible to retrieve the build tag")
 150         build_tag = "unknown_build_tag"
 151
 152     return build_tag
 153
 154
 155 def get_db_url(logger=None):
 156     """
 157     Returns DB URL
 158     """
 159     with open(os.environ["CONFIG_FUNCTEST_YAML"]) as f:
 160         functest_yaml = yaml.safe_load(f)
 161     f.close()
 162     db_url = functest_yaml.get("results").get("test_db_url")
 163     return db_url
 164
 165
 166 def logger_test_results(logger, project, case_name, status, details):
 167     pod_name = get_pod_name(logger)
 168     scenario = get_scenario(logger)
 169     version = get_version(logger)
 170     build_tag = get_build_tag(logger)
 171
 172     logger.info("Pushing %(p)s/%(n)s results: TEST_DB_URL=%(db)s "
 173                 "pod_name=%(pod)s version=%(v)s scenario=%(s)s "
 174                 "criteria=%(c)s details=%(d)s" % {
 175                     'p': project,
 176                     'n': case_name,
 177                     'db': get_db_url(),
 178                     'pod': pod_name,
 179                     'v': version,
 180                     's': scenario,
 181                     'c': status,
 182                     'b': build_tag,
 183                     'd': details,
 184                 })
 185
 186
 187 def push_results_to_db(project, case_name, logger,
 188                        start_date, stop_date, criteria, details):
 189     """
 190     POST results to the Result target DB
 191     """
 192     # Retrieve params from CI and conf
 193     url = get_db_url(logger) + "/results"
 194     installer = get_installer_type(logger)
 195     scenario = get_scenario(logger)
 196     version = get_version(logger)
 197     pod_name = get_pod_name(logger)
 198     build_tag = get_build_tag(logger)
 199     test_start = dt.fromtimestamp(start_date).strftime('%Y-%m-%d %H:%M:%S')
 200     test_stop = dt.fromtimestamp(stop_date).strftime('%Y-%m-%d %H:%M:%S')
 201
 202     params = {"project_name": project, "case_name": case_name,
 203               "pod_name": pod_name, "installer": installer,
 204               "version": version, "scenario": scenario, "criteria": criteria,
 205               "build_tag": build_tag, "start_date": test_start,
 206               "stop_date": test_stop, "details": details}
 207
 208     headers = {'Content-Type': 'application/json'}
 209     try:
 210         r = requests.post(url, data=json.dumps(params), headers=headers)
 211         if logger:
 212             logger.debug(r)
 213         return True
 214     except Exception, e:
 215         print ("Error [push_results_to_db('%s', '%s', '%s', " +
 216                "'%s', '%s', '%s', '%s', '%s', '%s')]:" %
 217                (url, project, case_name, pod_name, version,
 218                 scenario, criteria, build_tag, details)), e
 219         return False
 220
 221
 222 def get_resolvconf_ns():
 223     """
 224     Get nameservers from current resolv.conf
 225     """
 226     nameservers = []
 227     rconf = open("/etc/resolv.conf", "r")
 228     line = rconf.readline()
 229     while line:
 230         ip = re.search(r"\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b", line)
 231         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 232         if ip:
 233             result = sock.connect_ex((ip.group(), 53))
 234             if result == 0:
 235                 nameservers.append(ip.group())
 236         line = rconf.readline()
 237     return nameservers
 238
 239
 240 def get_ci_envvars():
 241     """
 242     Get the CI env variables
 243     """
 244     ci_env_var = {
 245         "installer": os.environ.get('INSTALLER_TYPE'),
 246         "scenario": os.environ.get('DEPLOY_SCENARIO')}
 247     return ci_env_var
 248
 249
 250 def execute_command(cmd, logger=None,
 251                     exit_on_error=True,
 252                     info=False,
 253                     error_msg="",
 254                     verbose=True):
 255     if not error_msg:
 256         error_msg = ("The command '%s' failed." % cmd)
 257     msg_exec = ("Executing command: '%s'" % cmd)
 258     if verbose:
 259         if logger:
 260             if info:
 261                 logger.info(msg_exec)
 262             else:
 263                 logger.debug(msg_exec)
 264         else:
 265             print(msg_exec)
 266     p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
 267     for line in iter(p.stdout.readline, b''):
 268         line = line.replace('\n', '')
 269         if logger:
 270             if info:
 271                 logger.info(line)
 272             else:
 273                 logger.debug(line)
 274         else:
 275             print line
 276     p.stdout.close()
 277     returncode = p.wait()
 278     if returncode != 0:
 279         if verbose:
 280             if logger:
 281                 logger.error(error_msg)
 282             else:
 283                 print(error_msg)
 284         if exit_on_error:
 285             sys.exit(1)
 286
 287     return returncode
 288
 289
 290 def get_deployment_dir(logger=None):
 291     """
 292     Returns current Rally deployment directory
 293     """
 294     with open(os.environ["CONFIG_FUNCTEST_YAML"]) as f:
 295         functest_yaml = yaml.safe_load(f)
 296     f.close()
 297     deployment_name = functest_yaml.get("rally").get("deployment_name")
 298     rally_dir = functest_yaml.get("general").get("directories").get(
 299         "dir_rally_inst")
 300     cmd = ("rally deployment list | awk '/" + deployment_name +
 301            "/ {print $2}'")
 302     p = subprocess.Popen(cmd, shell=True,
 303                          stdout=subprocess.PIPE,
 304                          stderr=subprocess.STDOUT)
 305     deployment_uuid = p.stdout.readline().rstrip()
 306     if deployment_uuid == "":
 307         if logger:
 308             logger.error("Rally deployment not found.")
 309         exit(-1)
 310     deployment_dir = (rally_dir + "/tempest/for-deployment-" +
 311                       deployment_uuid)
 312     return deployment_dir
 313
 314
 315 def get_criteria_by_test(testname):
 316     criteria = ""
 317     file = FUNCTEST_REPO + "/ci/testcases.yaml"
 318     tiers = tb.TierBuilder("", "", file)
 319     for tier in tiers.get_tiers():
 320         for test in tier.get_tests():
 321             if test.get_name() == testname:
 322                 criteria = test.get_criteria()
 323
 324     return criteria
 325
 326
 327 # ----------------------------------------------------------
 328 #
 329 #               YAML UTILS
 330 #
 331 # -----------------------------------------------------------
 332 def get_parameter_from_yaml(parameter, file=None):
 333     """
 334     Returns the value of a given parameter in config_functest.yaml
 335     parameter must be given in string format with dots
 336     Example: general.openstack.image_name
 337     """
 338     if file is None:
 339         file = os.environ["CONFIG_FUNCTEST_YAML"]
 340     with open(file) as f:
 341         functest_yaml = yaml.safe_load(f)
 342     f.close()
 343     value = functest_yaml
 344     for element in parameter.split("."):
 345         value = value.get(element)
 346         if value is None:
 347             raise ValueError("The parameter %s is not defined in"
 348                              " config_functest.yaml" % parameter)
 349     return value
 350
 351
 352 def check_success_rate(case_name, success_rate):
 353     success_rate = float(success_rate)
 354     criteria = get_criteria_by_test(case_name)
 355
 356     def get_value(op):
 357         return float(criteria.split(op)[1].rstrip('%'))
 358
 359     status = 'FAIL'
 360     ops = ['==', '>=']
 361     for op in ops:
 362         if op in criteria:
 363             c_value = get_value(op)
 364             if eval("%s %s %s" % (success_rate, op, c_value)):
 365                 status = 'PASS'
 366             break
 367
 368     return status