Enable heat context to support existing network

[yardstick.git] / yardstick / common / openstack_utils.py

diff --git a/yardstick/common/openstack_utils.py b/yardstick/common/openstack_utils.py
index c862a6b..8f666e2 100644 (file)
--- a/yardstick/common/openstack_utils.py
+++ b/yardstick/common/openstack_utils.py
@@ -7,8 +7,6 @@
 # http://www.apache.org/licenses/LICENSE-2.0
 ##############################################################################
 
 # http://www.apache.org/licenses/LICENSE-2.0
 ##############################################################################
 

-from __future__ import absolute_import
-

 import os
 import time
 import sys
 import os
 import time
 import sys


@@ -16,11 +14,15 @@ import logging
 
 from keystoneauth1 import loading
 from keystoneauth1 import session
 
 from keystoneauth1 import loading
 from keystoneauth1 import session

+import shade
+from shade import exc
+

 from cinderclient import client as cinderclient
 from novaclient import client as novaclient
 from glanceclient import client as glanceclient
 from neutronclient.neutron import client as neutronclient
 
 from cinderclient import client as cinderclient
 from novaclient import client as novaclient
 from glanceclient import client as glanceclient
 from neutronclient.neutron import client as neutronclient
 

+

 log = logging.getLogger(__name__)
 
 DEFAULT_HEAT_API_VERSION = '1'
 log = logging.getLogger(__name__)
 
 DEFAULT_HEAT_API_VERSION = '1'


@@ -170,27 +172,31 @@ def get_glance_client():    # pragma: no cover
     return glanceclient.Client(get_glance_client_version(), session=sess)
 
 
     return glanceclient.Client(get_glance_client_version(), session=sess)
 
 

+def get_shade_client():
+    return shade.openstack_cloud()
+
+

 # *********************************************
 #   NOVA
 # *********************************************
 # *********************************************
 #   NOVA
 # *********************************************

-def get_instances(nova_client):     # pragma: no cover
+def get_instances(nova_client):

     try:
         return nova_client.servers.list(search_opts={'all_tenants': 1})
     try:
         return nova_client.servers.list(search_opts={'all_tenants': 1})

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [get_instances(nova_client)]")
 
 
 def get_instance_status(nova_client, instance):     # pragma: no cover
     try:
         return nova_client.servers.get(instance.id).status
         log.exception("Error [get_instances(nova_client)]")
 
 
 def get_instance_status(nova_client, instance):     # pragma: no cover
     try:
         return nova_client.servers.get(instance.id).status

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [get_instance_status(nova_client)]")
 
 
 def get_instance_by_name(nova_client, instance_name):   # pragma: no cover
     try:
         return nova_client.servers.find(name=instance_name)
         log.exception("Error [get_instance_status(nova_client)]")
 
 
 def get_instance_by_name(nova_client, instance_name):   # pragma: no cover
     try:
         return nova_client.servers.find(name=instance_name)

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [get_instance_by_name(nova_client, '%s')]",
                       instance_name)
 
         log.exception("Error [get_instance_by_name(nova_client, '%s')]",
                       instance_name)
 


@@ -198,28 +204,28 @@ def get_instance_by_name(nova_client, instance_name):   # pragma: no cover
 def get_aggregates(nova_client):    # pragma: no cover
     try:
         return nova_client.aggregates.list()
 def get_aggregates(nova_client):    # pragma: no cover
     try:
         return nova_client.aggregates.list()

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [get_aggregates(nova_client)]")
 
 
 def get_availability_zones(nova_client):    # pragma: no cover
     try:
         return nova_client.availability_zones.list()
         log.exception("Error [get_aggregates(nova_client)]")
 
 
 def get_availability_zones(nova_client):    # pragma: no cover
     try:
         return nova_client.availability_zones.list()

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [get_availability_zones(nova_client)]")
 
 
 def get_availability_zone_names(nova_client):   # pragma: no cover
     try:
         return [az.zoneName for az in get_availability_zones(nova_client)]
         log.exception("Error [get_availability_zones(nova_client)]")
 
 
 def get_availability_zone_names(nova_client):   # pragma: no cover
     try:
         return [az.zoneName for az in get_availability_zones(nova_client)]

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [get_availability_zone_names(nova_client)]")
 
 
 def create_aggregate(nova_client, aggregate_name, av_zone):  # pragma: no cover
     try:
         nova_client.aggregates.create(aggregate_name, av_zone)
         log.exception("Error [get_availability_zone_names(nova_client)]")
 
 
 def create_aggregate(nova_client, aggregate_name, av_zone):  # pragma: no cover
     try:
         nova_client.aggregates.create(aggregate_name, av_zone)

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [create_aggregate(nova_client, %s, %s)]",
                       aggregate_name, av_zone)
         return False
         log.exception("Error [create_aggregate(nova_client, %s, %s)]",
                       aggregate_name, av_zone)
         return False


