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