testcases/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
  12 import os
  13 import urllib2
  14 import subprocess
  15 import sys
  16 import requests
  17 import json
  18 from git import Repo
  19
  20
  21 # ############ CREDENTIALS OPENSTACK #############
  22 def check_credentials():
  23     """
  24     Check if the OpenStack credentials (openrc) are sourced
  25     """
  26     env_vars = ['OS_AUTH_URL','OS_USERNAME','OS_PASSWORD','OS_TENANT_NAME']
  27     return all(map(lambda v: v in os.environ and os.environ[v], env_vars))
  28
  29
  30 def get_credentials(service):
  31     """Returns a creds dictionary filled with the following keys:
  32     * username
  33     * password/api_key (depending on the service)
  34     * tenant_name/project_id (depending on the service)
  35     * auth_url
  36     :param service: a string indicating the name of the service
  37                     requesting the credentials.
  38     """
  39     creds = {}
  40     # Unfortunately, each of the OpenStack client will request slightly
  41     # different entries in their credentials dict.
  42     if service.lower() in ("nova", "cinder"):
  43         password = "api_key"
  44         tenant = "project_id"
  45     else:
  46         password = "password"
  47         tenant = "tenant_name"
  48
  49     # The most common way to pass these info to the script is to do it through
  50     # environment variables.
  51     creds.update({
  52         "username": os.environ.get('OS_USERNAME', "admin"),
  53         password: os.environ.get("OS_PASSWORD", 'admin'),
  54         "auth_url": os.environ.get("OS_AUTH_URL",
  55                                    "http://192.168.20.71:5000/v2.0"),
  56         tenant: os.environ.get("OS_TENANT_NAME", "admin"),
  57     })
  58
  59     return creds
  60
  61
  62 # ################ NOVA #################
  63 def get_instance_status(nova_client, instance):
  64     try:
  65         instance = nova_client.servers.get(instance.id)
  66         return instance.status
  67     except:
  68         return None
  69
  70
  71 def get_instance_by_name(nova_client, instance_name):
  72     try:
  73         instance = nova_client.servers.find(name=instance_name)
  74         return instance
  75     except:
  76         return None
  77
  78
  79 def get_flavor_id(nova_client, flavor_name):
  80     flavors = nova_client.flavors.list(detailed=True)
  81     id = ''
  82     for f in flavors:
  83         if f.name == flavor_name:
  84             id = f.id
  85             break
  86     return id
  87
  88
  89 def get_flavor_id_by_ram_range(nova_client, min_ram, max_ram):
  90     flavors = nova_client.flavors.list(detailed=True)
  91     id = ''
  92     for f in flavors:
  93         if min_ram <= f.ram and f.ram <= max_ram:
  94             id = f.id
  95             break
  96     return id
  97
  98
  99 # ################ NEUTRON #################
 100 def create_neutron_net(neutron_client, name):
 101     json_body = {'network': {'name': name,
 102                              'admin_state_up': True}}
 103     try:
 104         network = neutron_client.create_network(body=json_body)
 105         network_dict = network['network']
 106         return network_dict['id']
 107     except:
 108         print "Error:", sys.exc_info()[0]
 109         return False
 110
 111
 112 def delete_neutron_net(neutron_client, network_id):
 113     try:
 114         neutron_client.delete_network(network_id)
 115         return True
 116     except:
 117         print "Error:", sys.exc_info()[0]
 118         return False
 119
 120
 121 def create_neutron_subnet(neutron_client, name, cidr, net_id):
 122     json_body = {'subnets': [{'name': name, 'cidr': cidr,
 123                              'ip_version': 4, 'network_id': net_id}]}
 124     try:
 125         subnet = neutron_client.create_subnet(body=json_body)
 126         return subnet['subnets'][0]['id']
 127     except:
 128         print "Error:", sys.exc_info()[0]
 129         return False
 130
 131
 132 def delete_neutron_subnet(neutron_client, subnet_id):
 133     try:
 134         neutron_client.delete_subnet(subnet_id)
 135         return True
 136     except:
 137         print "Error:", sys.exc_info()[0]
 138         return False
 139
 140
 141 def create_neutron_router(neutron_client, name):
 142     json_body = {'router': {'name': name, 'admin_state_up': True}}
 143     try:
 144         router = neutron_client.create_router(json_body)
 145         return router['router']['id']
 146     except:
 147         print "Error:", sys.exc_info()[0]
 148         return False
 149
 150
 151 def delete_neutron_router(neutron_client, router_id):
 152     json_body = {'router': {'id': router_id}}
 153     try:
 154         neutron_client.delete_router(router=router_id)
 155         return True
 156     except:
 157         print "Error:", sys.exc_info()[0]
 158         return False
 159
 160
 161 def add_interface_router(neutron_client, router_id, subnet_id):
 162     json_body = {"subnet_id": subnet_id}
 163     try:
 164         neutron_client.add_interface_router(router=router_id, body=json_body)
 165         return True
 166     except:
 167         print "Error:", sys.exc_info()[0]
 168         return False
 169
 170
 171 def remove_interface_router(neutron_client, router_id, subnet_id):
 172     json_body = {"subnet_id": subnet_id}
 173     try:
 174         neutron_client.remove_interface_router(router=router_id,
 175                                                body=json_body)
 176         return True
 177     except:
 178         print "Error:", sys.exc_info()[0]
 179         return False
 180
 181
 182 def create_neutron_port(neutron_client, name, network_id, ip):
 183     json_body = {'port': {
 184                  'admin_state_up': True,
 185                  'name': name,
 186                  'network_id': network_id,
 187                  'fixed_ips': [{"ip_address": ip}]
 188                  }}
 189     try:
 190         port = neutron_client.create_port(body=json_body)
 191         return port['port']['id']
 192     except:
 193         print "Error:", sys.exc_info()[0]
 194         return False
 195
 196
 197 def delete_neutron_port(neutron_client, port_id):
 198     try:
 199         neutron_client.delete_port(port_id)
 200         return True
 201     except:
 202         print "Error:", sys.exc_info()[0]
 203         return False
 204
 205
 206 def get_network_id(neutron_client, network_name):
 207     networks = neutron_client.list_networks()['networks']
 208     id = ''
 209     for n in networks:
 210         if n['name'] == network_name:
 211             id = n['id']
 212             break
 213     return id
 214
 215
 216 def check_neutron_net(neutron_client, net_name):
 217     for network in neutron_client.list_networks()['networks']:
 218         if network['name'] == net_name:
 219             for subnet in network['subnets']:
 220                 return True
 221     return False
 222
 223
 224 def get_network_list(neutron_client):
 225     network_list = neutron_client.list_networks()['networks']
 226     if len(network_list) == 0:
 227         return None
 228     else:
 229         return network_list
 230
 231
 232 def get_external_net(neutron_client):
 233     for network in neutron_client.list_networks()['networks']:
 234         if network['router:external']:
 235             return network['name']
 236     return False
 237
 238
 239 def update_sg_quota(neutron_client, tenant_id, sg_quota, sg_rule_quota):
 240     json_body = {"quota": {
 241         "security_group": sg_quota,
 242         "security_group_rule": sg_rule_quota
 243     }}
 244
 245     try:
 246         quota = neutron_client.update_quota(tenant_id=tenant_id,
 247                                             body=json_body)
 248         return True
 249     except:
 250         print "Error:", sys.exc_info()[0]
 251         return False
 252
 253 # ################ GLANCE #################
 254
 255
 256 def get_image_id(glance_client, image_name):
 257     images = glance_client.images.list()
 258     id = ''
 259     for i in images:
 260         if i.name == image_name:
 261             id = i.id
 262             break
 263     return id
 264
 265
 266 def create_glance_image(glance_client, image_name, file_path, is_public=True):
 267     try:
 268         with open(file_path) as fimage:
 269             image = glance_client.images.create(name=image_name,
 270                                                 is_public=is_public,
 271                                                 disk_format="qcow2",
 272                                                 container_format="bare",
 273                                                 data=fimage)
 274         return image.id
 275     except:
 276         return False
 277
 278
 279 # ################ KEYSTONE #################
 280 def get_tenant_id(keystone_client, tenant_name):
 281     tenants = keystone_client.tenants.list()
 282     id = ''
 283     for t in tenants:
 284         if t.name == tenant_name:
 285             id = t.id
 286             break
 287     return id
 288
 289
 290 def get_role_id(keystone_client, role_name):
 291     roles = keystone_client.roles.list()
 292     id = ''
 293     for r in roles:
 294         if r.name == role_name:
 295             id = r.id
 296             break
 297     return id
 298
 299
 300 def get_user_id(keystone_client, user_name):
 301     users = keystone_client.users.list()
 302     id = ''
 303     for u in users:
 304         if u.name == user_name:
 305             id = u.id
 306             break
 307     return id
 308
 309
 310 def create_tenant(keystone_client, tenant_name, tenant_description):
 311     try:
 312         tenant = keystone_client.tenants.create(tenant_name,
 313                                                 tenant_description,
 314                                                 enabled=True)
 315         return tenant.id
 316     except:
 317         print "Error:", sys.exc_info()[0]
 318         return False
 319
 320
 321 def delete_tenant(keystone_client, tenant_id):
 322     try:
 323         tenant = keystone_client.tenants.delete(tenant_id)
 324         return True
 325     except:
 326         print "Error:", sys.exc_info()[0]
 327         return False
 328
 329
 330 def create_user(keystone_client, user_name, user_password,
 331                 user_email, tenant_id):
 332     try:
 333         user = keystone_client.users.create(user_name, user_password,
 334                                             user_email, tenant_id,
 335                                             enabled=True)
 336         return user.id
 337     except:
 338         print "Error:", sys.exc_info()[0]
 339         return False
 340
 341
 342 def delete_user(keystone_client, user_id):
 343     try:
 344         tenant = keystone_client.users.delete(user_id)
 345         return True
 346     except:
 347         print "Error:", sys.exc_info()[0]
 348         return False
 349
 350
 351 def add_role_user(keystone_client, user_id, role_id, tenant_id):
 352     try:
 353         keystone_client.roles.add_user_role(user_id, role_id, tenant_id)
 354         return True
 355     except:
 356         print "Error:", sys.exc_info()[0]
 357         return False
 358
 359
 360 # ################ UTILS #################
 361 def check_internet_connectivity(url='http://www.opnfv.org/'):
 362     """
 363     Check if there is access to the internet
 364     """
 365     try:
 366         urllib2.urlopen(url, timeout=5)
 367         return True
 368     except urllib2.URLError:
 369         return False
 370
 371
 372 def download_url(url, dest_path):
 373     """
 374     Download a file to a destination path given a URL
 375     """
 376     name = url.rsplit('/')[-1]
 377     dest = dest_path + "/" + name
 378     try:
 379         response = urllib2.urlopen(url)
 380     except (urllib2.HTTPError, urllib2.URLError):
 381         return False
 382
 383     with open(dest, 'wb') as f:
 384         f.write(response.read())
 385     return True
 386
 387
 388 def execute_command(cmd, logger=None):
 389     """
 390     Execute Linux command
 391     """
 392     if logger:
 393         logger.debug('Executing command : {}'.format(cmd))
 394     output_file = "output.txt"
 395     f = open(output_file, 'w+')
 396     p = subprocess.call(cmd, shell=True, stdout=f, stderr=subprocess.STDOUT)
 397     f.close()
 398     f = open(output_file, 'r')
 399     result = f.read()
 400     if result != "" and logger:
 401         logger.debug(result)
 402     if p == 0:
 403         return True
 404     else:
 405         if logger:
 406             logger.error("Error when executing command %s" % cmd)
 407         exit(-1)
 408
 409
 410 def get_git_branch(repo_path):
 411     """
 412     Get git branch name
 413     """
 414     repo = Repo(repo_path)
 415     branch = repo.active_branch
 416     return branch.name
 417
 418
 419 def get_installer_type(logger=None):
 420     """
 421     Get installer type (fuel, foreman, apex, joid, compass)
 422     """
 423     try:
 424         installer = os.environ['INSTALLER_TYPE']
 425     except KeyError:
 426         if logger:
 427             logger.error("Impossible to retrieve the installer type")
 428         installer = "Unkown"
 429
 430     return installer
 431
 432
 433 def get_pod_name(logger=None):
 434     """
 435     Get PoD Name from env variable NODE_NAME
 436     """
 437     try:
 438         return os.environ['NODE_NAME']
 439     except KeyError:
 440         if logger:
 441             logger.error("Unable to retrieve the POD name from environment.Using pod name 'unknown-pod'")
 442         return "unknown-pod"
 443
 444
 445 def push_results_to_db(db_url, case_name, logger, pod_name, git_version, payload):
 446     url = db_url + "/results"
 447     installer = get_installer_type(logger)
 448     params = {"project_name": "functest", "case_name": case_name,
 449               "pod_name": pod_name, "installer": installer,
 450               "version": git_version, "details": payload}
 451
 452     headers = {'Content-Type': 'application/json'}
 453     try:
 454         r = requests.post(url, data=json.dumps(params), headers=headers)
 455         logger.debug(r)
 456         return True
 457     except:
 458         print "Error:", sys.exc_info()[0]
 459         return False