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