@@ -231,7 +237,7 @@ def get_aggregate_id(nova_client, aggregate_name):      # pragma: no cover
     try:
         aggregates = get_aggregates(nova_client)
         _id = next((ag.id for ag in aggregates if ag.name == aggregate_name))
     try:
         aggregates = get_aggregates(nova_client)
         _id = next((ag.id for ag in aggregates if ag.name == aggregate_name))

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [get_aggregate_id(nova_client, %s)]",
                       aggregate_name)
     else:
         log.exception("Error [get_aggregate_id(nova_client, %s)]",
                       aggregate_name)
     else:


@@ -243,7 +249,7 @@ def add_host_to_aggregate(nova_client, aggregate_name,
     try:
         aggregate_id = get_aggregate_id(nova_client, aggregate_name)
         nova_client.aggregates.add_host(aggregate_id, compute_host)
     try:
         aggregate_id = get_aggregate_id(nova_client, aggregate_name)
         nova_client.aggregates.add_host(aggregate_id, compute_host)

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [add_host_to_aggregate(nova_client, %s, %s)]",
                       aggregate_name, compute_host)
         return False
         log.exception("Error [add_host_to_aggregate(nova_client, %s, %s)]",
                       aggregate_name, compute_host)
         return False


@@ -256,7 +262,7 @@ def create_aggregate_with_host(nova_client, aggregate_name, av_zone,
     try:
         create_aggregate(nova_client, aggregate_name, av_zone)
         add_host_to_aggregate(nova_client, aggregate_name, compute_host)
     try:
         create_aggregate(nova_client, aggregate_name, av_zone)
         add_host_to_aggregate(nova_client, aggregate_name, compute_host)

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [create_aggregate_with_host("
                       "nova_client, %s, %s, %s)]",
                       aggregate_name, av_zone, compute_host)
         log.exception("Error [create_aggregate_with_host("
                       "nova_client, %s, %s, %s)]",
                       aggregate_name, av_zone, compute_host)


@@ -265,19 +271,20 @@ def create_aggregate_with_host(nova_client, aggregate_name, av_zone,
         return True
 
 
         return True
 
 

-def create_keypair(nova_client, name, key_path=None):    # pragma: no cover
+def create_keypair(name, key_path=None):    # pragma: no cover

     try:
         with open(key_path) as fpubkey:
     try:
         with open(key_path) as fpubkey:

-            keypair = get_nova_client().keypairs.create(name=name, public_key=fpubkey.read())
+            keypair = get_nova_client().keypairs.create(
+                name=name, public_key=fpubkey.read())

             return keypair
             return keypair

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [create_keypair(nova_client)]")
 
 
 def create_instance(json_body):    # pragma: no cover
     try:
         return get_nova_client().servers.create(**json_body)
         log.exception("Error [create_keypair(nova_client)]")
 
 
 def create_instance(json_body):    # pragma: no cover
     try:
         return get_nova_client().servers.create(**json_body)

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error create instance failed")
         return None
 
         log.exception("Error create instance failed")
         return None
 


@@ -288,7 +295,7 @@ def create_instance_and_wait_for_active(json_body):    # pragma: no cover
     nova_client = get_nova_client()
     instance = create_instance(json_body)
     count = VM_BOOT_TIMEOUT / SLEEP
     nova_client = get_nova_client()
     instance = create_instance(json_body)
     count = VM_BOOT_TIMEOUT / SLEEP

-    for n in range(count, -1, -1):
+    for _ in range(count, -1, -1):

         status = get_instance_status(nova_client, instance)
         if status.lower() == "active":
             return instance
         status = get_instance_status(nova_client, instance)
         if status.lower() == "active":
             return instance


@@ -300,10 +307,12 @@ def create_instance_and_wait_for_active(json_body):    # pragma: no cover
     return None
 
 
     return None
 
 

-def attach_server_volume(server_id, volume_id, device=None):    # pragma: no cover
+def attach_server_volume(server_id, volume_id,
+                         device=None):    # pragma: no cover

     try:
     try:

-        get_nova_client().volumes.create_server_volume(server_id, volume_id, device)
-    except Exception:
+        get_nova_client().volumes.create_server_volume(server_id,
+                                                       volume_id, device)
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [attach_server_volume(nova_client, '%s', '%s')]",
                       server_id, volume_id)
         return False
         log.exception("Error [attach_server_volume(nova_client, '%s', '%s')]",
                       server_id, volume_id)
         return False


@@ -314,7 +323,7 @@ def attach_server_volume(server_id, volume_id, device=None):    # pragma: no cov
 def delete_instance(nova_client, instance_id):      # pragma: no cover
     try:
         nova_client.servers.force_delete(instance_id)
 def delete_instance(nova_client, instance_id):      # pragma: no cover
     try:
         nova_client.servers.force_delete(instance_id)

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [delete_instance(nova_client, '%s')]",
                       instance_id)
         return False
         log.exception("Error [delete_instance(nova_client, '%s')]",
                       instance_id)
         return False


@@ -327,7 +336,7 @@ def remove_host_from_aggregate(nova_client, aggregate_name,
     try:
         aggregate_id = get_aggregate_id(nova_client, aggregate_name)
         nova_client.aggregates.remove_host(aggregate_id, compute_host)
     try:
         aggregate_id = get_aggregate_id(nova_client, aggregate_name)
         nova_client.aggregates.remove_host(aggregate_id, compute_host)

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error remove_host_from_aggregate(nova_client, %s, %s)",
                       aggregate_name, compute_host)
         return False
         log.exception("Error remove_host_from_aggregate(nova_client, %s, %s)",
                       aggregate_name, compute_host)
         return False


@@ -348,7 +357,7 @@ def delete_aggregate(nova_client, aggregate_name):  # pragma: no cover
     try:
         remove_hosts_from_aggregate(nova_client, aggregate_name)
         nova_client.aggregates.delete(aggregate_name)
     try:
         remove_hosts_from_aggregate(nova_client, aggregate_name)
         nova_client.aggregates.delete(aggregate_name)

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [delete_aggregate(nova_client, %s)]",
                       aggregate_name)
         return False
         log.exception("Error [delete_aggregate(nova_client, %s)]",
                       aggregate_name)
         return False


