utils/openstack_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 os
  12 import os.path
  13 import subprocess
  14 import sys
  15 import time
  16
  17 from glanceclient import client as glanceclient
  18 from keystoneclient.v2_0 import client as keystoneclient
  19 from neutronclient.v2_0 import client as neutronclient
  20 from novaclient import client as novaclient
  21
  22
  23 # *********************************************
  24 #   CREDENTIALS
  25 # *********************************************
  26 def check_credentials():
  27     """
  28     Check if the OpenStack credentials (openrc) are sourced
  29     """
  30     env_vars = ['OS_AUTH_URL', 'OS_USERNAME', 'OS_PASSWORD', 'OS_TENANT_NAME']
  31     return all(map(lambda v: v in os.environ and os.environ[v], env_vars))
  32
  33
  34 def get_credentials(service):
  35     """Returns a creds dictionary filled with the following keys:
  36     * username
  37     * password/api_key (depending on the service)
  38     * tenant_name/project_id (depending on the service)
  39     * auth_url
  40     :param service: a string indicating the name of the service
  41                     requesting the credentials.
  42     """
  43     creds = {}
  44
  45     # Check that the env vars exists:
  46     envvars = ('OS_USERNAME', 'OS_PASSWORD', 'OS_AUTH_URL', 'OS_TENANT_NAME')
  47     for envvar in envvars:
  48         if os.getenv(envvar) is None:
  49             print("'%s' is not exported as an env variable." % envvar)
  50             exit(-1)
  51
  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"),
  65         password: os.environ.get("OS_PASSWORD"),
  66         "auth_url": os.environ.get("OS_AUTH_URL"),
  67         tenant: os.environ.get("OS_TENANT_NAME")
  68     })
  69     cacert = os.environ.get("OS_CACERT")
  70     if cacert is not None:
  71         # each openstack client uses differnt kwargs for this
  72         creds.update({"cacert": cacert,
  73                       "ca_cert": cacert,
  74                       "https_ca_cert": cacert,
  75                       "https_cacert": cacert,
  76                       "ca_file": cacert})
  77         creds.update({"insecure": "True", "https_insecure": "True"})
  78         if not os.path.isfile(cacert):
  79             print ("WARNING: The 'OS_CACERT' environment variable is " +
  80                    "set to %s but the file does not exist." % cacert)
  81     return creds
  82
  83
  84 def source_credentials(rc_file):
  85     pipe = subprocess.Popen(". %s; env" % rc_file, stdout=subprocess.PIPE,
  86                             shell=True)
  87     output = pipe.communicate()[0]
  88     env = dict((line.split("=", 1) for line in output.splitlines()))
  89     os.environ.update(env)
  90     return env
  91
  92
  93 # *********************************************
  94 #   CLIENTS
  95 # *********************************************
  96 def get_keystone_client():
  97     creds_keystone = get_credentials("keystone")
  98     return keystoneclient.Client(**creds_keystone)
  99
 100
 101 def get_nova_client():
 102     creds_nova = get_credentials("nova")
 103     return novaclient.Client('2', **creds_nova)
 104
 105
 106 def get_neutron_client():
 107     creds_neutron = get_credentials("neutron")
 108     return neutronclient.Client(**creds_neutron)
 109
 110
 111 def get_glance_client():
 112     keystone_client = get_keystone_client()
 113     glance_endpoint = keystone_client.service_catalog.url_for(
 114         service_type='image', endpoint_type='publicURL')
 115     return glanceclient.Client(1, glance_endpoint,
 116                                token=keystone_client.auth_token)
 117
 118 # *********************************************
 119 #   NOVA
 120 # *********************************************
 121
 122
 123 def get_instances(nova_client):
 124     try:
 125         instances = nova_client.servers.list(search_opts={'all_tenants': 1})
 126         return instances
 127     except Exception, e:
 128         print "Error [get_instances(nova_client)]:", e
 129         return None
 130
 131
 132 def get_instance_status(nova_client, instance):
 133     try:
 134         instance = nova_client.servers.get(instance.id)
 135         return instance.status
 136     except:
 137         # print ("Error [get_instance_status(nova_client, '%s')]:" %
 138         #        str(instance)), e
 139         return None
 140
 141
 142 def get_instance_by_name(nova_client, instance_name):
 143     try:
 144         instance = nova_client.servers.find(name=instance_name)
 145         return instance
 146     except Exception, e:
 147         print ("Error [get_instance_by_name(nova_client, '%s')]:" %
 148                instance_name), e
 149         return None
 150
 151
 152 def get_flavor_id(nova_client, flavor_name):
 153     flavors = nova_client.flavors.list(detailed=True)
 154     id = ''
 155     for f in flavors:
 156         if f.name == flavor_name:
 157             id = f.id
 158             break
 159     return id
 160
 161
 162 def get_flavor_id_by_ram_range(nova_client, min_ram, max_ram):
 163     flavors = nova_client.flavors.list(detailed=True)
 164     id = ''
 165     for f in flavors:
 166         if min_ram <= f.ram and f.ram <= max_ram:
 167             id = f.id
 168             break
 169     return id
 170
 171
 172 def get_floating_ips(nova_client):
 173     try:
 174         floating_ips = nova_client.floating_ips.list()
 175         return floating_ips
 176     except Exception, e:
 177         print "Error [get_floating_ips(nova_client)]:", e
 178         return None
 179
 180
 181 def get_hypervisors(nova_client):
 182     try:
 183         nodes = []
 184         hypervisors = nova_client.hypervisors.list()
 185         for hypervisor in hypervisors:
 186             nodes.append(hypervisor.hypervisor_hostname)
 187         return nodes
 188     except Exception, e:
 189         print "Error [get_hypervisors(nova_client)]:", e
 190         return None
 191
 192
 193 def create_flavor(nova_client, flavor_name, ram, disk, vcpus):
 194     try:
 195         flavor = nova_client.flavors.create(flavor_name, ram, vcpus, disk)
 196     except Exception, e:
 197         print ("Error [create_flavor(nova_client, '%s', '%s', '%s', "
 198                "'%s')]:" % (flavor_name, ram, disk, vcpus)), e
 199         return None
 200     return flavor.id
 201
 202
 203 def create_instance(flavor_name,
 204                     image_id,
 205                     network_id,
 206                     instance_name="functest-vm",
 207                     confdrive=True,
 208                     userdata=None,
 209                     av_zone=''):
 210     nova_client = get_nova_client()
 211     try:
 212         flavor = nova_client.flavors.find(name=flavor_name)
 213     except:
 214         print("Error: Flavor '%s' not found. Available flavors are:" %
 215               flavor_name)
 216         print(nova_client.flavor.list())
 217         return -1
 218     if userdata is None:
 219         instance = nova_client.servers.create(
 220             name=instance_name,
 221             flavor=flavor,
 222             image=image_id,
 223             nics=[{"net-id": network_id}],
 224             availability_zone=av_zone
 225         )
 226     else:
 227         instance = nova_client.servers.create(
 228             name=instance_name,
 229             flavor=flavor,
 230             image=image_id,
 231             nics=[{"net-id": network_id}],
 232             config_drive=confdrive,
 233             userdata=userdata,
 234             availability_zone=av_zone
 235         )
 236     return instance
 237
 238
 239 def create_instance_and_wait_for_active(flavor_name,
 240                                         image_id,
 241                                         network_id,
 242                                         instance_name="",
 243                                         config_drive=False,
 244                                         userdata="",
 245                                         av_zone=''):
 246     SLEEP = 3
 247     VM_BOOT_TIMEOUT = 180
 248     nova_client = get_nova_client()
 249     instance = create_instance(flavor_name,
 250                                image_id,
 251                                network_id,
 252                                instance_name,
 253                                config_drive,
 254                                userdata,
 255                                av_zone)
 256
 257     count = VM_BOOT_TIMEOUT / SLEEP
 258     for n in range(count, -1, -1):
 259         status = get_instance_status(nova_client, instance)
 260         if status.lower() == "active":
 261             return instance
 262         elif status.lower() == "error":
 263             print("The instance %s went to ERROR status." % instance_name)
 264             return None
 265         time.sleep(SLEEP)
 266     print("Timeout booting the instance %s." % instance_name)
 267     return None
 268
 269
 270 def create_floating_ip(neutron_client):
 271     extnet_id = get_external_net_id(neutron_client)
 272     props = {'floating_network_id': extnet_id}
 273     try:
 274         ip_json = neutron_client.create_floatingip({'floatingip': props})
 275         fip_addr = ip_json['floatingip']['floating_ip_address']
 276         fip_id = ip_json['floatingip']['id']
 277     except Exception, e:
 278         print "Error [create_floating_ip(neutron_client)]:", e
 279         return None
 280     return {'fip_addr': fip_addr, 'fip_id': fip_id}
 281
 282
 283 def add_floating_ip(nova_client, server_id, floatingip_id):
 284     try:
 285         nova_client.servers.add_floating_ip(server_id, floatingip_id)
 286         return True
 287     except Exception, e:
 288         print ("Error [add_floating_ip(nova_client, '%s', '%s')]:" %
 289                (server_id, floatingip_id)), e
 290         return False
 291
 292
 293 def delete_instance(nova_client, instance_id):
 294     try:
 295         nova_client.servers.force_delete(instance_id)
 296         return True
 297     except Exception, e:
 298         print "Error [delete_instance(nova_client, '%s')]:" % instance_id, e
 299         return False
 300
 301
 302 def delete_floating_ip(nova_client, floatingip_id):
 303     try:
 304         nova_client.floating_ips.delete(floatingip_id)
 305         return True
 306     except Exception, e:
 307         print ("Error [delete_floating_ip(nova_client, '%s')]:" %
 308                floatingip_id), e
 309         return False
 310
 311
 312 # *********************************************
 313 #   NEUTRON
 314 # *********************************************
 315 def get_network_list(neutron_client):
 316     network_list = neutron_client.list_networks()['networks']
 317     if len(network_list) == 0:
 318         return None
 319     else:
 320         return network_list
 321
 322
 323 def get_router_list(neutron_client):
 324     router_list = neutron_client.list_routers()['routers']
 325     if len(router_list) == 0:
 326         return None
 327     else:
 328         return router_list
 329
 330
 331 def get_port_list(neutron_client):
 332     port_list = neutron_client.list_ports()['ports']
 333     if len(port_list) == 0:
 334         return None
 335     else:
 336         return port_list
 337
 338
 339 def get_network_id(neutron_client, network_name):
 340     networks = neutron_client.list_networks()['networks']
 341     id = ''
 342     for n in networks:
 343         if n['name'] == network_name:
 344             id = n['id']
 345             break
 346     return id
 347
 348
 349 def get_subnet_id(neutron_client, subnet_name):
 350     subnets = neutron_client.list_subnets()['subnets']
 351     id = ''
 352     for s in subnets:
 353         if s['name'] == subnet_name:
 354             id = s['id']
 355             break
 356     return id
 357
 358
 359 def get_router_id(neutron_client, router_name):
 360     routers = neutron_client.list_routers()['routers']
 361     id = ''
 362     for r in routers:
 363         if r['name'] == router_name:
 364             id = r['id']
 365             break
 366     return id
 367
 368
 369 def get_private_net(neutron_client):
 370     # Checks if there is an existing shared private network
 371     networks = neutron_client.list_networks()['networks']
 372     if len(networks) == 0:
 373         return None
 374     for net in networks:
 375         if (net['router:external'] is False) and (net['shared'] is True):
 376             return net
 377     return None
 378
 379
 380 def get_external_net(neutron_client):
 381     for network in neutron_client.list_networks()['networks']:
 382         if network['router:external']:
 383             return network['name']
 384     return False
 385
 386
 387 def get_external_net_id(neutron_client):
 388     for network in neutron_client.list_networks()['networks']:
 389         if network['router:external']:
 390             return network['id']
 391     return False
 392
 393
 394 def check_neutron_net(neutron_client, net_name):
 395     for network in neutron_client.list_networks()['networks']:
 396         if network['name'] == net_name:
 397             for subnet in network['subnets']:
 398                 return True
 399     return False
 400
 401
 402 def create_neutron_net(neutron_client, name):
 403     json_body = {'network': {'name': name,
 404                              'admin_state_up': True}}
 405     try:
 406         network = neutron_client.create_network(body=json_body)
 407         network_dict = network['network']
 408         return network_dict['id']
 409     except Exception, e:
 410         print "Error [create_neutron_net(neutron_client, '%s')]:" % name, e
 411         return False
 412
 413
 414 def create_neutron_subnet(neutron_client, name, cidr, net_id):
 415     json_body = {'subnets': [{'name': name, 'cidr': cidr,
 416                               'ip_version': 4, 'network_id': net_id}]}
 417     try:
 418         subnet = neutron_client.create_subnet(body=json_body)
 419         return subnet['subnets'][0]['id']
 420     except Exception, e:
 421         print ("Error [create_neutron_subnet(neutron_client, '%s', '%s', "
 422                "'%s')]:" % (name, cidr, net_id)), e
 423         return False
 424
 425
 426 def create_neutron_router(neutron_client, name):
 427     json_body = {'router': {'name': name, 'admin_state_up': True}}
 428     try:
 429         router = neutron_client.create_router(json_body)
 430         return router['router']['id']
 431     except Exception, e:
 432         print "Error [create_neutron_router(neutron_client, '%s')]:" % name, e
 433         return False
 434
 435
 436 def create_neutron_port(neutron_client, name, network_id, ip):
 437     json_body = {'port': {
 438                  'admin_state_up': True,
 439                  'name': name,
 440                  'network_id': network_id,
 441                  'fixed_ips': [{"ip_address": ip}]
 442                  }}
 443     try:
 444         port = neutron_client.create_port(body=json_body)
 445         return port['port']['id']
 446     except Exception, e:
 447         print ("Error [create_neutron_port(neutron_client, '%s', '%s', "
 448                "'%s')]:" % (name, network_id, ip)), e
 449         return False
 450
 451
 452 def update_neutron_net(neutron_client, network_id, shared=False):
 453     json_body = {'network': {'shared': shared}}
 454     try:
 455         neutron_client.update_network(network_id, body=json_body)
 456         return True
 457     except Exception, e:
 458         print ("Error [update_neutron_net(neutron_client, '%s', '%s')]:" %
 459                (network_id, str(shared))), e
 460         return False
 461
 462
 463 def update_neutron_port(neutron_client, port_id, device_owner):
 464     json_body = {'port': {
 465                  'device_owner': device_owner,
 466                  }}
 467     try:
 468         port = neutron_client.update_port(port=port_id,
 469                                           body=json_body)
 470         return port['port']['id']
 471     except Exception, e:
 472         print ("Error [update_neutron_port(neutron_client, '%s', '%s')]:" %
 473                (port_id, device_owner)), e
 474         return False
 475
 476
 477 def add_interface_router(neutron_client, router_id, subnet_id):
 478     json_body = {"subnet_id": subnet_id}
 479     try:
 480         neutron_client.add_interface_router(router=router_id, body=json_body)
 481         return True
 482     except Exception, e:
 483         print ("Error [add_interface_router(neutron_client, '%s', '%s')]:" %
 484                (router_id, subnet_id)), e
 485         return False
 486
 487
 488 def add_gateway_router(neutron_client, router_id):
 489     ext_net_id = get_external_net_id(neutron_client)
 490     router_dict = {'network_id': ext_net_id}
 491     try:
 492         neutron_client.add_gateway_router(router_id, router_dict)
 493         return True
 494     except Exception, e:
 495         print ("Error [add_gateway_router(neutron_client, '%s')]:" %
 496                router_id), e
 497         return False
 498
 499
 500 def delete_neutron_net(neutron_client, network_id):
 501     try:
 502         neutron_client.delete_network(network_id)
 503         return True
 504     except Exception, e:
 505         print ("Error [delete_neutron_net(neutron_client, '%s')]:" %
 506                network_id), e
 507         return False
 508
 509
 510 def delete_neutron_subnet(neutron_client, subnet_id):
 511     try:
 512         neutron_client.delete_subnet(subnet_id)
 513         return True
 514     except Exception, e:
 515         print ("Error [delete_neutron_subnet(neutron_client, '%s')]:" %
 516                subnet_id), e
 517         return False
 518
 519
 520 def delete_neutron_router(neutron_client, router_id):
 521     try:
 522         neutron_client.delete_router(router=router_id)
 523         return True
 524     except Exception, e:
 525         print ("Error [delete_neutron_router(neutron_client, '%s')]:" %
 526                router_id), e
 527         return False
 528
 529
 530 def delete_neutron_port(neutron_client, port_id):
 531     try:
 532         neutron_client.delete_port(port_id)
 533         return True
 534     except Exception, e:
 535         print "Error [delete_neutron_port(neutron_client, '%s')]:" % port_id, e
 536         return False
 537
 538
 539 def remove_interface_router(neutron_client, router_id, subnet_id):
 540     json_body = {"subnet_id": subnet_id}
 541     try:
 542         neutron_client.remove_interface_router(router=router_id,
 543                                                body=json_body)
 544         return True
 545     except Exception, e:
 546         print ("Error [remove_interface_router(neutron_client, '%s', '%s')]:" %
 547                (router_id, subnet_id)), e
 548         return False
 549
 550
 551 def remove_gateway_router(neutron_client, router_id):
 552     try:
 553         neutron_client.remove_gateway_router(router_id)
 554         return True
 555     except Exception, e:
 556         print ("Error [remove_gateway_router(neutron_client, '%s')]:" %
 557                router_id), e
 558         return False
 559
 560
 561 def create_network_full(logger,
 562                         neutron_client,
 563                         net_name,
 564                         subnet_name,
 565                         router_name,
 566                         cidr):
 567
 568     # Check if the network already exists
 569     network_id = get_network_id(neutron_client, net_name)
 570     subnet_id = get_subnet_id(neutron_client, subnet_name)
 571     router_id = get_router_id(neutron_client, router_name)
 572
 573     if network_id != '' and subnet_id != '' and router_id != '':
 574         logger.info("A network with name '%s' already exists..." % net_name)
 575     else:
 576         neutron_client.format = 'json'
 577         logger.info('Creating neutron network %s...' % net_name)
 578         network_id = create_neutron_net(neutron_client, net_name)
 579
 580         if not network_id:
 581             return False
 582
 583         logger.debug("Network '%s' created successfully" % network_id)
 584         logger.debug('Creating Subnet....')
 585         subnet_id = create_neutron_subnet(neutron_client, subnet_name,
 586                                           cidr, network_id)
 587         if not subnet_id:
 588             return False
 589
 590         logger.debug("Subnet '%s' created successfully" % subnet_id)
 591         logger.debug('Creating Router...')
 592         router_id = create_neutron_router(neutron_client, router_name)
 593
 594         if not router_id:
 595             return False
 596
 597         logger.debug("Router '%s' created successfully" % router_id)
 598         logger.debug('Adding router to subnet...')
 599
 600         if not add_interface_router(neutron_client, router_id, subnet_id):
 601             return False
 602
 603         logger.debug("Interface added successfully.")
 604
 605         logger.debug('Adding gateway to router...')
 606         if not add_gateway_router(neutron_client, router_id):
 607             return False
 608
 609         logger.debug("Gateway added successfully.")
 610
 611     network_dic = {'net_id': network_id,
 612                    'subnet_id': subnet_id,
 613                    'router_id': router_id}
 614     return network_dic
 615
 616
 617 def create_bgpvpn(neutron_client, **kwargs):
 618     # route_distinguishers
 619     # route_targets
 620     json_body = {"bgpvpn": kwargs}
 621     return neutron_client.create_bgpvpn(json_body)
 622
 623
 624 def create_network_association(neutron_client, bgpvpn_id, neutron_network_id):
 625     json_body = {"network_association": {"network_id": neutron_network_id}}
 626     return neutron_client.create_network_association(bgpvpn_id, json_body)
 627
 628
 629 def update_bgpvpn(neutron_client, bgpvpn_id, **kwargs):
 630     json_body = {"bgpvpn": kwargs}
 631     return neutron_client.update_bgpvpn(bgpvpn_id, json_body)
 632
 633 # *********************************************
 634 #   SEC GROUPS
 635 # *********************************************
 636
 637
 638 def get_security_groups(neutron_client):
 639     try:
 640         security_groups = neutron_client.list_security_groups()[
 641             'security_groups']
 642         return security_groups
 643     except Exception, e:
 644         print "Error [get_security_groups(neutron_client)]:", e
 645         return None
 646
 647
 648 def get_security_group_id(neutron_client, sg_name):
 649     security_groups = get_security_groups(neutron_client)
 650     id = ''
 651     for sg in security_groups:
 652         if sg['name'] == sg_name:
 653             id = sg['id']
 654             break
 655     return id
 656
 657
 658 def create_security_group(neutron_client, sg_name, sg_description):
 659     json_body = {'security_group': {'name': sg_name,
 660                                     'description': sg_description}}
 661     try:
 662         secgroup = neutron_client.create_security_group(json_body)
 663         return secgroup['security_group']
 664     except Exception, e:
 665         print ("Error [create_security_group(neutron_client, '%s', '%s')]:" %
 666                (sg_name, sg_description)), e
 667         return False
 668
 669
 670 def create_secgroup_rule(neutron_client, sg_id, direction, protocol,
 671                          port_range_min=None, port_range_max=None):
 672     if port_range_min is None and port_range_max is None:
 673         json_body = {'security_group_rule': {'direction': direction,
 674                                              'security_group_id': sg_id,
 675                                              'protocol': protocol}}
 676     elif port_range_min is not None and port_range_max is not None:
 677         json_body = {'security_group_rule': {'direction': direction,
 678                                              'security_group_id': sg_id,
 679                                              'port_range_min': port_range_min,
 680                                              'port_range_max': port_range_max,
 681                                              'protocol': protocol}}
 682     else:
 683         print ("Error [create_secgroup_rule(neutron_client, '%s', '%s', "
 684                "'%s', '%s', '%s', '%s')]:" % (neutron_client, sg_id, direction,
 685                                               port_range_min, port_range_max,
 686                                               protocol),
 687                " Invalid values for port_range_min, port_range_max")
 688         return False
 689     try:
 690         neutron_client.create_security_group_rule(json_body)
 691         return True
 692     except Exception, e:
 693         print ("Error [create_secgroup_rule(neutron_client, '%s', '%s', "
 694                "'%s', '%s', '%s', '%s')]:" % (neutron_client, sg_id, direction,
 695                                               port_range_min, port_range_max,
 696                                               protocol)), e
 697         return False
 698
 699
 700 def create_security_group_full(logger, neutron_client,
 701                                sg_name, sg_description):
 702     sg_id = get_security_group_id(neutron_client, sg_name)
 703     if sg_id != '':
 704         logger.info("Using existing security group '%s'..." % sg_name)
 705     else:
 706         logger.info("Creating security group  '%s'..." % sg_name)
 707         SECGROUP = create_security_group(neutron_client,
 708                                          sg_name,
 709                                          sg_description)
 710         if not SECGROUP:
 711             logger.error("Failed to create the security group...")
 712             return False
 713
 714         sg_id = SECGROUP['id']
 715
 716         logger.debug("Security group '%s' with ID=%s created successfully."
 717                      % (SECGROUP['name'], sg_id))
 718
 719         logger.debug("Adding ICMP rules in security group '%s'..."
 720                      % sg_name)
 721         if not create_secgroup_rule(neutron_client, sg_id,
 722                                     'ingress', 'icmp'):
 723             logger.error("Failed to create the security group rule...")
 724             return False
 725
 726         logger.debug("Adding SSH rules in security group '%s'..."
 727                      % sg_name)
 728         if not create_secgroup_rule(
 729                 neutron_client, sg_id, 'ingress', 'tcp', '22', '22'):
 730             logger.error("Failed to create the security group rule...")
 731             return False
 732
 733         if not create_secgroup_rule(
 734                 neutron_client, sg_id, 'egress', 'tcp', '22', '22'):
 735             logger.error("Failed to create the security group rule...")
 736             return False
 737     return sg_id
 738
 739
 740 def add_secgroup_to_instance(nova_client, instance_id, secgroup_id):
 741     try:
 742         nova_client.servers.add_security_group(instance_id, secgroup_id)
 743         return True
 744     except Exception, e:
 745         print ("Error [add_secgroup_to_instance(nova_client, '%s', '%s')]: " %
 746                (instance_id, secgroup_id)), e
 747         return False
 748
 749
 750 def update_sg_quota(neutron_client, tenant_id, sg_quota, sg_rule_quota):
 751     json_body = {"quota": {
 752         "security_group": sg_quota,
 753         "security_group_rule": sg_rule_quota
 754     }}
 755
 756     try:
 757         neutron_client.update_quota(tenant_id=tenant_id,
 758                                     body=json_body)
 759         return True
 760     except Exception, e:
 761         print ("Error [update_sg_quota(neutron_client, '%s', '%s', "
 762                "'%s')]:" % (tenant_id, sg_quota, sg_rule_quota)), e
 763         return False
 764
 765
 766 def delete_security_group(neutron_client, secgroup_id):
 767     try:
 768         neutron_client.delete_security_group(secgroup_id)
 769         return True
 770     except Exception, e:
 771         print ("Error [delete_security_group(neutron_client, '%s')]:" %
 772                secgroup_id), e
 773         return False
 774
 775
 776 # *********************************************
 777 #   GLANCE
 778 # *********************************************
 779 def get_images(nova_client):
 780     try:
 781         images = nova_client.images.list()
 782         return images
 783     except Exception, e:
 784         print "Error [get_images]:", e
 785         return None
 786
 787
 788 def get_image_id(glance_client, image_name):
 789     images = glance_client.images.list()
 790     id = ''
 791     for i in images:
 792         if i.name == image_name:
 793             id = i.id
 794             break
 795     return id
 796
 797
 798 def create_glance_image(glance_client, image_name, file_path, disk="qcow2",
 799                         container="bare", public=True, logger=None):
 800     if not os.path.isfile(file_path):
 801         print "Error: file " + file_path + " does not exist."
 802         return False
 803     try:
 804         image_id = get_image_id(glance_client, image_name)
 805         if image_id != '':
 806             if logger:
 807                 logger.info("Image %s already exists." % image_name)
 808         else:
 809             if logger:
 810                 logger.info("Creating image '%s' from '%s'..." % (image_name,
 811                                                                   file_path))
 812             with open(file_path) as fimage:
 813                 image = glance_client.images.create(name=image_name,
 814                                                     is_public=public,
 815                                                     disk_format=disk,
 816                                                     container_format=container,
 817                                                     data=fimage)
 818             image_id = image.id
 819         return image_id
 820     except Exception, e:
 821         print ("Error [create_glance_image(glance_client, '%s', '%s', "
 822                "'%s')]:" % (image_name, file_path, str(public))), e
 823         return False
 824
 825
 826 def delete_glance_image(nova_client, image_id):
 827     try:
 828         nova_client.images.delete(image_id)
 829         return True
 830     except Exception, e:
 831         print ("Error [delete_glance_image(nova_client, '%s')]:" % image_id), e
 832         return False
 833
 834
 835 # *********************************************
 836 #   CINDER
 837 # *********************************************
 838 def get_volumes(cinder_client):
 839     try:
 840         volumes = cinder_client.volumes.list(search_opts={'all_tenants': 1})
 841         return volumes
 842     except Exception, e:
 843         print "Error [get_volumes(cinder_client)]:", e
 844         return None
 845
 846
 847 def list_volume_types(cinder_client, public=True, private=True):
 848     try:
 849         volume_types = cinder_client.volume_types.list()
 850         if not public:
 851             volume_types = [vt for vt in volume_types if not vt.is_public]
 852         if not private:
 853             volume_types = [vt for vt in volume_types if vt.is_public]
 854         return volume_types
 855     except Exception, e:
 856         print "Error [list_volume_types(cinder_client)]:", e
 857         return None
 858
 859
 860 def create_volume_type(cinder_client, name):
 861     try:
 862         volume_type = cinder_client.volume_types.create(name)
 863         return volume_type
 864     except Exception, e:
 865         print "Error [create_volume_type(cinder_client, '%s')]:" % name, e
 866         return None
 867
 868
 869 def update_cinder_quota(cinder_client, tenant_id, vols_quota,
 870                         snapshots_quota, gigabytes_quota):
 871     quotas_values = {"volumes": vols_quota,
 872                      "snapshots": snapshots_quota,
 873                      "gigabytes": gigabytes_quota}
 874
 875     try:
 876         cinder_client.quotas.update(tenant_id, **quotas_values)
 877         return True
 878     except Exception, e:
 879         print ("Error [update_cinder_quota(cinder_client, '%s', '%s', '%s'"
 880                "'%s')]:" % (tenant_id, vols_quota,
 881                             snapshots_quota, gigabytes_quota)), e
 882         return False
 883
 884
 885 def delete_volume(cinder_client, volume_id, forced=False):
 886     try:
 887         if forced:
 888             try:
 889                 cinder_client.volumes.detach(volume_id)
 890             except:
 891                 print "Error:", sys.exc_info()[0]
 892             cinder_client.volumes.force_delete(volume_id)
 893         else:
 894             cinder_client.volumes.delete(volume_id)
 895         return True
 896     except Exception, e:
 897         print ("Error [delete_volume(cinder_client, '%s', '%s')]:" %
 898                (volume_id, str(forced))), e
 899         return False
 900
 901
 902 def delete_volume_type(cinder_client, volume_type):
 903     try:
 904         cinder_client.volume_types.delete(volume_type)
 905         return True
 906     except Exception, e:
 907         print ("Error [delete_volume_type(cinder_client, '%s')]:" %
 908                volume_type), e
 909         return False
 910
 911
 912 # *********************************************
 913 #   KEYSTONE
 914 # *********************************************
 915 def get_tenants(keystone_client):
 916     try:
 917         tenants = keystone_client.tenants.list()
 918         return tenants
 919     except Exception, e:
 920         print "Error [get_tenants(keystone_client)]:", e
 921         return None
 922
 923
 924 def get_users(keystone_client):
 925     try:
 926         users = keystone_client.users.list()
 927         return users
 928     except Exception, e:
 929         print "Error [get_users(keystone_client)]:", e
 930         return None
 931
 932
 933 def get_tenant_id(keystone_client, tenant_name):
 934     tenants = keystone_client.tenants.list()
 935     id = ''
 936     for t in tenants:
 937         if t.name == tenant_name:
 938             id = t.id
 939             break
 940     return id
 941
 942
 943 def get_user_id(keystone_client, user_name):
 944     users = keystone_client.users.list()
 945     id = ''
 946     for u in users:
 947         if u.name == user_name:
 948             id = u.id
 949             break
 950     return id
 951
 952
 953 def get_role_id(keystone_client, role_name):
 954     roles = keystone_client.roles.list()
 955     id = ''
 956     for r in roles:
 957         if r.name == role_name:
 958             id = r.id
 959             break
 960     return id
 961
 962
 963 def create_tenant(keystone_client, tenant_name, tenant_description):
 964     try:
 965         tenant = keystone_client.tenants.create(tenant_name,
 966                                                 tenant_description,
 967                                                 enabled=True)
 968         return tenant.id
 969     except Exception, e:
 970         print ("Error [create_tenant(cinder_client, '%s', '%s')]:" %
 971                (tenant_name, tenant_description)), e
 972         return False
 973
 974
 975 def create_user(keystone_client, user_name, user_password,
 976                 user_email, tenant_id):
 977     try:
 978         user = keystone_client.users.create(user_name, user_password,
 979                                             user_email, tenant_id,
 980                                             enabled=True)
 981         return user.id
 982     except Exception, e:
 983         print ("Error [create_user(keystone_client, '%s', '%s', '%s'"
 984                "'%s')]:" % (user_name, user_password, user_email, tenant_id),
 985                e)
 986         return False
 987
 988
 989 def add_role_user(keystone_client, user_id, role_id, tenant_id):
 990     try:
 991         keystone_client.roles.add_user_role(user_id, role_id, tenant_id)
 992         return True
 993     except Exception, e:
 994         print ("Error [add_role_user(keystone_client, '%s', '%s'"
 995                "'%s')]:" % (user_id, role_id, tenant_id)), e
 996         return False
 997
 998
 999 def delete_tenant(keystone_client, tenant_id):
1000     try:
1001         keystone_client.tenants.delete(tenant_id)
1002         return True
1003     except Exception, e:
1004         print "Error [delete_tenant(keystone_client, '%s')]:" % tenant_id, e
1005         return False
1006
1007
1008 def delete_user(keystone_client, user_id):
1009     try:
1010         keystone_client.users.delete(user_id)
1011         return True
1012     except Exception, e:
1013         print "Error [delete_user(keystone_client, '%s')]:" % user_id, e
1014         return False