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 import json
  12 import os
  13 import os.path
  14 import re
  15 import requests
  16 import shutil
  17 import socket
  18 import subprocess
  19 import sys
  20 import urllib2
  21 from git import Repo
  22
  23
  24 # ----------------------------------------------------------
  25 #
  26 #               OPENSTACK UTILS
  27 #
  28 # -----------------------------------------------------------
  29
  30
  31 #*********************************************
  32 #   CREDENTIALS
  33 #*********************************************
  34 def check_credentials():
  35     """
  36     Check if the OpenStack credentials (openrc) are sourced
  37     """
  38     env_vars = ['OS_AUTH_URL', 'OS_USERNAME', 'OS_PASSWORD', 'OS_TENANT_NAME']
  39     return all(map(lambda v: v in os.environ and os.environ[v], env_vars))
  40
  41
  42 def get_credentials(service):
  43     """Returns a creds dictionary filled with the following keys:
  44     * username
  45     * password/api_key (depending on the service)
  46     * tenant_name/project_id (depending on the service)
  47     * auth_url
  48     :param service: a string indicating the name of the service
  49                     requesting the credentials.
  50     """
  51     creds = {}
  52     # Unfortunately, each of the OpenStack client will request slightly
  53     # different entries in their credentials dict.
  54     if service.lower() in ("nova", "cinder"):
  55         password = "api_key"
  56         tenant = "project_id"
  57     else:
  58         password = "password"
  59         tenant = "tenant_name"
  60
  61     # The most common way to pass these info to the script is to do it through
  62     # environment variables.
  63     creds.update({
  64         "username": os.environ.get('OS_USERNAME', "admin"),
  65         password: os.environ.get("OS_PASSWORD", 'admin'),
  66         "auth_url": os.environ.get("OS_AUTH_URL",
  67                                    "http://192.168.20.71:5000/v2.0"),
  68         tenant: os.environ.get("OS_TENANT_NAME", "admin"),
  69     })
  70     return creds
  71
  72
  73 #*********************************************
  74 #   NOVA
  75 #*********************************************
  76 def get_instances(nova_client):
  77     try:
  78         instances = nova_client.servers.list(search_opts={'all_tenants': 1})
  79         return instances
  80     except Exception, e:
  81         print "Error [get_instances(nova_client)]:", e
  82         return None
  83
  84
  85 def get_instance_status(nova_client, instance):
  86     try:
  87         instance = nova_client.servers.get(instance.id)
  88         return instance.status
  89     except Exception, e:
  90         #print "Error [get_instance_status(nova_client, '%s')]:" % \
  91         #    str(instance), e
  92         return None
  93
  94
  95 def get_instance_by_name(nova_client, instance_name):
  96     try:
  97         instance = nova_client.servers.find(name=instance_name)
  98         return instance
  99     except Exception, e:
 100         print "Error [get_instance_by_name(nova_client, '%s')]:" % \
 101             instance_name, e
 102         return None
 103
 104
 105 def get_flavor_id(nova_client, flavor_name):
 106     flavors = nova_client.flavors.list(detailed=True)
 107     id = ''
 108     for f in flavors:
 109         if f.name == flavor_name:
 110             id = f.id
 111             break
 112     return id
 113
 114
 115 def get_flavor_id_by_ram_range(nova_client, min_ram, max_ram):
 116     flavors = nova_client.flavors.list(detailed=True)
 117     id = ''
 118     for f in flavors:
 119         if min_ram <= f.ram and f.ram <= max_ram:
 120             id = f.id
 121             break
 122     return id
 123
 124
 125 def get_floating_ips(nova_client):
 126     try:
 127         floating_ips = nova_client.floating_ips.list()
 128         return floating_ips
 129     except Exception, e:
 130         print "Error [get_floating_ips(nova_client)]:", e
 131         return None
 132
 133
 134 def create_flavor(nova_client, flavor_name, ram, disk, vcpus):
 135     try:
 136         flavor = nova_client.flavors.create(flavor_name, ram, vcpus, disk)
 137     except Exception, e:
 138         print "Error [create_flavor(nova_client, '%s', '%s', '%s', "\
 139             "'%s')]:" % (flavor_name, ram, disk, vcpus), e
 140         return None
 141     return flavor.id
 142
 143
 144 def create_floating_ip(neutron_client):
 145     extnet_id = get_external_net_id(neutron_client)
 146     props = {'floating_network_id': extnet_id}
 147     try:
 148         ip_json = neutron_client.create_floatingip({'floatingip': props})
 149         fip_addr = ip_json['floatingip']['floating_ip_address']
 150         fip_id = ip_json['floatingip']['id']
 151     except Exception, e:
 152         print "Error [create_floating_ip(neutron_client)]:", e
 153         return None
 154     return {'fip_addr': fip_addr, 'fip_id': fip_id}
 155
 156
 157 def add_floating_ip(nova_client, server_id, floatingip_id):
 158     try:
 159         nova_client.servers.add_floating_ip(server_id, floatingip_id)
 160         return True
 161     except Exception, e:
 162         print "Error [add_floating_ip(nova_client, '%s', '%s')]:" % \
 163             (server_id, floatingip_id), e
 164         return False
 165
 166
 167 def delete_instance(nova_client, instance_id):
 168     try:
 169         nova_client.servers.force_delete(instance_id)
 170         return True
 171     except Exception, e:
 172         print "Error [delete_instance(nova_client, '%s')]:" % instance_id, e
 173         return False
 174
 175
 176 def delete_floating_ip(nova_client, floatingip_id):
 177     try:
 178         nova_client.floating_ips.delete(floatingip_id)
 179         return True
 180     except Exception, e:
 181         print "Error [delete_floating_ip(nova_client, '%s')]:" % floatingip_id, e
 182         return False
 183
 184
 185 #*********************************************
 186 #   NEUTRON
 187 #*********************************************
 188 def get_network_list(neutron_client):
 189     network_list = neutron_client.list_networks()['networks']
 190     if len(network_list) == 0:
 191         return None
 192     else:
 193         return network_list
 194
 195
 196 def get_router_list(neutron_client):
 197     router_list = neutron_client.list_routers()['routers']
 198     if len(router_list) == 0:
 199         return None
 200     else:
 201         return router_list
 202
 203
 204 def get_port_list(neutron_client):
 205     port_list = neutron_client.list_ports()['ports']
 206     if len(port_list) == 0:
 207         return None
 208     else:
 209         return port_list
 210
 211
 212 def get_network_id(neutron_client, network_name):
 213     networks = neutron_client.list_networks()['networks']
 214     id = ''
 215     for n in networks:
 216         if n['name'] == network_name:
 217             id = n['id']
 218             break
 219     return id
 220
 221
 222 def get_subnet_id(neutron_client, subnet_name):
 223     subnets = neutron_client.list_subnets()['subnets']
 224     id = ''
 225     for s in subnets:
 226         if s['name'] == subnet_name:
 227             id = s['id']
 228             break
 229     return id
 230
 231
 232 def get_router_id(neutron_client, router_name):
 233     routers = neutron_client.list_routers()['routers']
 234     id = ''
 235     for r in routers:
 236         if r['name'] == router_name:
 237             id = r['id']
 238             break
 239     return id
 240
 241
 242 def get_private_net(neutron_client):
 243     # Checks if there is an existing shared private network
 244     networks = neutron_client.list_networks()['networks']
 245     if len(networks) == 0:
 246         return None
 247     for net in networks:
 248         if (net['router:external'] is False) and (net['shared'] is True):
 249             return net
 250     return None
 251
 252
 253 def get_external_net(neutron_client):
 254     for network in neutron_client.list_networks()['networks']:
 255         if network['router:external']:
 256             return network['name']
 257     return False
 258
 259
 260 def get_external_net_id(neutron_client):
 261     for network in neutron_client.list_networks()['networks']:
 262         if network['router:external']:
 263             return network['id']
 264     return False
 265
 266
 267 def check_neutron_net(neutron_client, net_name):
 268     for network in neutron_client.list_networks()['networks']:
 269         if network['name'] == net_name:
 270             for subnet in network['subnets']:
 271                 return True
 272     return False
 273
 274
 275 def create_neutron_net(neutron_client, name):
 276     json_body = {'network': {'name': name,
 277                              'admin_state_up': True}}
 278     try:
 279         network = neutron_client.create_network(body=json_body)
 280         network_dict = network['network']
 281         return network_dict['id']
 282     except Exception, e:
 283         print "Error [create_neutron_net(neutron_client, '%s')]:" % name, e
 284         return False
 285
 286
 287 def create_neutron_subnet(neutron_client, name, cidr, net_id):
 288     json_body = {'subnets': [{'name': name, 'cidr': cidr,
 289                               'ip_version': 4, 'network_id': net_id}]}
 290     try:
 291         subnet = neutron_client.create_subnet(body=json_body)
 292         return subnet['subnets'][0]['id']
 293     except Exception, e:
 294         print "Error [create_neutron_subnet(neutron_client, '%s', '%s', "\
 295             "'%s')]:" % (name, cidr, net_id), e
 296         return False
 297
 298
 299 def create_neutron_router(neutron_client, name):
 300     json_body = {'router': {'name': name, 'admin_state_up': True}}
 301     try:
 302         router = neutron_client.create_router(json_body)
 303         return router['router']['id']
 304     except Exception, e:
 305         print "Error [create_neutron_router(neutron_client, '%s')]:" % name, e
 306         return False
 307
 308
 309 def create_neutron_port(neutron_client, name, network_id, ip):
 310     json_body = {'port': {
 311                  'admin_state_up': True,
 312                  'name': name,
 313                  'network_id': network_id,
 314                  'fixed_ips': [{"ip_address": ip}]
 315                  }}
 316     try:
 317         port = neutron_client.create_port(body=json_body)
 318         return port['port']['id']
 319     except Exception, e:
 320         print "Error [create_neutron_port(neutron_client, '%s', '%s', "\
 321             "'%s')]:" % (name, network_id, ip), e
 322         return False
 323
 324
 325 def update_neutron_net(neutron_client, network_id, shared=False):
 326     json_body = {'network': {'shared': shared}}
 327     try:
 328         neutron_client.update_network(network_id, body=json_body)
 329         return True
 330     except Exception, e:
 331         print "Error [update_neutron_net(neutron_client, '%s', '%s')]:" % \
 332             (network_id, str(shared)), e
 333         return False
 334
 335
 336 def update_neutron_port(neutron_client, port_id, device_owner):
 337     json_body = {'port': {
 338                  'device_owner': device_owner,
 339                  }}
 340     try:
 341         port = neutron_client.update_port(port=port_id,
 342                                           body=json_body)
 343         return port['port']['id']
 344     except Exception, e:
 345         print "Error [update_neutron_port(neutron_client, '%s', '%s')]:" % \
 346             (port_id, device_owner), e
 347         return False
 348
 349
 350 def add_interface_router(neutron_client, router_id, subnet_id):
 351     json_body = {"subnet_id": subnet_id}
 352     try:
 353         neutron_client.add_interface_router(router=router_id, body=json_body)
 354         return True
 355     except Exception, e:
 356         print "Error [add_interface_router(neutron_client, '%s', '%s')]:" % \
 357             (router_id, subnet_id), e
 358         return False
 359
 360
 361 def add_gateway_router(neutron_client, router_id):
 362     ext_net_id = get_external_net_id(neutron_client)
 363     router_dict = {'network_id': ext_net_id}
 364     try:
 365         neutron_client.add_gateway_router(router_id, router_dict)
 366         return True
 367     except Exception, e:
 368         print "Error [add_gateway_router(neutron_client, '%s')]:" % router_id, e
 369         return False
 370
 371
 372 def delete_neutron_net(neutron_client, network_id):
 373     try:
 374         neutron_client.delete_network(network_id)
 375         return True
 376     except Exception, e:
 377         print "Error [delete_neutron_net(neutron_client, '%s')]:" % network_id, e
 378         return False
 379
 380
 381 def delete_neutron_subnet(neutron_client, subnet_id):
 382     try:
 383         neutron_client.delete_subnet(subnet_id)
 384         return True
 385     except Exception, e:
 386         print "Error [delete_neutron_subnet(neutron_client, '%s')]:" % subnet_id, e
 387         return False
 388
 389
 390 def delete_neutron_router(neutron_client, router_id):
 391     json_body = {'router': {'id': router_id}}
 392     try:
 393         neutron_client.delete_router(router=router_id)
 394         return True
 395     except Exception, e:
 396         print "Error [delete_neutron_router(neutron_client, '%s')]:" % \
 397             router_id, e
 398         return False
 399
 400
 401 def delete_neutron_port(neutron_client, port_id):
 402     try:
 403         neutron_client.delete_port(port_id)
 404         return True
 405     except Exception, e:
 406         print "Error [delete_neutron_port(neutron_client, '%s')]:" % port_id, e
 407         return False
 408
 409
 410 def remove_interface_router(neutron_client, router_id, subnet_id):
 411     json_body = {"subnet_id": subnet_id}
 412     try:
 413         neutron_client.remove_interface_router(router=router_id,
 414                                                body=json_body)
 415         return True
 416     except Exception, e:
 417         print "Error [remove_interface_router(neutron_client, '%s', '%s')]:" % \
 418             (router_id, subnet_id), e
 419         return False
 420
 421
 422 def remove_gateway_router(neutron_client, router_id):
 423     try:
 424         neutron_client.remove_gateway_router(router_id)
 425         return True
 426     except Exception, e:
 427         print "Error [remove_gateway_router(neutron_client, '%s')]:" % router_id, e
 428         return False
 429
 430
 431 #*********************************************
 432 #   SEC GROUPS
 433 #*********************************************
 434 def get_security_groups(neutron_client):
 435     try:
 436         security_groups = neutron_client.list_security_groups()[
 437             'security_groups']
 438         return security_groups
 439     except Exception, e:
 440         print "Error [get_security_groups(neutron_client)]:", e
 441         return None
 442
 443 def get_security_group_id(neutron_client, sg_name):
 444     security_groups = get_security_groups(neutron_client)
 445     id = ''
 446     for sg in security_groups:
 447         if sg['name'] == sg_name:
 448             id = sg['id']
 449             break
 450     return id
 451
 452
 453 def create_security_group(neutron_client, sg_name, sg_description):
 454     json_body = {'security_group': {'name': sg_name,
 455                                     'description': sg_description}}
 456     try:
 457         secgroup = neutron_client.create_security_group(json_body)
 458         return secgroup['security_group']
 459     except Exception, e:
 460         print "Error [create_security_group(neutron_client, '%s', '%s')]:" % \
 461             (sg_name, sg_description), e
 462         return False
 463
 464
 465 def create_secgroup_rule(neutron_client, sg_id, direction, protocol,
 466                          port_range_min=None, port_range_max=None):
 467     if port_range_min is None and port_range_max is None:
 468         json_body = {'security_group_rule': {'direction': direction,
 469                                              'security_group_id': sg_id,
 470                                              'protocol': protocol}}
 471     elif port_range_min is not None and port_range_max is not None:
 472         json_body = {'security_group_rule': {'direction': direction,
 473                                              'security_group_id': sg_id,
 474                                              'port_range_min': port_range_min,
 475                                              'port_range_max': port_range_max,
 476                                              'protocol': protocol}}
 477     else:
 478         print "Error [create_secgroup_rule(neutron_client, '%s', '%s', "\
 479               "'%s', '%s', '%s', '%s')]:" % (neutron_client, sg_id, direction, \
 480                                              port_range_min, port_range_max, protocol),\
 481               " Invalid values for port_range_min, port_range_max"
 482         return False
 483     try:
 484         neutron_client.create_security_group_rule(json_body)
 485         return True
 486     except Exception, e:
 487         print "Error [create_secgroup_rule(neutron_client, '%s', '%s', "\
 488             "'%s', '%s', '%s', '%s')]:" % (neutron_client, sg_id, direction,
 489                                            port_range_min, port_range_max,
 490                                            protocol), e
 491         return False
 492
 493
 494 def add_secgroup_to_instance(nova_client, instance_id, secgroup_id):
 495     try:
 496         nova_client.servers.add_security_group(instance_id, secgroup_id)
 497         return True
 498     except Exception, e:
 499         print "Error [add_secgroup_to_instance(nova_client, '%s', '%s')]: " % \
 500             (instance_id, secgroup_id), e
 501         return False
 502
 503
 504 def update_sg_quota(neutron_client, tenant_id, sg_quota, sg_rule_quota):
 505     json_body = {"quota": {
 506         "security_group": sg_quota,
 507         "security_group_rule": sg_rule_quota
 508     }}
 509
 510     try:
 511         quota = neutron_client.update_quota(tenant_id=tenant_id,
 512                                             body=json_body)
 513         return True
 514     except Exception, e:
 515         print "Error [update_sg_quota(neutron_client, '%s', '%s', "\
 516             "'%s')]:" % (tenant_id, sg_quota, sg_rule_quota), e
 517         return False
 518
 519
 520 def delete_security_group(neutron_client, secgroup_id):
 521     try:
 522         neutron_client.delete_security_group(secgroup_id)
 523         return True
 524     except Exception, e:
 525         print "Error [delete_security_group(neutron_client, '%s')]:" % secgroup_id, e
 526         return False
 527
 528
 529 #*********************************************
 530 #   GLANCE
 531 #*********************************************
 532 def get_images(nova_client):
 533     try:
 534         images = nova_client.images.list()
 535         return images
 536     except Exception, e:
 537         print "Error [get_images]:", e
 538         return None
 539
 540
 541 def get_image_id(glance_client, image_name):
 542     images = glance_client.images.list()
 543     id = ''
 544     for i in images:
 545         if i.name == image_name:
 546             id = i.id
 547             break
 548     return id
 549
 550
 551 def create_glance_image(glance_client, image_name, file_path, public=True):
 552     if not os.path.isfile(file_path):
 553         print "Error: file " + file_path + " does not exist."
 554         return False
 555     try:
 556         with open(file_path) as fimage:
 557             image = glance_client.images.create(name=image_name,
 558                                                 is_public=public,
 559                                                 disk_format="qcow2",
 560                                                 container_format="bare",
 561                                                 data=fimage)
 562         return image.id
 563     except Exception, e:
 564         print "Error [create_glance_image(glance_client, '%s', '%s', "\
 565             "'%s')]:" % (image_name, file_path, str(public)), e
 566         return False
 567
 568
 569 def delete_glance_image(nova_client, image_id):
 570     try:
 571         nova_client.images.delete(image_id)
 572         return True
 573     except Exception, e:
 574         print "Error [delete_glance_image(nova_client, '%s')]:" % image_id, e
 575         return False
 576
 577
 578 #*********************************************
 579 #   CINDER
 580 #*********************************************
 581 def get_volumes(cinder_client):
 582     try:
 583         volumes = cinder_client.volumes.list(search_opts={'all_tenants': 1})
 584         return volumes
 585     except Exception, e:
 586         print "Error [get_volumes(cinder_client)]:", e
 587         return None
 588
 589
 590 def list_volume_types(cinder_client, public=True, private=True):
 591     try:
 592         volume_types = cinder_client.volume_types.list()
 593         if not public:
 594             volume_types = [vt for vt in volume_types if not vt.is_public]
 595         if not private:
 596             volume_types = [vt for vt in volume_types if vt.is_public]
 597         return volume_types
 598     except Exception, e:
 599         print "Error [list_volume_types(cinder_client)]:", e
 600         return None
 601
 602
 603 def create_volume_type(cinder_client, name):
 604     try:
 605         volume_type = cinder_client.volume_types.create(name)
 606         return volume_type
 607     except Exception, e:
 608         print "Error [create_volume_type(cinder_client, '%s')]:" % name, e
 609         return None
 610
 611
 612 def update_cinder_quota(cinder_client, tenant_id, vols_quota,
 613                         snapshots_quota, gigabytes_quota):
 614     quotas_values = {"volumes": vols_quota,
 615                      "snapshots": snapshots_quota,
 616                      "gigabytes": gigabytes_quota}
 617
 618     try:
 619         quotas_default = cinder_client.quotas.update(tenant_id,
 620                                                      **quotas_values)
 621         return True
 622     except Exception, e:
 623         print "Error [update_cinder_quota(cinder_client, '%s', '%s', '%s'" \
 624             "'%s')]:" % (tenant_id, vols_quota, snapshots_quota, gigabytes_quota), e
 625         return False
 626
 627
 628 def delete_volume(cinder_client, volume_id, forced=False):
 629     try:
 630         if forced:
 631             try:
 632                 cinder_client.volumes.detach(volume_id)
 633             except:
 634                 print "Error:", sys.exc_info()[0]
 635             cinder_client.volumes.force_delete(volume_id)
 636         else:
 637             cinder_client.volumes.delete(volume_id)
 638         return True
 639     except Exception, e:
 640         print "Error [delete_volume(cinder_client, '%s', '%s')]:" % \
 641             (volume_id, str(forced)), e
 642         return False
 643
 644
 645 def delete_volume_type(cinder_client, volume_type):
 646     try:
 647         cinder_client.volume_types.delete(volume_type)
 648         return True
 649     except Exception, e:
 650         print "Error [delete_volume_type(cinder_client, '%s')]:" % volume_type, e
 651         return False
 652
 653
 654 #*********************************************
 655 #   KEYSTONE
 656 #*********************************************
 657 def get_tenants(keystone_client):
 658     try:
 659         tenants = keystone_client.tenants.list()
 660         return tenants
 661     except Exception, e:
 662         print "Error [get_tenants(keystone_client)]:", e
 663         return None
 664
 665
 666 def get_users(keystone_client):
 667     try:
 668         users = keystone_client.users.list()
 669         return users
 670     except Exception, e:
 671         print "Error [get_users(keystone_client)]:", e
 672         return None
 673
 674
 675 def get_tenant_id(keystone_client, tenant_name):
 676     tenants = keystone_client.tenants.list()
 677     id = ''
 678     for t in tenants:
 679         if t.name == tenant_name:
 680             id = t.id
 681             break
 682     return id
 683
 684
 685 def get_user_id(keystone_client, user_name):
 686     users = keystone_client.users.list()
 687     id = ''
 688     for u in users:
 689         if u.name == user_name:
 690             id = u.id
 691             break
 692     return id
 693
 694
 695 def get_role_id(keystone_client, role_name):
 696     roles = keystone_client.roles.list()
 697     id = ''
 698     for r in roles:
 699         if r.name == role_name:
 700             id = r.id
 701             break
 702     return id
 703
 704
 705 def create_tenant(keystone_client, tenant_name, tenant_description):
 706     try:
 707         tenant = keystone_client.tenants.create(tenant_name,
 708                                                 tenant_description,
 709                                                 enabled=True)
 710         return tenant.id
 711     except Exception, e:
 712         print "Error [create_tenant(cinder_client, '%s', '%s')]:" % \
 713             (tenant_name, tenant_description), e
 714         return False
 715
 716
 717 def create_user(keystone_client, user_name, user_password,
 718                 user_email, tenant_id):
 719     try:
 720         user = keystone_client.users.create(user_name, user_password,
 721                                             user_email, tenant_id,
 722                                             enabled=True)
 723         return user.id
 724     except Exception, e:
 725         print "Error [create_user(keystone_client, '%s', '%s', '%s'" \
 726             "'%s')]:" % (user_name, user_password, user_email, tenant_id), e
 727         return False
 728
 729
 730 def add_role_user(keystone_client, user_id, role_id, tenant_id):
 731     try:
 732         keystone_client.roles.add_user_role(user_id, role_id, tenant_id)
 733         return True
 734     except Exception, e:
 735         print "Error [add_role_user(keystone_client, '%s', '%s'" \
 736             "'%s')]:" % (user_id, role_id, tenant_id), e
 737         return False
 738
 739
 740 def delete_tenant(keystone_client, tenant_id):
 741     try:
 742         tenant = keystone_client.tenants.delete(tenant_id)
 743         return True
 744     except Exception, e:
 745         print "Error [delete_tenant(keystone_client, '%s')]:" % tenant_id, e
 746         return False
 747
 748
 749 def delete_user(keystone_client, user_id):
 750     try:
 751         tenant = keystone_client.users.delete(user_id)
 752         return True
 753     except Exception, e:
 754         print "Error [delete_user(keystone_client, '%s')]:" % user_id, e
 755         return False
 756
 757
 758
 759
 760
 761
 762
 763 # ----------------------------------------------------------
 764 #
 765 #               INTERNET UTILS
 766 #
 767 # -----------------------------------------------------------
 768 def check_internet_connectivity(url='http://www.opnfv.org/'):
 769     """
 770     Check if there is access to the internet
 771     """
 772     try:
 773         urllib2.urlopen(url, timeout=5)
 774         return True
 775     except urllib2.URLError:
 776         return False
 777
 778
 779 def download_url(url, dest_path):
 780     """
 781     Download a file to a destination path given a URL
 782     """
 783     name = url.rsplit('/')[-1]
 784     dest = dest_path + "/" + name
 785     try:
 786         response = urllib2.urlopen(url)
 787     except (urllib2.HTTPError, urllib2.URLError):
 788         return False
 789
 790     with open(dest, 'wb') as f:
 791         shutil.copyfileobj(response, f)
 792     return True
 793
 794
 795
 796
 797 # ----------------------------------------------------------
 798 #
 799 #               CI UTILS
 800 #
 801 # -----------------------------------------------------------
 802 def get_git_branch(repo_path):
 803     """
 804     Get git branch name
 805     """
 806     repo = Repo(repo_path)
 807     branch = repo.active_branch
 808     return branch.name
 809
 810
 811 def get_installer_type(logger=None):
 812     """
 813     Get installer type (fuel, apex, joid, compass)
 814     """
 815     try:
 816         installer = os.environ['INSTALLER_TYPE']
 817     except KeyError:
 818         if logger:
 819             logger.error("Impossible to retrieve the installer type")
 820         installer = "Unknown_installer"
 821
 822     return installer
 823
 824
 825 def get_scenario(logger=None):
 826     """
 827     Get scenario
 828     """
 829     try:
 830         scenario = os.environ['DEPLOY_SCENARIO']
 831     except KeyError:
 832         if logger:
 833             logger.error("Impossible to retrieve the scenario")
 834         scenario = "Unknown_scenario"
 835
 836     return scenario
 837
 838
 839 def get_pod_name(logger=None):
 840     """
 841     Get PoD Name from env variable NODE_NAME
 842     """
 843     try:
 844         return os.environ['NODE_NAME']
 845     except KeyError:
 846         if logger:
 847             logger.error(
 848                 "Unable to retrieve the POD name from environment.Using pod name 'unknown-pod'")
 849         return "unknown-pod"
 850
 851
 852 def push_results_to_db(db_url, project, case_name, logger, pod_name,
 853                        version, payload):
 854     """
 855     POST results to the Result target DB
 856     """
 857     url = db_url + "/results"
 858     installer = get_installer_type(logger)
 859     params = {"project_name": project, "case_name": case_name,
 860               "pod_name": pod_name, "installer": installer,
 861               "version": version, "details": payload}
 862
 863     headers = {'Content-Type': 'application/json'}
 864     try:
 865         r = requests.post(url, data=json.dumps(params), headers=headers)
 866         if logger:
 867             logger.debug(r)
 868         return True
 869     except Exception, e:
 870         print "Error [push_results_to_db('%s', '%s', '%s', '%s', '%s', '%s')]:" \
 871             % (db_url, project, case_name, pod_name, version, payload), e
 872         return False
 873
 874
 875 def get_resolvconf_ns():
 876     """
 877     Get nameservers from current resolv.conf
 878     """
 879     nameservers = []
 880     rconf = open("/etc/resolv.conf", "r")
 881     line = rconf.readline()
 882     while line:
 883         ip = re.search(r"\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b", line)
 884         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 885         if ip:
 886             result = sock.connect_ex((ip.group(), 53))
 887             if result == 0:
 888                 nameservers.append(ip.group())
 889         line = rconf.readline()
 890     return nameservers
 891
 892
 893 def getTestEnv(test, functest_yaml):
 894     """
 895     Get the config of the testcase based on functest_config.yaml
 896       2 options
 897         - test = test project e.g; ovno
 898         - test = testcase e.g. functest/odl
 899        look for the / to see if it is a test project or a testcase
 900     """
 901     try:
 902         TEST_ENV = functest_yaml.get("test-dependencies")
 903
 904         if test.find("/") < 0:
 905             config_test = TEST_ENV[test]
 906         else:
 907             test_split = test.split("/")
 908             testproject = test_split[0]
 909             testcase = test_split[1]
 910             config_test = TEST_ENV[testproject][testcase]
 911     except KeyError:
 912         # if not defined in dependencies => no dependencies
 913         config_test = ""
 914     except Exception, e:
 915         print "Error [getTestEnv]:", e
 916
 917     return config_test
 918
 919
 920 def get_ci_envvars():
 921     """
 922     Get the CI env variables
 923     """
 924     ci_env_var = {
 925         "installer": os.environ.get('INSTALLER_TYPE'),
 926         "scenario": os.environ.get('DEPLOY_SCENARIO')}
 927     return ci_env_var
 928
 929
 930 def isTestRunnable(test, functest_yaml):
 931     """
 932     Return True if the test is runnable in the current scenario
 933     """
 934     # By default we assume that all the tests are always runnable...
 935     is_runnable = True
 936     # Retrieve CI environment
 937     ci_env = get_ci_envvars()
 938     # Retrieve test environement from config file
 939     test_env = getTestEnv(test, functest_yaml)
 940
 941     # if test_env not empty => dependencies to be checked
 942     if test_env is not None and len(test_env) > 0:
 943         # possible criteria = ["installer", "scenario"]
 944         # consider test criteria from config file
 945         # compare towards CI env through CI en variable
 946         for criteria in test_env:
 947             if re.search(test_env[criteria], ci_env[criteria]) is None:
 948                 # print "Test "+ test + " cannot be run on the environment"
 949                 is_runnable = False
 950     return is_runnable
 951
 952
 953 def generateTestcaseList(functest_yaml):
 954     """
 955     Generate a test file with the runnable test according to
 956     the current scenario
 957     """
 958     test_list = ""
 959     # get testcases
 960     testcase_list = functest_yaml.get("test-dependencies")
 961     projects = testcase_list.keys()
 962
 963     for project in projects:
 964         testcases = testcase_list[project]
 965         # 1 or 2 levels for testcases project[/case]l
 966         # if only project name without controller or scenario
 967         # => shall be runnable on any controller/scenario
 968         if testcases is None:
 969             test_list += project + " "
 970         else:
 971             for testcase in testcases:
 972                 if testcase == "installer" or testcase == "scenario":
 973                     # project (1 level)
 974                     if isTestRunnable(project, functest_yaml):
 975                         test_list += project + " "
 976                 else:
 977                     # project/testcase (2 levels)
 978                     thetest = project + "/" + testcase
 979                     if isTestRunnable(thetest, functest_yaml):
 980                         test_list += testcase + " "
 981
 982     # sort the list to execute the test in the right order
 983     test_order_list = functest_yaml.get("test_exec_priority")
 984     test_sorted_list = ""
 985     for test in test_order_list:
 986         if test_order_list[test] in test_list:
 987             test_sorted_list += test_order_list[test] + " "
 988
 989     # create a file that could be consumed by run-test.sh
 990     # this method is used only for CI
 991     # so it can be run only in container
 992     # reuse default conf directory to store the list of runnable tests
 993     file = open("/home/opnfv/functest/conf/testcase-list.txt", 'w')
 994     file.write(test_sorted_list)
 995     file.close()
 996
 997     return test_sorted_list
 998
 999
1000 def execute_command(cmd, logger=None, exit_on_error=True):
1001     """
1002     Execute Linux command
1003         prints stdout to a file and depending on if there
1004         is a logger defined, it will print it or not.
1005     """
1006     if logger:
1007         logger.debug('Executing command : {}'.format(cmd))
1008     output_file = "output.txt"
1009     f = open(output_file, 'w+')
1010     p = subprocess.call(cmd, shell=True, stdout=f, stderr=subprocess.STDOUT)
1011     f.close()
1012     f = open(output_file, 'r')
1013     result = f.read()
1014     if result != "" and logger:
1015         logger.debug(result)
1016     if p == 0:
1017         return True
1018     else:
1019         if logger:
1020             logger.error("Error when executing command %s" % cmd)
1021         if exit_on_error:
1022             exit(-1)
1023         return False