@@ -366,8 +375,9 @@ def get_server_by_name(name):   # pragma: no cover
 
 def create_flavor(name, ram, vcpus, disk, **kwargs):   # pragma: no cover
     try:
 
 def create_flavor(name, ram, vcpus, disk, **kwargs):   # pragma: no cover
     try:

-        return get_nova_client().flavors.create(name, ram, vcpus, disk, **kwargs)
-    except Exception:
+        return get_nova_client().flavors.create(name, ram, vcpus,
+                                                disk, **kwargs)
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [create_flavor(nova_client, %s, %s, %s, %s, %s)]",
                       name, ram, disk, vcpus, kwargs['is_public'])
         return None
         log.exception("Error [create_flavor(nova_client, %s, %s, %s, %s, %s)]",
                       name, ram, disk, vcpus, kwargs['is_public'])
         return None


@@ -400,7 +410,7 @@ def get_flavor_by_name(name):   # pragma: no cover
 
 
 def check_status(status, name, iterations, interval):   # pragma: no cover
 
 
 def check_status(status, name, iterations, interval):   # pragma: no cover

-    for i in range(iterations):
+    for _ in range(iterations):

         try:
             server = get_server_by_name(name)
         except IndexError:
         try:
             server = get_server_by_name(name)
         except IndexError:


@@ -417,7 +427,7 @@ def check_status(status, name, iterations, interval):   # pragma: no cover
 def delete_flavor(flavor_id):    # pragma: no cover
     try:
         get_nova_client().flavors.delete(flavor_id)
 def delete_flavor(flavor_id):    # pragma: no cover
     try:
         get_nova_client().flavors.delete(flavor_id)

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [delete_flavor(nova_client, %s)]", flavor_id)
         return False
     else:
         log.exception("Error [delete_flavor(nova_client, %s)]", flavor_id)
         return False
     else:


@@ -428,7 +438,7 @@ def delete_keypair(nova_client, key):     # pragma: no cover
     try:
         nova_client.keypairs.delete(key=key)
         return True
     try:
         nova_client.keypairs.delete(key=key)
         return True

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [delete_keypair(nova_client)]")
         return False
 
         log.exception("Error [delete_keypair(nova_client)]")
         return False
 


@@ -436,45 +446,78 @@ def delete_keypair(nova_client, key):     # pragma: no cover
 # *********************************************
 #   NEUTRON
 # *********************************************
 # *********************************************
 #   NEUTRON
 # *********************************************

-def get_network_id(neutron_client, network_name):       # pragma: no cover
-    networks = neutron_client.list_networks()['networks']
-    return next((n['id'] for n in networks if n['name'] == network_name), None)
-
-
-def get_port_id_by_ip(neutron_client, ip_address):      # pragma: no cover
-    ports = neutron_client.list_ports()['ports']
-    return next((i['id'] for i in ports for j in i.get(
-        'fixed_ips') if j['ip_address'] == ip_address), None)
+def get_network_id(shade_client, network_name):
+    networks = shade_client.list_networks({'name': network_name})
+    if networks:
+        return networks[0]['id']

 
 
 def create_neutron_net(neutron_client, json_body):      # pragma: no cover
     try:
         network = neutron_client.create_network(body=json_body)
         return network['network']['id']
 
 
 def create_neutron_net(neutron_client, json_body):      # pragma: no cover
     try:
         network = neutron_client.create_network(body=json_body)
         return network['network']['id']

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.error("Error [create_neutron_net(neutron_client)]")
         raise Exception("operation error")
         log.error("Error [create_neutron_net(neutron_client)]")
         raise Exception("operation error")

-        return None
+
+
+def delete_neutron_net(shade_client, network_id):
+    try:
+        return shade_client.delete_network(network_id)
+    except exc.OpenStackCloudException:
+        log.error("Error [delete_neutron_net(shade_client, '%s')]", network_id)
+        return False

 
 
 def create_neutron_subnet(neutron_client, json_body):      # pragma: no cover
     try:
         subnet = neutron_client.create_subnet(body=json_body)
         return subnet['subnets'][0]['id']
 
 
 def create_neutron_subnet(neutron_client, json_body):      # pragma: no cover
     try:
         subnet = neutron_client.create_subnet(body=json_body)
         return subnet['subnets'][0]['id']

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.error("Error [create_neutron_subnet")
         raise Exception("operation error")
         log.error("Error [create_neutron_subnet")
         raise Exception("operation error")

-        return None

 
 
 def create_neutron_router(neutron_client, json_body):      # pragma: no cover
     try:
         router = neutron_client.create_router(json_body)
         return router['router']['id']
 
 
 def create_neutron_router(neutron_client, json_body):      # pragma: no cover
     try:
         router = neutron_client.create_router(json_body)
         return router['router']['id']

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.error("Error [create_neutron_router(neutron_client)]")
         raise Exception("operation error")
         log.error("Error [create_neutron_router(neutron_client)]")
         raise Exception("operation error")

-        return None
+
+
+def delete_neutron_router(neutron_client, router_id):      # pragma: no cover
+    try:
+        neutron_client.delete_router(router=router_id)
+        return True
+    except Exception:  # pylint: disable=broad-except
+        log.error("Error [delete_neutron_router(neutron_client, '%s')]",
+                  router_id)
+        return False
+
+
+def remove_gateway_router(neutron_client, router_id):      # pragma: no cover
+    try:
+        neutron_client.remove_gateway_router(router_id)
+        return True
+    except Exception:  # pylint: disable=broad-except
+        log.error("Error [remove_gateway_router(neutron_client, '%s')]",
+                  router_id)
+        return False
+
+
+def remove_interface_router(neutron_client, router_id, subnet_id,
+                            **json_body):      # pragma: no cover
+    json_body.update({"subnet_id": subnet_id})
+    try:
+        neutron_client.remove_interface_router(router=router_id,
+                                               body=json_body)
+        return True
+    except Exception:  # pylint: disable=broad-except
+        log.error("Error [remove_interface_router(neutron_client, '%s', "
+                  "'%s')]", router_id, subnet_id)
+        return False

 
 
 def create_floating_ip(neutron_client, extnet_id):      # pragma: no cover
 
 
 def create_floating_ip(neutron_client, extnet_id):      # pragma: no cover


@@ -483,7 +526,7 @@ def create_floating_ip(neutron_client, extnet_id):      # pragma: no cover
         ip_json = neutron_client.create_floatingip({'floatingip': props})
         fip_addr = ip_json['floatingip']['floating_ip_address']
         fip_id = ip_json['floatingip']['id']
         ip_json = neutron_client.create_floatingip({'floatingip': props})
         fip_addr = ip_json['floatingip']['floating_ip_address']
         fip_id = ip_json['floatingip']['id']

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.error("Error [create_floating_ip(neutron_client)]")
         return None
     return {'fip_addr': fip_addr, 'fip_id': fip_id}
         log.error("Error [create_floating_ip(neutron_client)]")
         return None
     return {'fip_addr': fip_addr, 'fip_id': fip_id}


@@ -493,8 +536,9 @@ def delete_floating_ip(nova_client, floatingip_id):      # pragma: no cover
     try:
         nova_client.floating_ips.delete(floatingip_id)
         return True
     try:
         nova_client.floating_ips.delete(floatingip_id)
         return True

-    except Exception:
-        log.error("Error [delete_floating_ip(nova_client, '%s')]" % floatingip_id)
+    except Exception:  # pylint: disable=broad-except
+        log.error("Error [delete_floating_ip(nova_client, '%s')]",
+                  floatingip_id)

         return False
 
 
         return False
 
 


@@ -503,7 +547,7 @@ def get_security_groups(neutron_client):      # pragma: no cover
         security_groups = neutron_client.list_security_groups()[
             'security_groups']
         return security_groups
         security_groups = neutron_client.list_security_groups()[
             'security_groups']
         return security_groups

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.error("Error [get_security_groups(neutron_client)]")
         return None
 
         log.error("Error [get_security_groups(neutron_client)]")
         return None
 


@@ -518,15 +562,16 @@ def get_security_group_id(neutron_client, sg_name):      # pragma: no cover
     return id
 
 
     return id
 
 

-def create_security_group(neutron_client, sg_name, sg_description):      # pragma: no cover
+def create_security_group(neutron_client, sg_name,
+                          sg_description):      # pragma: no cover

     json_body = {'security_group': {'name': sg_name,
                                     'description': sg_description}}
     try:
         secgroup = neutron_client.create_security_group(json_body)
         return secgroup['security_group']
     json_body = {'security_group': {'name': sg_name,
                                     'description': sg_description}}
     try:
         secgroup = neutron_client.create_security_group(json_body)
         return secgroup['security_group']

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.error("Error [create_security_group(neutron_client, '%s', "
         log.error("Error [create_security_group(neutron_client, '%s', "

-                  "'%s')]" % (sg_name, sg_description))
+                  "'%s')]", sg_name, sg_description)

         return None
 
 
         return None
 
 


@@ -557,28 +602,27 @@ def create_secgroup_rule(neutron_client, sg_id, direction, protocol,
         else:
             log.error("Bad security group format."
                       "One of the port range is not properly set:"
         else:
             log.error("Bad security group format."
                       "One of the port range is not properly set:"

-                      "range min: {},"
-                      "range max: {}".format(port_range_min,
-                                             port_range_max))
+                      "range min: %s, range max: %s", port_range_min,
+                      port_range_max)

             return False
 
     # Create security group using neutron client
     try:
         neutron_client.create_security_group_rule(json_body)
         return True
             return False
 
     # Create security group using neutron client
     try:
         neutron_client.create_security_group_rule(json_body)
         return True

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Impossible to create_security_group_rule,"
                       "security group rule probably already exists")
         return False
 
 
         log.exception("Impossible to create_security_group_rule,"
                       "security group rule probably already exists")
         return False
 
 

-def create_security_group_full(neutron_client,
-                               sg_name, sg_description):      # pragma: no cover
+def create_security_group_full(neutron_client, sg_name,
+                               sg_description):      # pragma: no cover

     sg_id = get_security_group_id(neutron_client, sg_name)
     if sg_id != '':
     sg_id = get_security_group_id(neutron_client, sg_name)
     if sg_id != '':

-        log.info("Using existing security group '%s'..." % sg_name)
+        log.info("Using existing security group '%s'...", sg_name)

     else:
     else:

-        log.info("Creating security group  '%s'..." % sg_name)
+        log.info("Creating security group  '%s'...", sg_name)

         SECGROUP = create_security_group(neutron_client,
                                          sg_name,
                                          sg_description)
         SECGROUP = create_security_group(neutron_client,
                                          sg_name,
                                          sg_description)


@@ -588,18 +632,16 @@ def create_security_group_full(neutron_client,
 
         sg_id = SECGROUP['id']
 
 
         sg_id = SECGROUP['id']
 

-        log.debug("Security group '%s' with ID=%s created successfully."
-                  % (SECGROUP['name'], sg_id))
+        log.debug("Security group '%s' with ID=%s created successfully.",
+                  SECGROUP['name'], sg_id)

 
 

-        log.debug("Adding ICMP rules in security group '%s'..."
-                  % sg_name)
+        log.debug("Adding ICMP rules in security group '%s'...", sg_name)

         if not create_secgroup_rule(neutron_client, sg_id,
                                     'ingress', 'icmp'):
             log.error("Failed to create the security group rule...")
             return None
 
         if not create_secgroup_rule(neutron_client, sg_id,
                                     'ingress', 'icmp'):
             log.error("Failed to create the security group rule...")
             return None
 

-        log.debug("Adding SSH rules in security group '%s'..."
-                  % sg_name)
+        log.debug("Adding SSH rules in security group '%s'...", sg_name)

         if not create_secgroup_rule(
                 neutron_client, sg_id, 'ingress', 'tcp', '22', '22'):
             log.error("Failed to create the security group rule...")
         if not create_secgroup_rule(
                 neutron_client, sg_id, 'ingress', 'tcp', '22', '22'):
             log.error("Failed to create the security group rule...")


@@ -624,31 +666,27 @@ def create_image(glance_client, image_name, file_path, disk_format,
                  container_format, min_disk, min_ram, protected, tag,
                  public, **kwargs):    # pragma: no cover
     if not os.path.isfile(file_path):
                  container_format, min_disk, min_ram, protected, tag,
                  public, **kwargs):    # pragma: no cover
     if not os.path.isfile(file_path):

-        log.error("Error: file %s does not exist." % file_path)
+        log.error("Error: file %s does not exist.", file_path)

         return None
     try:
         image_id = get_image_id(glance_client, image_name)
         if image_id is not None:
         return None
     try:
         image_id = get_image_id(glance_client, image_name)
         if image_id is not None:

-            log.info("Image %s already exists." % image_name)
+            log.info("Image %s already exists.", image_name)

         else:
             log.info("Creating image '%s' from '%s'...", image_name, file_path)
 
         else:
             log.info("Creating image '%s' from '%s'...", image_name, file_path)
 

-            image = glance_client.images.create(name=image_name,
-                                                visibility=public,
-                                                disk_format=disk_format,
-                                                container_format=container_format,
-                                                min_disk=min_disk,
-                                                min_ram=min_ram,
-                                                tags=tag,
-                                                protected=protected,
-                                                **kwargs)
+            image = glance_client.images.create(
+                name=image_name, visibility=public, disk_format=disk_format,
+                container_format=container_format, min_disk=min_disk,
+                min_ram=min_ram, tags=tag, protected=protected, **kwargs)

             image_id = image.id
             with open(file_path) as image_data:
                 glance_client.images.upload(image_id, image_data)
         return image_id
             image_id = image.id
             with open(file_path) as image_data:
                 glance_client.images.upload(image_id, image_data)
         return image_id

-    except Exception:
-        log.error("Error [create_glance_image(glance_client, '%s', '%s', '%s')]",
-                  image_name, file_path, public)
+    except Exception:  # pylint: disable=broad-except
+        log.error(
+            "Error [create_glance_image(glance_client, '%s', '%s', '%s')]",
+            image_name, file_path, public)

         return None
 
 
         return None
 
 


@@ -656,7 +694,7 @@ def delete_image(glance_client, image_id):    # pragma: no cover
     try:
         glance_client.images.delete(image_id)
 
     try:
         glance_client.images.delete(image_id)
 

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [delete_flavor(glance_client, %s)]", image_id)
         return False
     else:
         log.exception("Error [delete_flavor(glance_client, %s)]", image_id)
         return False
     else:


@@ -682,18 +720,19 @@ def create_volume(cinder_client, volume_name, volume_size,
             volume = cinder_client.volumes.create(name=volume_name,
                                                   size=volume_size)
         return volume
             volume = cinder_client.volumes.create(name=volume_name,
                                                   size=volume_size)
         return volume

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [create_volume(cinder_client, %s)]",
                       (volume_name, volume_size))
         return None
 
 
         log.exception("Error [create_volume(cinder_client, %s)]",
                       (volume_name, volume_size))
         return None
 
 

-def delete_volume(cinder_client, volume_id, forced=False):      # pragma: no cover
+def delete_volume(cinder_client, volume_id,
+                  forced=False):      # pragma: no cover

     try:
         if forced:
             try:
                 cinder_client.volumes.detach(volume_id)
     try:
         if forced:
             try:
                 cinder_client.volumes.detach(volume_id)

-            except:
+            except Exception:  # pylint: disable=broad-except

                 log.error(sys.exc_info()[0])
             cinder_client.volumes.force_delete(volume_id)
         else:
                 log.error(sys.exc_info()[0])
             cinder_client.volumes.force_delete(volume_id)
         else:


@@ -703,8 +742,8 @@ def delete_volume(cinder_client, volume_id, forced=False):      # pragma: no cov
                     break
             cinder_client.volumes.delete(volume_id)
         return True
                     break
             cinder_client.volumes.delete(volume_id)
         return True

-    except Exception:
-        log.exception("Error [delete_volume(cinder_client, '%s')]" % volume_id)
+    except Exception:  # pylint: disable=broad-except
+        log.exception("Error [delete_volume(cinder_client, '%s')]", volume_id)

         return False
 
 
         return False
 
 


@@ -712,7 +751,7 @@ def detach_volume(server_id, volume_id):      # pragma: no cover
     try:
         get_nova_client().volumes.delete_server_volume(server_id, volume_id)
         return True
     try:
         get_nova_client().volumes.delete_server_volume(server_id, volume_id)
         return True

-    except Exception:
+    except Exception:  # pylint: disable=broad-except

         log.exception("Error [detach_server_volume(nova_client, '%s', '%s')]",
                       server_id, volume_id)
         return False
         log.exception("Error [detach_server_volume(nova_client, '%s', '%s')]",
                       server_id, volume_id)
         return False