Merge "introduce heat context"

10 files changed, 2433 insertions, 613 deletions

diff --git a/vnftest/common/constants.py b/vnftest/common/constants.py
index 9634708..a613ff0 100644
--- a/vnftest/common/constants.py
+++ b/vnftest/common/constants.py
@@ -61,26 +61,6 @@ def get_param(key, default=''):
             raise
         return default
 
-
-try:
-    SERVER_IP = get_param('api.server_ip')
-except KeyError:
-    try:
-        from pyroute2 import IPDB
-    except ImportError:
-        SERVER_IP = '172.17.0.1'
-    else:
-        with IPDB() as ip:
-            try:
-                SERVER_IP = ip.routes['default'].gateway
-            except KeyError:
-                # during unittests ip.routes['default'] can be invalid
-                SERVER_IP = '127.0.0.1'
-
-if not SERVER_IP:
-    SERVER_IP = '127.0.0.1'
-
-
 # dir
 CONF_DIR = get_param('dir.conf', '/etc/vnftest')
 IMAGE_DIR = get_param('dir.images', join(VNFTEST_ROOT_PATH, '../../images/'))
@@ -111,6 +91,14 @@ BASE_URL = 'http://localhost:5000'
 ENV_ACTION_API = BASE_URL + '/vnftest/env/action'
 ASYNC_TASK_API = BASE_URL + '/vnftest/asynctask'
 
+# flags
+IS_EXISTING = 'is_existing'
+IS_PUBLIC = 'is_public'
+
 # general
 TESTCASE_PRE = 'onap_vnftest_'
 TESTSUITE_PRE = 'onap_'
+
+
+# OpenStack cloud default config parameters
+OS_CLOUD_DEFAULT_CONFIG = {'verify': False}
diff --git a/vnftest/common/openstack_utils.py b/vnftest/common/openstack_utils.py
index 1bbdc43..048a9d9 100644
--- a/vnftest/common/openstack_utils.py
+++ b/vnftest/common/openstack_utils.py
@@ -14,60 +14,49 @@
 # vnftest comment: this is a modified copy of
 # yardstick/common/openstack_utils.py
 
-from __future__ import absolute_import
-
-import os
-import time
-import sys
+import copy
 import logging
+import os
 
-from keystoneauth1 import loading
-from keystoneauth1 import session
 from cinderclient import client as cinderclient
 from novaclient import client as novaclient
 from glanceclient import client as glanceclient
+from keystoneauth1 import loading
+from keystoneauth1 import session
 from neutronclient.neutron import client as neutronclient
-from heatclient.client import Client as heatclient
+import shade
+from shade import exc
+
+from vnftest.common import constants
+
 
 log = logging.getLogger(__name__)
 
 DEFAULT_HEAT_API_VERSION = '1'
 DEFAULT_API_VERSION = '2'
 
-creds = {}
-
 
 # *********************************************
 #   CREDENTIALS
 # *********************************************
-def initialize(openstack_env_config):
-    keystone_api_version = openstack_env_config.get('OS_IDENTITY_API_VERSION', None)
-
-    if keystone_api_version is None or keystone_api_version == '2':
-        keystone_v3 = False
-        creds['tenant_name'] = openstack_env_config['OS_TENANT_NAME']
-    else:
-        keystone_v3 = True
-        creds['tenant_name'] = openstack_env_config['OS_PROJECT_NAME']
-        creds['project_name'] = openstack_env_config['OS_PROJECT_NAME']
-
-    creds["username"] = openstack_env_config["OS_USERNAME"]
-    creds["password"] = openstack_env_config["OS_PASSWORD"]
-    creds["auth_url"] = openstack_env_config["OS_AUTH_URL"]
-    creds["tenant_id"] = openstack_env_config["OS_TENANT_ID"]
-
-    if keystone_v3:
-        if 'OS_USER_DOMAIN_NAME' in openstack_env_config:
-            creds.update({
-                "user_domain_name": openstack_env_config['OS_USER_DOMAIN_NAME']
-            })
-        if 'OS_PROJECT_DOMAIN_NAME' in openstack_env_config:
-            creds.update({
-                "project_domain_name": openstack_env_config['OS_PROJECT_DOMAIN_NAME']
-            })
-
-
 def get_credentials():
+    """Returns a creds dictionary filled with parsed from env
+
+    Keystone API version used is 3; v2 was deprecated in 2014 (Icehouse). Along
+    with this deprecation, environment variable 'OS_TENANT_NAME' is replaced by
+    'OS_PROJECT_NAME'.
+    """
+    creds = {'username': os.environ.get('OS_USERNAME'),
+             'password': os.environ.get('OS_PASSWORD'),
+             'auth_url': os.environ.get('OS_AUTH_URL'),
+             'project_name': os.environ.get('OS_PROJECT_NAME')
+             }
+
+    if os.getenv('OS_USER_DOMAIN_NAME'):
+        creds['user_domain_name'] = os.getenv('OS_USER_DOMAIN_NAME')
+    if os.getenv('OS_PROJECT_DOMAIN_NAME'):
+        creds['project_domain_name'] = os.getenv('OS_PROJECT_DOMAIN_NAME')
+
     return creds
 
 
@@ -159,11 +148,6 @@ def get_neutron_client():   # pragma: no cover
     return neutronclient.Client(get_neutron_client_version(), session=sess)
 
 
-def get_heat_client():   # pragma: no cover
-    sess = get_session()
-    return heatclient(get_heat_api_version(), session=sess)
-
-
 def get_glance_client_version():    # pragma: no cover
     try:
         api_version = os.environ['OS_IMAGE_API_VERSION']
@@ -179,225 +163,226 @@ def get_glance_client():    # pragma: no cover
     return glanceclient.Client(get_glance_client_version(), session=sess)
 
 
-# *********************************************
-#   NOVA
-# *********************************************
-def get_instances(nova_client):     # pragma: no cover
-    try:
-        return nova_client.servers.list(search_opts={'all_tenants': 1})
-    except Exception:
-        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:
-        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:
-        log.exception("Error [get_instance_by_name(nova_client, '%s')]",
-                      instance_name)
-
-
-def get_instance_by_id(instance_id):   # pragma: no cover
-    try:
-        return get_nova_client().servers.find(id=instance_id)
-    except Exception:
-        log.exception("Error [get_instance_by_id(nova_client, '%s')]",
-                      instance_id)
-
+def get_shade_client(**os_cloud_config):
+    """Get Shade OpenStack cloud client
 
-def get_aggregates(nova_client):    # pragma: no cover
-    try:
-        return nova_client.aggregates.list()
-    except Exception:
-        log.exception("Error [get_aggregates(nova_client)]")
+    By default, the input parameters given to "shade.openstack_cloud" method
+    are stored in "constants.OS_CLOUD_DEFAULT_CONFIG". The input parameters
+    passed in this function, "os_cloud_config", will overwrite the default
+    ones.
 
+    :param os_cloud_config: (kwargs) input arguments for
+                            "shade.openstack_cloud" method.
+    :return: ``shade.OpenStackCloud`` object.
+    """
+    params = copy.deepcopy(constants.OS_CLOUD_DEFAULT_CONFIG)
+    params.update(os_cloud_config)
+    return shade.openstack_cloud(**params)
 
-def get_availability_zones(nova_client):    # pragma: no cover
-    try:
-        return nova_client.availability_zones.list()
-    except Exception:
-        log.exception("Error [get_availability_zones(nova_client)]")
-
+def get_shade_operator_client(**os_cloud_config):
+    """Get Shade Operator cloud 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:
-        log.exception("Error [get_availability_zone_names(nova_client)]")
+    :return: ``shade.OperatorCloud`` object.
+    """
+    params = copy.deepcopy(constants.OS_CLOUD_DEFAULT_CONFIG)
+    params.update(os_cloud_config)
+    return shade.operator_cloud(**params)
 
 
-def create_aggregate(nova_client, aggregate_name, av_zone):  # pragma: no cover
-    try:
-        nova_client.aggregates.create(aggregate_name, av_zone)
-    except Exception:
-        log.exception("Error [create_aggregate(nova_client, %s, %s)]",
-                      aggregate_name, av_zone)
-        return False
-    else:
-        return True
-
-
-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))
-    except Exception:
-        log.exception("Error [get_aggregate_id(nova_client, %s)]",
-                      aggregate_name)
-    else:
-        return _id
-
-
-def add_host_to_aggregate(nova_client, aggregate_name,
-                          compute_host):    # pragma: no cover
-    try:
-        aggregate_id = get_aggregate_id(nova_client, aggregate_name)
-        nova_client.aggregates.add_host(aggregate_id, compute_host)
-    except Exception:
-        log.exception("Error [add_host_to_aggregate(nova_client, %s, %s)]",
-                      aggregate_name, compute_host)
-        return False
-    else:
-        return True
-
-
-def create_aggregate_with_host(nova_client, aggregate_name, av_zone,
-                               compute_host):    # pragma: no cover
-    try:
-        create_aggregate(nova_client, aggregate_name, av_zone)
-        add_host_to_aggregate(nova_client, aggregate_name, compute_host)
-    except Exception:
-        log.exception("Error [create_aggregate_with_host("
-                      "nova_client, %s, %s, %s)]",
-                      aggregate_name, av_zone, compute_host)
-        return False
-    else:
-        return True
-
-
-def create_keypair(nova_client, name, key_path=None):    # pragma: no cover
-    try:
-        with open(key_path) as fpubkey:
-            keypair = get_nova_client().keypairs.create(name=name, public_key=fpubkey.read())
-            return keypair
-    except Exception:
-        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:
-        log.exception("Error create instance failed")
-        return None
-
-
-def create_instance_and_wait_for_active(json_body):    # pragma: no cover
-    SLEEP = 3
-    VM_BOOT_TIMEOUT = 180
-    nova_client = get_nova_client()
-    instance = create_instance(json_body)
-    count = VM_BOOT_TIMEOUT / SLEEP
-    for n in range(count, -1, -1):
-        status = get_instance_status(nova_client, instance)
-        if status.lower() == "active":
-            return instance
-        elif status.lower() == "error":
-            log.error("The instance went to ERROR status.")
-            return None
-        time.sleep(SLEEP)
-    log.error("Timeout booting the instance.")
-    return None
-
-
-def attach_server_volume(server_id, volume_id, device=None):    # pragma: no cover
-    try:
-        get_nova_client().volumes.create_server_volume(server_id, volume_id, device)
-    except Exception:
-        log.exception("Error [attach_server_volume(nova_client, '%s', '%s')]",
-                      server_id, volume_id)
-        return False
-    else:
+# *********************************************
+#   NOVA
+# *********************************************
+def create_keypair(shade_client, name, public_key=None):
+    """Create a new keypair.
+
+    :param name: Name of the keypair being created.
+    :param public_key: Public key for the new keypair.
+
+    :return: Created keypair.
+    """
+    try:
+        return shade_client.create_keypair(name, public_key=public_key)
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [create_keypair(shade_client)]. "
+                  "Exception message, '%s'", o_exc.orig_message)
+
+
+def create_instance_and_wait_for_active(shade_client, name, image,
+                                        flavor, auto_ip=True, ips=None,
+                                        ip_pool=None, root_volume=None,
+                                        terminate_volume=False, wait=True,
+                                        timeout=180, reuse_ips=True,
+                                        network=None, boot_from_volume=False,
+                                        volume_size='20', boot_volume=None,
+                                        volumes=None, nat_destination=None,
+                                        **kwargs):
+    """Create a virtual server instance.
+
+    :param name:(string) Name of the server.
+    :param image:(dict) Image dict, name or ID to boot with. Image is required
+                 unless boot_volume is given.
+    :param flavor:(dict) Flavor dict, name or ID to boot onto.
+    :param auto_ip: Whether to take actions to find a routable IP for
+                    the server.
+    :param ips: List of IPs to attach to the server.
+    :param ip_pool:(string) Name of the network or floating IP pool to get an
+                   address from.
+    :param root_volume:(string) Name or ID of a volume to boot from.
+                       (defaults to None - deprecated, use boot_volume)
+    :param boot_volume:(string) Name or ID of a volume to boot from.
+    :param terminate_volume:(bool) If booting from a volume, whether it should
+                            be deleted when the server is destroyed.
+    :param volumes:(optional) A list of volumes to attach to the server.
+    :param wait:(optional) Wait for the address to appear as assigned to the server.
+    :param timeout: Seconds to wait, defaults to 60.
+    :param reuse_ips:(bool)Whether to attempt to reuse pre-existing
+                     floating ips should a floating IP be needed.
+    :param network:(dict) Network dict or name or ID to attach the server to.
+                   Mutually exclusive with the nics parameter. Can also be be
+                   a list of network names or IDs or network dicts.
+    :param boot_from_volume:(bool) Whether to boot from volume. 'boot_volume'
+                            implies True, but boot_from_volume=True with
+                            no boot_volume is valid and will create a
+                            volume from the image and use that.
+    :param volume_size: When booting an image from volume, how big should
+                        the created volume be?
+    :param nat_destination: Which network should a created floating IP
+                            be attached to, if it's not possible to infer from
+                            the cloud's configuration.
+    :param meta:(optional) A dict of arbitrary key/value metadata to store for
+                this server. Both keys and values must be <=255 characters.
+    :param reservation_id: A UUID for the set of servers being requested.
+    :param min_count:(optional extension) The minimum number of servers to
+                     launch.
+    :param max_count:(optional extension) The maximum number of servers to
+                     launch.
+    :param security_groups: A list of security group names.
+    :param userdata: User data to pass to be exposed by the metadata server
+                     this can be a file type object as well or a string.
+    :param key_name:(optional extension) Name of previously created keypair to
+                    inject into the instance.
+    :param availability_zone: Name of the availability zone for instance
+                              placement.
+    :param block_device_mapping:(optional) A dict of block device mappings for
+                                this server.
+    :param block_device_mapping_v2:(optional) A dict of block device mappings
+                                   for this server.
+    :param nics:(optional extension) An ordered list of nics to be added to
+                 this server, with information about connected networks, fixed
+                 IPs, port etc.
+    :param scheduler_hints:(optional extension) Arbitrary key-value pairs
+                           specified by the client to help boot an instance.
+    :param config_drive:(optional extension) Value for config drive either
+                         boolean, or volume-id.
+    :param disk_config:(optional extension) Control how the disk is partitioned
+                       when the server is created. Possible values are 'AUTO'
+                       or 'MANUAL'.
+    :param admin_pass:(optional extension) Add a user supplied admin password.
+
+    :returns: The created server.
+    """
+    try:
+        return shade_client.create_server(
+            name, image, flavor, auto_ip=auto_ip, ips=ips, ip_pool=ip_pool,
+            root_volume=root_volume, terminate_volume=terminate_volume,
+            wait=wait, timeout=timeout, reuse_ips=reuse_ips, network=network,
+            boot_from_volume=boot_from_volume, volume_size=volume_size,
+            boot_volume=boot_volume, volumes=volumes,
+            nat_destination=nat_destination, **kwargs)
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [create_instance(shade_client)]. "
+                  "Exception message, '%s'", o_exc.orig_message)
+
+
+def attach_volume_to_server(shade_client, server_name_or_id, volume_name_or_id,
+                            device=None, wait=True, timeout=None):
+    """Attach a volume to a server.
+
+    This will attach a volume, described by the passed in volume
+    dict, to the server described by the passed in server dict on the named
+    device on the server.
+
+    If the volume is already attached to the server, or generally not
+    available, then an exception is raised. To re-attach to a server,
+    but under a different device, the user must detach it first.
+
+    :param server_name_or_id:(string) The server name or id to attach to.
+    :param volume_name_or_id:(string) The volume name or id to attach.
+    :param device:(string) The device name where the volume will attach.
+    :param wait:(bool) If true, waits for volume to be attached.
+    :param timeout: Seconds to wait for volume attachment. None is forever.
+
+    :returns: True if attached successful, False otherwise.
+    """
+    try:
+        server = shade_client.get_server(name_or_id=server_name_or_id)
+        volume = shade_client.get_volume(volume_name_or_id)
+        shade_client.attach_volume(
+            server, volume, device=device, wait=wait, timeout=timeout)
         return True
-
-
-def delete_instance(nova_client, instance_id):      # pragma: no cover
-    try:
-        nova_client.servers.force_delete(instance_id)
-    except Exception:
-        log.exception("Error [delete_instance(nova_client, '%s')]",
-                      instance_id)
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [attach_volume_to_server(shade_client)]. "
+                  "Exception message: %s", o_exc.orig_message)
         return False
-    else:
-        return True
 
 
-def remove_host_from_aggregate(nova_client, aggregate_name,
-                               compute_host):  # pragma: no cover
-    try:
-        aggregate_id = get_aggregate_id(nova_client, aggregate_name)
-        nova_client.aggregates.remove_host(aggregate_id, compute_host)
-    except Exception:
-        log.exception("Error remove_host_from_aggregate(nova_client, %s, %s)",
-                      aggregate_name, compute_host)
+def delete_instance(shade_client, name_or_id, wait=False, timeout=180,
+                    delete_ips=False, delete_ip_retry=1):
+    """Delete a server instance.
+
+    :param name_or_id: name or ID of the server to delete
+    :param wait:(bool) If true, waits for server to be deleted.
+    :param timeout:(int) Seconds to wait for server deletion.
+    :param delete_ips:(bool) If true, deletes any floating IPs associated with
+                      the instance.
+    :param delete_ip_retry:(int) Number of times to retry deleting
+                           any floating ips, should the first try be
+                           unsuccessful.
+    :returns: True if delete succeeded, False otherwise.
+    """
+    try:
+        return shade_client.delete_server(
+            name_or_id, wait=wait, timeout=timeout, delete_ips=delete_ips,
+            delete_ip_retry=delete_ip_retry)
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [delete_instance(shade_client, '%s')]. "
+                  "Exception message: %s", name_or_id,
+                  o_exc.orig_message)
         return False
-    else:
-        return True
-
 
-def remove_hosts_from_aggregate(nova_client,
-                                aggregate_name):   # pragma: no cover
-    aggregate_id = get_aggregate_id(nova_client, aggregate_name)
-    hosts = nova_client.aggregates.get(aggregate_id).hosts
-    assert(
-        all(remove_host_from_aggregate(nova_client, aggregate_name, host)
-            for host in hosts))
 
+def get_server(shade_client, name_or_id=None, filters=None, detailed=False,
+               bare=False):
+    """Get a server by name or ID.
 
-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)
-    except Exception:
-        log.exception("Error [delete_aggregate(nova_client, %s)]",
-                      aggregate_name)
-        return False
-    else:
-        return True
-
+    :param name_or_id: Name or ID of the server.
+    :param filters:(dict) A dictionary of meta data to use for further
+                   filtering.
+    :param detailed:(bool) Whether or not to add detailed additional
+                    information.
+    :param bare:(bool) Whether to skip adding any additional information to the
+                server record.
 
-def get_server_by_name(name):   # pragma: no cover
+    :returns: A server ``munch.Munch`` or None if no matching server is found.
+    """
     try:
-        return get_nova_client().servers.list(search_opts={'name': name})[0]
-    except IndexError:
-        log.exception('Failed to get nova client')
-        raise
+        return shade_client.get_server(name_or_id=name_or_id, filters=filters,
+                                       detailed=detailed, bare=bare)
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [get_server(shade_client, '%s')]. "
+                  "Exception message: %s", name_or_id, o_exc.orig_message)
 
 
 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
 
 
-def get_image_by_name(name):    # pragma: no cover
-    images = get_nova_client().images.list()
-    try:
-        return next((a for a in images if a.name == name))
-    except StopIteration:
-        log.exception('No image matched')
-
-
 def get_flavor_id(nova_client, flavor_name):    # pragma: no cover
     flavors = nova_client.flavors.list(detailed=True)
     flavor_id = ''
@@ -408,405 +393,512 @@ def get_flavor_id(nova_client, flavor_name):    # pragma: no cover
     return flavor_id
 
 
-def get_flavor_by_name(name):   # pragma: no cover
-    flavors = get_nova_client().flavors.list()
-    try:
-        return next((a for a in flavors if a.name == name))
-    except StopIteration:
-        log.exception('No flavor matched')
-
-
-def check_status(status, name, iterations, interval):   # pragma: no cover
-    for i in range(iterations):
-        try:
-            server = get_server_by_name(name)
-        except IndexError:
-            log.error('Cannot found %s server', name)
-            raise
+def get_flavor(shade_client, name_or_id, filters=None, get_extra=True):
+    """Get a flavor by name or ID.
 
-        if server.status == status:
-            return True
+    :param name_or_id: Name or ID of the flavor.
+    :param filters: A dictionary of meta data to use for further filtering.
+    :param get_extra: Whether or not the list_flavors call should get the extra
+    flavor specs.
 
-        time.sleep(interval)
-    return False
+    :returns: A flavor ``munch.Munch`` or None if no matching flavor is found.
+    """
+    try:
+        return shade_client.get_flavor(name_or_id, filters=filters,
+                                       get_extra=get_extra)
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [get_flavor(shade_client, '%s')]. "
+                  "Exception message: %s", name_or_id, o_exc.orig_message)
 
 
 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:
         return True
 
 
-def delete_keypair(nova_client, key):     # pragma: no cover
+def delete_keypair(shade_client, name):
+    """Delete a keypair.
+
+    :param name: Name of the keypair to delete.
+
+    :returns: True if delete succeeded, False otherwise.
+    """
     try:
-        nova_client.keypairs.delete(key=key)
-        return True
-    except Exception:
-        log.exception("Error [delete_keypair(nova_client)]")
+        return shade_client.delete_keypair(name)
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [delete_neutron_router(shade_client, '%s')]. "
+                  "Exception message: %s", name, o_exc.orig_message)
         return False
 
 
 # *********************************************
 #   NEUTRON
 # *********************************************
-def get_network_by_name(network_name):       # pragma: no cover
-    try:
-        networks = get_neutron_client().list_networks()['networks']
-        return next((n for n in networks if n['name'] == network_name), None)
-    except Exception:
-        log.exception("Error [get_instance_by_id(nova_client, '%s')]",
-                      network_name)
-
-
-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 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:
-        log.error("Error [create_neutron_net(neutron_client)]")
-        raise Exception("operation error")
+def create_neutron_net(shade_client, network_name, shared=False,
+                       admin_state_up=True, external=False, provider=None,
+                       project_id=None):
+    """Create a neutron network.
+
+    :param network_name:(string) name of the network being created.
+    :param shared:(bool) whether the network is shared.
+    :param admin_state_up:(bool) set the network administrative state.
+    :param external:(bool) whether this network is externally accessible.
+    :param provider:(dict) a dict of network provider options.
+    :param project_id:(string) specify the project ID this network
+                      will be created on (admin-only).
+    :returns:(string) the network id.
+    """
+    try:
+        networks = shade_client.create_network(
+            name=network_name, shared=shared, admin_state_up=admin_state_up,
+            external=external, provider=provider, project_id=project_id)
+        return networks['id']
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [create_neutron_net(shade_client)]."
+                  "Exception message, '%s'", o_exc.orig_message)
         return None
 
 
-def delete_neutron_net(neutron_client, network_id):      # pragma: no cover
+def delete_neutron_net(shade_client, network_id):
     try:
-        neutron_client.delete_network(network_id)
-        return True
-    except Exception:
-        log.error("Error [delete_neutron_net(neutron_client, '%s')]" % network_id)
+        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']
-    except Exception:
-        log.error("Error [create_neutron_subnet")
-        raise Exception("operation error")
+def create_neutron_subnet(shade_client, network_name_or_id, cidr=None,
+                          ip_version=4, enable_dhcp=False, subnet_name=None,
+                          tenant_id=None, allocation_pools=None,
+                          gateway_ip=None, disable_gateway_ip=False,
+                          dns_nameservers=None, host_routes=None,
+                          ipv6_ra_mode=None, ipv6_address_mode=None,
+                          use_default_subnetpool=False):
+    """Create a subnet on a specified network.
+
+    :param network_name_or_id:(string) the unique name or ID of the
+                              attached network. If a non-unique name is
+                              supplied, an exception is raised.
+    :param cidr:(string) the CIDR.
+    :param ip_version:(int) the IP version.
+    :param enable_dhcp:(bool) whether DHCP is enable.
+    :param subnet_name:(string) the name of the subnet.
+    :param tenant_id:(string) the ID of the tenant who owns the network.
+    :param allocation_pools: A list of dictionaries of the start and end
+                            addresses for the allocation pools.
+    :param gateway_ip:(string) the gateway IP address.
+    :param disable_gateway_ip:(bool) whether gateway IP address is enabled.
+    :param dns_nameservers: A list of DNS name servers for the subnet.
+    :param host_routes: A list of host route dictionaries for the subnet.
+    :param ipv6_ra_mode:(string) IPv6 Router Advertisement mode.
+                        Valid values are: 'dhcpv6-stateful',
+                        'dhcpv6-stateless', or 'slaac'.
+    :param ipv6_address_mode:(string) IPv6 address mode.
+                             Valid values are: 'dhcpv6-stateful',
+                             'dhcpv6-stateless', or 'slaac'.
+    :param use_default_subnetpool:(bool) use the default subnetpool for
+                                  ``ip_version`` to obtain a CIDR. It is
+                                  required to pass ``None`` to the ``cidr``
+                                  argument when enabling this option.
+    :returns:(string) the subnet id.
+    """
+    try:
+        subnet = shade_client.create_subnet(
+            network_name_or_id, cidr=cidr, ip_version=ip_version,
+            enable_dhcp=enable_dhcp, subnet_name=subnet_name,
+            tenant_id=tenant_id, allocation_pools=allocation_pools,
+            gateway_ip=gateway_ip, disable_gateway_ip=disable_gateway_ip,
+            dns_nameservers=dns_nameservers, host_routes=host_routes,
+            ipv6_ra_mode=ipv6_ra_mode, ipv6_address_mode=ipv6_address_mode,
+            use_default_subnetpool=use_default_subnetpool)
+        return subnet['id']
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [create_neutron_subnet(shade_client)]. "
+                  "Exception message: %s", o_exc.orig_message)
         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']
-    except Exception:
-        log.error("Error [create_neutron_router(neutron_client)]")
-        raise Exception("operation error")
-        return None
+def create_neutron_router(shade_client, name=None, admin_state_up=True,
+                          ext_gateway_net_id=None, enable_snat=None,
+                          ext_fixed_ips=None, project_id=None):
+    """Create a logical router.
 
+    :param name:(string) the router name.
+    :param admin_state_up:(bool) the administrative state of the router.
+    :param ext_gateway_net_id:(string) network ID for the external gateway.
+    :param enable_snat:(bool) enable Source NAT (SNAT) attribute.
+    :param ext_fixed_ips: List of dictionaries of desired IP and/or subnet
+                          on the external network.
+    :param project_id:(string) project ID for the router.
 
-def delete_neutron_router(neutron_client, router_id):      # pragma: no cover
+    :returns:(string) the router id.
+    """
     try:
-        neutron_client.delete_router(router=router_id)
-        return True
-    except Exception:
-        log.error("Error [delete_neutron_router(neutron_client, '%s')]" % router_id)
-        return False
+        router = shade_client.create_router(
+            name, admin_state_up, ext_gateway_net_id, enable_snat,
+            ext_fixed_ips, project_id)
+        return router['id']
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [create_neutron_router(shade_client)]. "
+                  "Exception message: %s", o_exc.orig_message)
 
 
-def remove_gateway_router(neutron_client, router_id):      # pragma: no cover
+def delete_neutron_router(shade_client, router_id):
     try:
-        neutron_client.remove_gateway_router(router_id)
-        return True
-    except Exception:
-        log.error("Error [remove_gateway_router(neutron_client, '%s')]" % router_id)
+        return shade_client.delete_router(router_id)
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [delete_neutron_router(shade_client, '%s')]. "
+                  "Exception message: %s", router_id, o_exc.orig_message)
         return False
 
 
-def remove_interface_router(neutron_client, router_id, subnet_id,
-                            **json_body):      # pragma: no cover
-    json_body.update({"subnet_id": subnet_id})
+def remove_gateway_router(neutron_client, router_id):      # pragma: no cover
     try:
-        neutron_client.remove_interface_router(router=router_id,
-                                               body=json_body)
+        neutron_client.remove_gateway_router(router_id)
         return True
-    except Exception:
-        log.error("Error [remove_interface_router(neutron_client, '%s', "
-                  "'%s')]" % (router_id, subnet_id))
+    except Exception:  # pylint: disable=broad-except
+        log.error("Error [remove_gateway_router(neutron_client, '%s')]",
+                  router_id)
         return False
 
 
-def create_floating_ip(neutron_client, extnet_id):      # pragma: no cover
-    props = {'floating_network_id': extnet_id}
-    try:
-        ip_json = neutron_client.create_floatingip({'floatingip': props})
-        fip_addr = ip_json['floatingip']['floating_ip_address']
-        fip_id = ip_json['floatingip']['id']
-    except Exception:
-        log.error("Error [create_floating_ip(neutron_client)]")
-        return None
-    return {'fip_addr': fip_addr, 'fip_id': fip_id}
+def remove_router_interface(shade_client, router, subnet_id=None,
+                            port_id=None):
+    """Detach a subnet from an internal router interface.
 
+    At least one of subnet_id or port_id must be supplied. If you specify both
+    subnet and port ID, the subnet ID must correspond to the subnet ID of the
+    first IP address on the port specified by the port ID.
+    Otherwise an error occurs.
 
-def delete_floating_ip(nova_client, floatingip_id):      # pragma: no cover
+    :param router: The dict object of the router being changed
+    :param subnet_id:(string) The ID of the subnet to use for the interface
+    :param port_id:(string) The ID of the port to use for the interface
+    :returns: True on success
+    """
     try:
-        nova_client.floating_ips.delete(floatingip_id)
+        shade_client.remove_router_interface(
+            router, subnet_id=subnet_id, port_id=port_id)
         return True
-    except Exception:
-        log.error("Error [delete_floating_ip(nova_client, '%s')]" % floatingip_id)
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [remove_interface_router(shade_client)]. "
+                  "Exception message: %s", o_exc.orig_message)
         return False
 
 
-def get_security_groups(neutron_client):      # pragma: no cover
-    try:
-        security_groups = neutron_client.list_security_groups()[
-            'security_groups']
-        return security_groups
-    except Exception:
-        log.error("Error [get_security_groups(neutron_client)]")
-        return None
-
-
-def get_security_group_id(neutron_client, sg_name):      # pragma: no cover
-    security_groups = get_security_groups(neutron_client)
-    id = ''
-    for sg in security_groups:
-        if sg['name'] == sg_name:
-            id = sg['id']
-            break
-    return id
-
-
-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']
-    except Exception:
-        log.error("Error [create_security_group(neutron_client, '%s', "
-                  "'%s')]" % (sg_name, sg_description))
-        return None
+def create_floating_ip(shade_client, network_name_or_id=None, server=None,
+                       fixed_address=None, nat_destination=None,
+                       port=None, wait=False, timeout=60):
+    """Allocate a new floating IP from a network or a pool.
+
+    :param network_name_or_id: Name or ID of the network
+                               that the floating IP should come from.
+    :param server: Server dict for the server to create
+                  the IP for and to which it should be attached.
+    :param fixed_address: Fixed IP to attach the floating ip to.
+    :param nat_destination: Name or ID of the network
+                           that the fixed IP to attach the floating
+                           IP to should be on.
+    :param port: The port ID that the floating IP should be
+                attached to. Specifying a port conflicts with specifying a
+                server,fixed_address or nat_destination.
+    :param wait: Whether to wait for the IP to be active.Only applies
+                if a server is provided.
+    :param timeout: How long to wait for the IP to be active.Only
+                   applies if a server is provided.
+
+    :returns:Floating IP id and address
+    """
+    try:
+        fip = shade_client.create_floating_ip(
+            network=network_name_or_id, server=server,
+            fixed_address=fixed_address, nat_destination=nat_destination,
+            port=port, wait=wait, timeout=timeout)
+        return {'fip_addr': fip['floating_ip_address'], 'fip_id': fip['id']}
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [create_floating_ip(shade_client)]. "
+                  "Exception message: %s", o_exc.orig_message)
+
+
+def delete_floating_ip(shade_client, floating_ip_id, retry=1):
+    try:
+        return shade_client.delete_floating_ip(floating_ip_id=floating_ip_id,
+                                               retry=retry)
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [delete_floating_ip(shade_client,'%s')]. "
+                  "Exception message: %s", floating_ip_id, o_exc.orig_message)
+        return False
 
 
-def create_secgroup_rule(neutron_client, sg_id, direction, protocol,
-                         port_range_min=None, port_range_max=None,
-                         **json_body):      # pragma: no cover
-    # We create a security group in 2 steps
-    # 1 - we check the format and set the json body accordingly
-    # 2 - we call neturon client to create the security group
-
-    # Format check
-    json_body.update({'security_group_rule': {'direction': direction,
-                     'security_group_id': sg_id, 'protocol': protocol}})
-    # parameters may be
-    # - both None => we do nothing
-    # - both Not None => we add them to the json description
-    # but one cannot be None is the other is not None
-    if (port_range_min is not None and port_range_max is not None):
-        # add port_range in json description
-        json_body['security_group_rule']['port_range_min'] = port_range_min
-        json_body['security_group_rule']['port_range_max'] = port_range_max
-        log.debug("Security_group format set (port range included)")
-    else:
-        # either both port range are set to None => do nothing
-        # or one is set but not the other => log it and return False
-        if port_range_min is None and port_range_max is None:
-            log.debug("Security_group format set (no port range mentioned)")
-        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))
-            return False
-
-    # Create security group using neutron client
-    try:
-        neutron_client.create_security_group_rule(json_body)
+def create_security_group_rule(shade_client, secgroup_name_or_id,
+                               port_range_min=None, port_range_max=None,
+                               protocol=None, remote_ip_prefix=None,
+                               remote_group_id=None, direction='ingress',
+                               ethertype='IPv4', project_id=None):
+    """Create a new security group rule
+
+    :param secgroup_name_or_id:(string) The security group name or ID to
+                               associate with this security group rule. If a
+                               non-unique group name is given, an exception is
+                               raised.
+    :param port_range_min:(int) The minimum port number in the range that is
+                          matched by the security group rule. If the protocol
+                          is TCP or UDP, this value must be less than or equal
+                          to the port_range_max attribute value. If nova is
+                          used by the cloud provider for security groups, then
+                          a value of None will be transformed to -1.
+    :param port_range_max:(int) The maximum port number in the range that is
+                          matched by the security group rule. The
+                          port_range_min attribute constrains the
+                          port_range_max attribute. If nova is used by the
+                          cloud provider for security groups, then a value of
+                          None will be transformed to -1.
+    :param protocol:(string) The protocol that is matched by the security group
+                    rule. Valid values are None, tcp, udp, and icmp.
+    :param remote_ip_prefix:(string) The remote IP prefix to be associated with
+                            this security group rule. This attribute matches
+                            the specified IP prefix as the source IP address of
+                            the IP packet.
+    :param remote_group_id:(string) The remote group ID to be associated with
+                           this security group rule.
+    :param direction:(string) Ingress or egress: The direction in which the
+                     security group rule is applied.
+    :param ethertype:(string) Must be IPv4 or IPv6, and addresses represented
+                     in CIDR must match the ingress or egress rules.
+    :param project_id:(string) Specify the project ID this security group will
+                      be created on (admin-only).
+
+    :returns: True on success.
+    """
+
+    try:
+        shade_client.create_security_group_rule(
+            secgroup_name_or_id, port_range_min=port_range_min,
+            port_range_max=port_range_max, protocol=protocol,
+            remote_ip_prefix=remote_ip_prefix, remote_group_id=remote_group_id,
+            direction=direction, ethertype=ethertype, project_id=project_id)
         return True
-    except Exception:
-        log.exception("Impossible to create_security_group_rule,"
-                      "security group rule probably already exists")
+    except exc.OpenStackCloudException as op_exc:
+        log.error("Failed to create_security_group_rule(shade_client). "
+                  "Exception message: %s", op_exc.orig_message)
         return False
 
 
-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 != '':
-        log.info("Using existing security group '%s'..." % sg_name)
-    else:
-        log.info("Creating security group  '%s'..." % sg_name)
-        SECGROUP = create_security_group(neutron_client,
-                                         sg_name,
-                                         sg_description)
-        if not SECGROUP:
-            log.error("Failed to create the security group...")
-            return None
-
-        sg_id = SECGROUP['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)
-        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)
-        if not create_secgroup_rule(
-                neutron_client, sg_id, 'ingress', 'tcp', '22', '22'):
-            log.error("Failed to create the security group rule...")
-            return None
-
-        if not create_secgroup_rule(
-                neutron_client, sg_id, 'egress', 'tcp', '22', '22'):
-            log.error("Failed to create the security group rule...")
-            return None
-    return sg_id
+def create_security_group_full(shade_client, sg_name,
+                               sg_description, project_id=None):
+    security_group = shade_client.get_security_group(sg_name)
+
+    if security_group:
+        log.info("Using existing security group '%s'...", sg_name)
+        return security_group['id']
+
+    log.info("Creating security group  '%s'...", sg_name)
+    try:
+        security_group = shade_client.create_security_group(
+            sg_name, sg_description, project_id=project_id)
+    except (exc.OpenStackCloudException,
+            exc.OpenStackCloudUnavailableFeature) as op_exc:
+        log.error("Error [create_security_group(shade_client, %s, %s)]. "
+                  "Exception message: %s", sg_name, sg_description,
+                  op_exc.orig_message)
+        return
+
+    log.debug("Security group '%s' with ID=%s created successfully.",
+              security_group['name'], security_group['id'])
+
+    log.debug("Adding ICMP rules in security group '%s'...", sg_name)
+    if not create_security_group_rule(shade_client, security_group['id'],
+                                      direction='ingress', protocol='icmp'):
+        log.error("Failed to create the security group rule...")
+        shade_client.delete_security_group(sg_name)
+        return
+
+    log.debug("Adding SSH rules in security group '%s'...", sg_name)
+    if not create_security_group_rule(shade_client, security_group['id'],
+                                      direction='ingress', protocol='tcp',
+                                      port_range_min='22',
+                                      port_range_max='22'):
+        log.error("Failed to create the security group rule...")
+        shade_client.delete_security_group(sg_name)
+        return
+
+    if not create_security_group_rule(shade_client, security_group['id'],
+                                      direction='egress', protocol='tcp',
+                                      port_range_min='22',
+                                      port_range_max='22'):
+        log.error("Failed to create the security group rule...")
+        shade_client.delete_security_group(sg_name)
+        return
+    return security_group['id']
 
 
 # *********************************************
 #   GLANCE
 # *********************************************
-def get_image_id(glance_client, image_name):    # pragma: no cover
-    images = glance_client.images.list()
-    return next((i.id for i in images if i.name == image_name), None)
-
-
-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):
-        log.error("Error: file %s does not exist." % file_path)
-        return None
-    try:
-        image_id = get_image_id(glance_client, image_name)
+def create_image(shade_client, name, filename=None, container='images',
+                 md5=None, sha256=None, disk_format=None,
+                 container_format=None, disable_vendor_agent=True,
+                 wait=False, timeout=3600, allow_duplicates=False, meta=None,
+                 volume=None, **kwargs):
+    """Upload an image.
+
+    :param name:(str) Name of the image to create. If it is a pathname of an
+                image, the name will be constructed from the extensionless
+                basename of the path.
+    :param filename:(str) The path to the file to upload, if needed.
+    :param container:(str) Name of the container in swift where images should
+                     be uploaded for import if the cloud requires such a thing.
+    :param md5:(str) md5 sum of the image file. If not given, an md5 will
+            be calculated.
+    :param sha256:(str) sha256 sum of the image file. If not given, an md5
+                  will be calculated.
+    :param disk_format:(str) The disk format the image is in.
+    :param container_format:(str) The container format the image is in.
+    :param disable_vendor_agent:(bool) Whether or not to append metadata
+                                flags to the image to inform the cloud in
+                                question to not expect a vendor agent to be running.
+    :param wait:(bool) If true, waits for image to be created.
+    :param timeout:(str) Seconds to wait for image creation.
+    :param allow_duplicates:(bool) If true, skips checks that enforce unique
+                            image name.
+    :param meta:(dict) A dict of key/value pairs to use for metadata that
+                bypasses automatic type conversion.
+    :param volume:(str) Name or ID or volume object of a volume to create an
+                  image from.
+    Additional kwargs will be passed to the image creation as additional
+    metadata for the image and will have all values converted to string
+    except for min_disk, min_ram, size and virtual_size which will be
+    converted to int.
+    If you are sure you have all of your data types correct or have an
+    advanced need to be explicit, use meta. If you are just a normal
+    consumer, using kwargs is likely the right choice.
+    If a value is in meta and kwargs, meta wins.
+    :returns: Image id
+    """
+    try:
+        image_id = shade_client.get_image_id(name)
         if image_id is not None:
-            log.info("Image %s already exists." % image_name)
-        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_id = image.id
-            with open(file_path) as image_data:
-                glance_client.images.upload(image_id, image_data)
+            log.info("Image %s already exists.", name)
+            return image_id
+        log.info("Creating image '%s'", name)
+        image = shade_client.create_image(
+            name, filename=filename, container=container, md5=md5, sha256=sha256,
+            disk_format=disk_format, container_format=container_format,
+            disable_vendor_agent=disable_vendor_agent, wait=wait, timeout=timeout,
+            allow_duplicates=allow_duplicates, meta=meta, volume=volume, **kwargs)
+        image_id = image["id"]
         return image_id
-    except Exception:
-        log.error("Error [create_glance_image(glance_client, '%s', '%s', '%s')]",
-                  image_name, file_path, public)
-        return None
+    except exc.OpenStackCloudException as op_exc:
+        log.error("Failed to create_image(shade_client). "
+                  "Exception message: %s", op_exc.orig_message)
 
 
-def delete_image(glance_client, image_id):    # pragma: no cover
+def delete_image(shade_client, name_or_id, wait=False, timeout=3600,
+                 delete_objects=True):
     try:
-        glance_client.images.delete(image_id)
+        return shade_client.delete_image(name_or_id, wait=wait,
+                                         timeout=timeout,
+                                         delete_objects=delete_objects)
 
-    except Exception:
-        log.exception("Error [delete_flavor(glance_client, %s)]", image_id)
+    except exc.OpenStackCloudException as op_exc:
+        log.error("Failed to delete_image(shade_client). "
+                  "Exception message: %s", op_exc.orig_message)
+        return False
+
+
+def list_images(shade_client=None):
+    if shade_client is None:
+        shade_client = get_shade_client()
+
+    try:
+        return shade_client.list_images()
+    except exc.OpenStackCloudException as o_exc:
+        log.error("Error [list_images(shade_client)]."
+                  "Exception message, '%s'", o_exc.orig_message)
         return False
-    else:
-        return True
 
 
 # *********************************************
 #   CINDER
 # *********************************************
-def get_volume_id(volume_name):    # pragma: no cover
-    volumes = get_cinder_client().volumes.list()
-    return next((v.id for v in volumes if v.name == volume_name), None)
-
-
-def create_volume(cinder_client, volume_name, volume_size,
-                  volume_image=False):    # pragma: no cover
-    try:
-        if volume_image:
-            volume = cinder_client.volumes.create(name=volume_name,
-                                                  size=volume_size,
-                                                  imageRef=volume_image)
-        else:
-            volume = cinder_client.volumes.create(name=volume_name,
-                                                  size=volume_size)
-        return volume
-    except Exception:
-        log.exception("Error [create_volume(cinder_client, %s)]",
-                      (volume_name, volume_size))
-        return None
+def get_volume_id(shade_client, volume_name):
+    return shade_client.get_volume_id(volume_name)
 
 
-def delete_volume(cinder_client, volume_id, forced=False):      # pragma: no cover
-    try:
-        if forced:
-            try:
-                cinder_client.volumes.detach(volume_id)
-            except:
-                log.error(sys.exc_info()[0])
-            cinder_client.volumes.force_delete(volume_id)
-        else:
-            while True:
-                volume = get_cinder_client().volumes.get(volume_id)
-                if volume.status.lower() == 'available':
-                    break
-            cinder_client.volumes.delete(volume_id)
-        return True
-    except Exception:
-        log.exception("Error [delete_volume(cinder_client, '%s')]" % volume_id)
-        return False
+def get_volume(shade_client, name_or_id, filters=None):
+    """Get a volume by name or ID.
 
+    :param name_or_id: Name or ID of the volume.
+    :param filters: A dictionary of meta data to use for further filtering.
 
-def detach_volume(server_id, volume_id):      # pragma: no cover
-    try:
-        get_nova_client().volumes.delete_server_volume(server_id, volume_id)
-        return True
-    except Exception:
-        log.exception("Error [detach_server_volume(nova_client, '%s', '%s')]",
-                      server_id, volume_id)
-        return False
-# *********************************************
-#   HEAT
-# *********************************************
+    :returns: A volume ``munch.Munch`` or None if no matching volume is found.
+    """
+    return shade_client.get_volume(name_or_id, filters=filters)
+
+
+def create_volume(shade_client, size, wait=True, timeout=None,
+                  image=None, **kwargs):
+    """Create a volume.
 
+    :param size: Size, in GB of the volume to create.
+    :param name: (optional) Name for the volume.
+    :param description: (optional) Name for the volume.
+    :param wait: If true, waits for volume to be created.
+    :param timeout: Seconds to wait for volume creation. None is forever.
+    :param image: (optional) Image name, ID or object from which to create
+                  the volume.
 
-def get_stack(heat_stack_id):    # pragma: no cover
+    :returns: The created volume object.
+
+    """
     try:
-        client = get_heat_client()
-        return client.stacks.get(heat_stack_id)
-    except Exception as e:
-        log.exception("Error [get_stack(heat_stack_id)]", e)
+        return shade_client.create_volume(size, wait=wait, timeout=timeout,
+                                          image=image, **kwargs)
+    except (exc.OpenStackCloudException, exc.OpenStackCloudTimeout) as op_exc:
+        log.error("Failed to create_volume(shade_client). "
+                  "Exception message: %s", op_exc.orig_message)
+
+
+def delete_volume(shade_client, name_or_id=None, wait=True, timeout=None):
+    """Delete a volume.
 
+    :param name_or_id:(string) Name or unique ID of the volume.
+    :param wait:(bool) If true, waits for volume to be deleted.
+    :param timeout:(string) Seconds to wait for volume deletion. None is forever.
 
-def get_stack_resources(heat_stack_id):    # pragma: no cover
+    :return:  True on success, False otherwise.
+    """
     try:
-        client = get_heat_client()
-        return client.resources.list(heat_stack_id)
-    except Exception as e:
-        log.exception("Error [get_stack_resources(heat_stack_id)]: %s", e)
+        return shade_client.delete_volume(name_or_id=name_or_id,
+                                          wait=wait, timeout=timeout)
+    except (exc.OpenStackCloudException, exc.OpenStackCloudTimeout) as o_exc:
+        log.error("Error [delete_volume(shade_client,'%s')]. "
+                  "Exception message: %s", name_or_id, o_exc.orig_message)
+        return False
+
 
+def detach_volume(shade_client, server_name_or_id, volume_name_or_id,
+                  wait=True, timeout=None):
+    """Detach a volume from a server.
 
-def get_stack_vms(heat_stack_id):    # pragma: no cover
-    resources = get_stack_resources(heat_stack_id)
-    ret_vms = []
-    for resource in resources:
-        if resource.resource_type == "OS::Nova::Server":
-            ret_vms.append(resource)
-    return ret_vms
+    :param server_name_or_id: The server name or id to detach from.
+    :param volume_name_or_id: The volume name or id to detach.
+    :param wait: If true, waits for volume to be detached.
+    :param timeout: Seconds to wait for volume detachment. None is forever.
+
+    :return: True on success.
+    """
+    try:
+        volume = shade_client.get_volume(volume_name_or_id)
+        server = get_server(shade_client, name_or_id=server_name_or_id)
+        shade_client.detach_volume(server, volume, wait=wait, timeout=timeout)
+        return True
+    except (exc.OpenStackCloudException, exc.OpenStackCloudTimeout) as o_exc:
+        log.error("Error [detach_volume(shade_client)]. "
+                  "Exception message: %s", o_exc.orig_message)
+        return False
diff --git a/vnftest/common/utils.py b/vnftest/common/utils.py
index dfd32d5..b3f0c05 100644
--- a/vnftest/common/utils.py
+++ b/vnftest/common/utils.py
@@ -204,16 +204,6 @@ def result_handler(status, data):
     return jsonify(result)
 
 
-def change_obj_to_dict(obj):
-    dic = {}
-    for k, v in vars(obj).items():
-        try:
-            vars(v)
-        except TypeError:
-            dic.update({k: v})
-    return dic
-
-
 def set_dict_value(dic, keys, value):
     return_dic = dic
 
@@ -413,9 +403,26 @@ class dotdict(dict):
     __delattr__ = dict.__delitem__
 
 
+def deep_dotdict(obj):
+    if isinstance(obj, dict):
+        dot_dict = {}
+        for k, v in obj.items():
+            if isinstance(k, basestring) and not k.startswith('_'):
+                v = deep_dotdict(v)
+                dot_dict[k] = v
+        return dotdict(dot_dict)
+    if isinstance(obj, list):
+        new_list = []
+        for element in obj:
+            element = deep_dotdict(element)
+            new_list.append(element)
+        return new_list
+    return obj
+
+
 def normalize_data_struct(obj):
-    if isinstance(obj, basestring):
-        return [obj]
+    if obj is None:
+        return None
     if isinstance(obj, list):
         nomalized_list = []
         for element in obj:
@@ -424,11 +431,15 @@ def normalize_data_struct(obj):
         return nomalized_list
     if isinstance(obj, dict):
         normalized_dict = {}
-        for k, v in obj:
-            v = normalize_data_struct(v)
-            normalized_dict[k] = v
+        for k, v in obj.items():
+            if isinstance(k, basestring) and not k.startswith('_'):
+                v = normalize_data_struct(v)
+                normalized_dict[k] = v
         return normalized_dict
-    return change_obj_to_dict(obj)
+    # return obj if it is string, integer, bool ect.
+    if not hasattr(obj, '__dict__'):
+        return obj
+    return normalize_data_struct(obj.__dict__)
 
 
 def xml_to_dict(xml_str):
@@ -510,7 +521,6 @@ def format(in_obj, params):
     if not isinstance(in_obj, basestring):
         return in_obj
 
-    dotdict(params)
     ret_str = ""
     ret_obj = None
     for literal_text, field_name, format_spec, conversion in \
@@ -522,7 +532,7 @@ def format(in_obj, params):
             try:
                 value = tmp_dict[field_name]
             except KeyError:
-                tmp_dict = dotdict(tmp_dict)
+                tmp_dict = deep_dotdict(tmp_dict)
                 field_name = '{' + field_name + '}'
                 value = field_name.format(**tmp_dict)
             if isinstance(value, basestring):
diff --git a/vnftest/contexts/base.py b/vnftest/contexts/base.py
index 29e3a19..c10732a 100644
--- a/vnftest/contexts/base.py
+++ b/vnftest/contexts/base.py
@@ -13,27 +13,69 @@
 ##############################################################################
 import abc
 import six
-from vnftest.common import openstack_utils
 
 import vnftest.common.utils as utils
-import yaml
 import logging
+
+from vnftest.common import constants
+
 LOG = logging.getLogger(__name__)
 
 
+class Flags(object):
+    """Class to represent the status of the flags in a context"""
+
+    _FLAGS = {'no_setup': False,
+              'no_teardown': False,
+              'os_cloud_config': constants.OS_CLOUD_DEFAULT_CONFIG}
+
+    def __init__(self, **kwargs):
+        for name, value in self._FLAGS.items():
+            setattr(self, name, value)
+
+        for name, value in ((name, value) for (name, value) in kwargs.items()
+                            if name in self._FLAGS):
+            setattr(self, name, value)
+
+    def parse(self, **kwargs):
+        """Read in values matching the flags stored in this object"""
+        if not kwargs:
+            return
+
+        for name, value in ((name, value) for (name, value) in kwargs.items()
+                            if name in self._FLAGS):
+            setattr(self, name, value)
+
+
 @six.add_metaclass(abc.ABCMeta)
 class Context(object):
     """Class that represents a context in the logical model"""
-    list = []
+    _list = []
 
     def __init__(self):
-        Context.list.append(self)
+        Context._list.append(self)
+        self._flags = Flags()
         self._task_id = None
         self._name = None
+        self._name_task_id = None
 
     def init(self, attrs):
         self._task_id = attrs['task_id']
         self._name = attrs['name']
+        self._flags.parse(**attrs.get('flags', {}))
+        self._name_task_id = '{}-{}'.format(
+            self._name, self._task_id[:8])
+
+    @property
+    def name(self):
+        if self._flags.no_setup or self._flags.no_teardown:
+            return self._name
+        else:
+            return self._name_task_id
+
+    @property
+    def assigned_name(self):
+        return self._name
 
     @staticmethod
     def get_cls(context_type):
@@ -50,7 +92,7 @@ class Context(object):
         return Context.get_cls(context_type)()
 
     def _delete_context(self):
-        Context.list.remove(self)
+        Context._list.remove(self)
 
     @abc.abstractmethod
     def deploy(self):
diff --git a/vnftest/contexts/heat.py b/vnftest/contexts/heat.py
new file mode 100644
index 0000000..f6ca611
--- /dev/null
+++ b/vnftest/contexts/heat.py
@@ -0,0 +1,591 @@
+##############################################################################
+# Copyright 2018 EuropeanSoftwareMarketingLtd.
+# ===================================================================
+#  Licensed under the ApacheLicense, Version2.0 (the"License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under
+# the License
+##############################################################################
+# vnftest comment: this is a modified copy of
+# yardstick/benchmark/contexts/heat.py
+
+import collections
+import logging
+import os
+import errno
+from collections import OrderedDict
+
+import ipaddress
+import pkg_resources
+
+from vnftest.contexts.base import Context
+from vnftest.contexts.model import Network
+from vnftest.contexts.model import PlacementGroup, ServerGroup
+from vnftest.contexts.model import Server
+from vnftest.contexts.model import update_scheduler_hints
+from vnftest.common import exceptions as y_exc
+from vnftest.common.openstack_utils import get_shade_client
+from vnftest.orchestrator.heat import HeatStack
+from vnftest.orchestrator.heat import HeatTemplate
+from vnftest.common import constants as consts
+from vnftest.common import utils
+from vnftest.common.utils import source_env
+from vnftest.common import openstack_utils
+
+LOG = logging.getLogger(__name__)
+
+DEFAULT_HEAT_TIMEOUT = 3600
+
+
+def join_args(sep, *args):
+    return sep.join(args)
+
+
+def h_join(*args):
+    return '-'.join(args)
+
+
+class HeatContext(Context):
+    """Class that represents a context in the logical model"""
+
+    __context_type__ = "Heat"
+
+    def __init__(self):
+        self.stack = None
+        self.networks = OrderedDict()
+        self.heat_timeout = None
+        self.servers = {}
+        self.placement_groups = []
+        self.server_groups = []
+        self.keypair_name = None
+        self.secgroup_name = None
+        self.security_group = None
+        self.attrs = {}
+        self._image = None
+        self._flavor = None
+        self.flavors = set()
+        self._user = None
+        self.template_file = None
+        self.heat_parameters = None
+        self.heat_timeout = None
+        self.key_filename = None
+        self._shade_client = None
+        self._operator_client = None
+        self.nodes = []
+        self.controllers = []
+        self.computes = []
+        self.baremetals = []
+        super(HeatContext, self).__init__()
+
+    @staticmethod
+    def assign_external_network(networks):
+        if networks:
+            sorted_networks = sorted(networks.items())
+            external_network = os.environ.get("EXTERNAL_NETWORK", "net04_ext")
+
+            have_external_network = any(net.get("external_network") for net in networks.values())
+            if not have_external_network:
+                # try looking for mgmt network first
+                try:
+                    networks['mgmt']["external_network"] = external_network
+                except KeyError:
+                    if sorted_networks:
+                        # otherwise assign it to first network using os.environ
+                        sorted_networks[0][1]["external_network"] = external_network
+
+            return sorted_networks
+        return networks
+
+    def init(self, attrs):
+        """Initializes itself from the supplied arguments"""
+        super(HeatContext, self).init(attrs)
+
+        self.check_environment()
+        self._user = attrs.get("user")
+
+        self.template_file = attrs.get("heat_template")
+
+        self._shade_client = openstack_utils.get_shade_client()
+        self._operator_client = openstack_utils.get_shade_operator_client()
+
+        self.heat_timeout = attrs.get("timeout", DEFAULT_HEAT_TIMEOUT)
+        if self.template_file:
+            self.heat_parameters = attrs.get("heat_parameters")
+            return
+
+        self.keypair_name = None  # h_join(self.name, "key")
+
+        self.secgroup_name = None  # h_join(self.name, "secgroup")
+
+        self.security_group = attrs.get("security_group")
+
+        self._image = attrs.get("image")
+
+        self._flavor = attrs.get("flavor")
+
+        self.placement_groups = [PlacementGroup(name, self, pg_attrs["policy"])
+                                 for name, pg_attrs in attrs.get(
+                                 "placement_groups", {}).items()]
+
+        self.server_groups = [ServerGroup(name, self, sg_attrs["policy"])
+                              for name, sg_attrs in attrs.get(
+                              "server_groups", {}).items()]
+
+        # we have to do this first, because we are injecting external_network
+        # into the dict
+        networks = attrs.get("networks", {})
+        sorted_networks = self.assign_external_network(networks)
+
+        if sorted_networks:
+            self.networks = OrderedDict(
+                (name, Network(name, self, net_attrs)) for name, net_attrs in
+                sorted_networks)
+
+        for name, server_attrs in sorted(attrs["servers"].items()):
+            server = Server(name, self, server_attrs)
+            self.servers[name] = server
+
+        self.attrs = attrs
+
+    def check_environment(self):
+        try:
+            os.environ['OS_AUTH_URL']
+        except KeyError:
+            try:
+                source_env(consts.OPENRC)
+            except IOError as e:
+                if e.errno != errno.EEXIST:
+                    LOG.error('OPENRC file not found')
+                    raise
+                else:
+                    LOG.error('OS_AUTH_URL not found')
+
+    @property
+    def image(self):
+        """returns application's default image name"""
+        return self._image
+
+    @property
+    def flavor(self):
+        """returns application's default flavor name"""
+        return self._flavor
+
+    @property
+    def user(self):
+        """return login user name corresponding to image"""
+        return self._user
+
+    def _add_resources_to_template(self, template):
+        """add to the template the resources represented by this context"""
+
+        if self.flavor:
+            if isinstance(self.flavor, dict):
+                flavor = self.flavor.setdefault("name", self.name + "-flavor")
+                template.add_flavor(**self.flavor)
+                self.flavors.add(flavor)
+
+        # template.add_keypair(self.keypair_name, self.name)
+        # template.add_security_group(self.secgroup_name, self.security_group)
+
+        for network in self.networks.values():
+            # Using existing network
+            if network.is_existing():
+                continue
+            template.add_network(network.stack_name,
+                                 network.physical_network,
+                                 network.provider,
+                                 network.segmentation_id,
+                                 network.port_security_enabled,
+                                 network.network_type)
+            template.add_subnet(network.subnet_stack_name, network.stack_name,
+                                network.subnet_cidr,
+                                network.enable_dhcp,
+                                network.gateway_ip)
+
+            if network.router:
+                template.add_router(network.router.stack_name,
+                                    network.router.external_gateway_info,
+                                    network.subnet_stack_name)
+                template.add_router_interface(network.router.stack_if_name,
+                                              network.router.stack_name,
+                                              network.subnet_stack_name)
+
+        # create a list of servers sorted by increasing no of placement groups
+        list_of_servers = sorted(self.servers.itervalues(),
+                                 key=lambda s: len(s.placement_groups))
+
+        #
+        # add servers with scheduler hints derived from placement groups
+        #
+
+        # create list of servers with availability policy
+        availability_servers = []
+        for server in list_of_servers:
+            for pg in server.placement_groups:
+                if pg.policy == "availability":
+                    availability_servers.append(server)
+                    break
+
+        for server in availability_servers:
+            if isinstance(server.flavor, dict):
+                try:
+                    self.flavors.add(server.flavor["name"])
+                except KeyError:
+                    self.flavors.add(h_join(server.stack_name, "flavor"))
+
+        # add servers with availability policy
+        added_servers = []
+        for server in availability_servers:
+            scheduler_hints = {}
+            for pg in server.placement_groups:
+                update_scheduler_hints(scheduler_hints, added_servers, pg)
+            # workaround for openstack nova bug, check JIRA: vnftest-200
+            # for details
+            if len(availability_servers) == 2:
+                if not scheduler_hints["different_host"]:
+                    scheduler_hints.pop("different_host", None)
+                    server.add_to_template(template,
+                                           list(self.networks.values()),
+                                           scheduler_hints)
+                else:
+                    scheduler_hints["different_host"] = \
+                        scheduler_hints["different_host"][0]
+                    server.add_to_template(template,
+                                           list(self.networks.values()),
+                                           scheduler_hints)
+            else:
+                server.add_to_template(template,
+                                       list(self.networks.values()),
+                                       scheduler_hints)
+            added_servers.append(server.stack_name)
+
+        # create list of servers with affinity policy
+        affinity_servers = []
+        for server in list_of_servers:
+            for pg in server.placement_groups:
+                if pg.policy == "affinity":
+                    affinity_servers.append(server)
+                    break
+
+        # add servers with affinity policy
+        for server in affinity_servers:
+            if server.stack_name in added_servers:
+                continue
+            scheduler_hints = {}
+            for pg in server.placement_groups:
+                update_scheduler_hints(scheduler_hints, added_servers, pg)
+            server.add_to_template(template, list(self.networks.values()),
+                                   scheduler_hints)
+            added_servers.append(server.stack_name)
+
+        # add server group
+        for sg in self.server_groups:
+            template.add_server_group(sg.name, sg.policy)
+
+        # add remaining servers with no placement group configured
+        for server in list_of_servers:
+            # TODO placement_group and server_group should combine
+            if not server.placement_groups:
+                scheduler_hints = {}
+                # affinity/anti-aff server group
+                sg = server.server_group
+                if sg:
+                    scheduler_hints["group"] = {'get_resource': sg.name}
+                server.add_to_template(template,
+                                       list(self.networks.values()),
+                                       scheduler_hints)
+
+    def get_neutron_info(self):
+        if not self._shade_client:
+            self._shade_client = get_shade_client()
+
+        networks = self._shade_client.list_networks()
+        for network in self.networks.values():
+            for neutron_net in (net for net in networks if net.name == network.stack_name):
+                    network.segmentation_id = neutron_net.get('provider:segmentation_id')
+                    # we already have physical_network
+                    # network.physical_network = neutron_net.get('provider:physical_network')
+                    network.network_type = neutron_net.get('provider:network_type')
+                    network.neutron_info = neutron_net
+
+    def _create_new_stack(self, heat_template):
+         try:
+             return heat_template.create(block=True,
+                                         timeout=self.heat_timeout)
+         except KeyboardInterrupt:
+             raise y_exc.StackCreationInterrupt
+         except Exception:
+             LOG.exception("stack failed")
+             # let the other failures happen, we want stack trace
+             raise
+
+    def _retrieve_existing_stack(self, stack_name):
+        stack = HeatStack(stack_name)
+        if stack.get():
+            return stack
+        else:
+            LOG.warning("Stack %s does not exist", self.name)
+            return None
+
+    def deploy(self):
+        """deploys template into a stack using cloud"""
+        LOG.info("Deploying context '%s' START", self.name)
+
+        # self.key_filename = ''.join(
+        #     [consts.VNFTEST_ROOT_PATH,
+        #      '/vnftest/resources/files/vnftest_key-',
+        #      self.name])
+        # Permissions may have changed since creation; this can be fixed. If we
+        # overwrite the file, we lose future access to VMs using this key.
+        # As long as the file exists, even if it is unreadable, keep it intact
+        # if not os.path.exists(self.key_filename):
+        #     SSH.gen_keys(self.key_filename)
+
+        heat_template = HeatTemplate(
+            self.name, template_file=self.template_file,
+            heat_parameters=self.heat_parameters,
+            os_cloud_config=self._flags.os_cloud_config)
+
+        if self.template_file is None:
+            self._add_resources_to_template(heat_template)
+
+        if self._flags.no_setup:
+            # Try to get an existing stack, returns a stack or None
+            self.stack = self._retrieve_existing_stack(self.name)
+            if not self.stack:
+                self.stack = self._create_new_stack(heat_template)
+
+        else:
+            self.stack = self._create_new_stack(heat_template)
+
+        # TODO: use Neutron to get segmentation-id
+        self.get_neutron_info()
+
+        # copy some vital stack output into server objects
+        for server in self.servers.itervalues():
+            if server.networks:
+                self.update_networks(server)
+            if server.ports:
+                self.add_server_port(server)
+
+            if server.floating_ip:
+                server.public_ip = \
+                    self.stack.outputs[server.floating_ip["stack_name"]]
+
+        LOG.info("Deploying context '%s' DONE", self.name)
+
+    @staticmethod
+    def _port_net_is_existing(port_info):
+        net_flags = port_info.get('net_flags', {})
+        return net_flags.get(consts.IS_EXISTING)
+
+    @staticmethod
+    def _port_net_is_public(port_info):
+        net_flags = port_info.get('net_flags', {})
+        return net_flags.get(consts.IS_PUBLIC)
+
+    def update_networks(self, server):
+        for network in server.networks:
+            if 'network' in network:
+                network_name = network['network']
+                output_key = server.stack_name + ".networks.%s-ip" % network_name
+                ip = self.stack.outputs[output_key]
+                network["ip"] = ip
+
+    def add_server_port(self, server):
+        server_ports = server.ports.values()
+        for server_port in server_ports:
+            port_info = server_port[0]
+            port_ip = self.stack.outputs[port_info["stack_name"]]
+            port_net_is_existing = self._port_net_is_existing(port_info)
+            port_net_is_public = self._port_net_is_public(port_info)
+            if port_net_is_existing and (port_net_is_public or
+                                         len(server_ports) == 1):
+                server.public_ip = port_ip
+            if not server.private_ip or len(server_ports) == 1:
+                server.private_ip = port_ip
+
+        server.interfaces = {}
+        for network_name, ports in server.ports.items():
+            for port in ports:
+                # port['port'] is either port name from mapping or default network_name
+                if self._port_net_is_existing(port):
+                    continue
+                server.interfaces[port['port']] = self.make_interface_dict(network_name,
+                                                                           port['port'],
+                                                                           port['stack_name'],
+                                                                           self.stack.outputs)
+                server.override_ip(network_name, port)
+
+    def make_interface_dict(self, network_name, port, stack_name, outputs):
+        private_ip = outputs[stack_name]
+        mac_address = outputs[h_join(stack_name, "mac_address")]
+        # these are attributes of the network, not the port
+        output_subnet_cidr = outputs[h_join(self.name, network_name,
+                                            'subnet', 'cidr')]
+
+        # these are attributes of the network, not the port
+        output_subnet_gateway = outputs[h_join(self.name, network_name,
+                                               'subnet', 'gateway_ip')]
+
+        return {
+            # add default port name
+            "name": port,
+            "private_ip": private_ip,
+            "subnet_id": outputs[h_join(stack_name, "subnet_id")],
+            "subnet_cidr": output_subnet_cidr,
+            "network": str(ipaddress.ip_network(output_subnet_cidr).network_address),
+            "netmask": str(ipaddress.ip_network(output_subnet_cidr).netmask),
+            "gateway_ip": output_subnet_gateway,
+            "mac_address": mac_address,
+            "device_id": outputs[h_join(stack_name, "device_id")],
+            "network_id": outputs[h_join(stack_name, "network_id")],
+            # this should be == vld_id for NSB tests
+            "network_name": network_name,
+            # to match vnf_generic
+            "local_mac": mac_address,
+            "local_ip": private_ip,
+        }
+
+    def _delete_key_file(self):
+        if self.key_filename is not None:
+            try:
+                utils.remove_file(self.key_filename)
+                utils.remove_file(self.key_filename + ".pub")
+            except OSError:
+                LOG.exception("There was an error removing the key file %s",
+                              self.key_filename)
+
+    def undeploy(self):
+        """undeploys stack from cloud"""
+        if self._flags.no_teardown:
+            LOG.info("Undeploying context '%s' SKIP", self.name)
+            return
+
+        if self.stack:
+            LOG.info("Undeploying context '%s' START", self.name)
+            self.stack.delete()
+            self.stack = None
+            LOG.info("Undeploying context '%s' DONE", self.name)
+
+            self._delete_key_file()
+
+        super(HeatContext, self).undeploy()
+
+    @staticmethod
+    def generate_routing_table(server):
+        routes = [
+            {
+                "network": intf["network"],
+                "netmask": intf["netmask"],
+                "if": name,
+                # We have to encode a None gateway as '' for Jinja2 to YAML conversion
+                "gateway": intf["gateway_ip"] if intf["gateway_ip"] else '',
+            }
+            for name, intf in server.interfaces.items()
+        ]
+        return routes
+
+    def _get_server(self, attr_name):
+        """lookup server info by name from context
+        attr_name: either a name for a server created by vnftest or a dict
+        with attribute name mapping when using external heat templates
+        """
+        if isinstance(attr_name, collections.Mapping):
+            node_name, cname = self.split_host_name(attr_name['name'])
+            if cname is None or cname != self.name:
+                return None
+
+            # Create a dummy server instance for holding the *_ip attributes
+            server = Server(node_name, self, {})
+            server.public_ip = self.stack.outputs.get(
+                attr_name.get("public_ip_attr", object()), None)
+
+            server.private_ip = self.stack.outputs.get(
+                attr_name.get("private_ip_attr", object()), None)
+        else:
+            try:
+                server = self.servers[attr_name]
+            except KeyError:
+                attr_name_no_suffix = attr_name.split("-")[0]
+                server = self.servers.get(attr_name_no_suffix, None)
+            if server is None:
+                return None
+
+        pkey = pkg_resources.resource_string(
+            'vnftest.resources',
+            h_join('files/vnftest_key', self.name)).decode('utf-8')
+        key_filename = pkg_resources.resource_filename('vnftest.resources',
+            h_join('files/vnftest_key', self.name))
+        result = {
+            "user": server._context.user,
+            "pkey": pkey,
+            "key_filename": key_filename,
+            "private_ip": server.private_ip,
+            "interfaces": server.interfaces,
+            "routing_table": self.generate_routing_table(server),
+            # empty IPv6 routing table
+            "nd_route_tbl": [],
+            # we want to save the contex name so we can generate pod.yaml
+            "name": server.name,
+        }
+        # Target server may only have private_ip
+        if server.public_ip:
+            result["ip"] = server.public_ip
+
+        return result
+
+    def _get_network(self, attr_name):
+        if not isinstance(attr_name, collections.Mapping):
+            network = self.networks.get(attr_name, None)
+
+        else:
+            # Only take the first key, value
+            key, value = next(iter(attr_name.items()), (None, None))
+            if key is None:
+                return None
+            network_iter = (n for n in self.networks.values() if getattr(n, key) == value)
+            network = next(network_iter, None)
+
+        if network is None:
+            return None
+
+        result = {
+            "name": network.name,
+            "segmentation_id": network.segmentation_id,
+            "network_type": network.network_type,
+            "physical_network": network.physical_network,
+        }
+        return result
+
+    def _get_physical_nodes(self):
+        return self.nodes
+
+    def _get_physical_node_for_server(self, server_name):
+        node_name, ctx_name = self.split_host_name(server_name)
+        if ctx_name is None or self.name != ctx_name:
+            return None
+
+        matching_nodes = [s for s in self.servers.itervalues() if s.name == node_name]
+        if len(matching_nodes) == 0:
+            return None
+
+        server = openstack_utils.get_server(self._shade_client,
+                                            name_or_id=server_name)
+
+        if server:
+            server = server.toDict()
+            list_hypervisors = self._operator_client.list_hypervisors()
+
+            for hypervisor in list_hypervisors:
+                if hypervisor.hypervisor_hostname == server['OS-EXT-SRV-ATTR:hypervisor_hostname']:
+                    for node in self.nodes:
+                        if node['ip'] == hypervisor.host_ip:
+                            return "{}.{}".format(node['name'], self.name)
+
+        return None
diff --git a/vnftest/contexts/model.py b/vnftest/contexts/model.py
new file mode 100644
index 0000000..52b8d34
--- /dev/null
+++ b/vnftest/contexts/model.py
@@ -0,0 +1,433 @@
+##############################################################################
+# Copyright 2018 EuropeanSoftwareMarketingLtd.
+# ===================================================================
+#  Licensed under the ApacheLicense, Version2.0 (the"License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under
+# the License
+##############################################################################
+# vnftest comment: this is a modified copy of
+# yardstick/benchmark/contexts/model.py
+""" Logical model
+
+"""
+from __future__ import absolute_import
+
+import six
+import logging
+
+from collections import Mapping
+from six.moves import range
+
+from vnftest.common import constants as consts
+
+
+LOG = logging.getLogger(__name__)
+
+
+class Object(object):
+    """Base class for classes in the logical model
+    Contains common attributes and methods
+    """
+
+    def __init__(self, name, context):
+        # model identities and reference
+        self.name = name
+        self._context = context
+
+        # stack identities
+        self.stack_name = None
+        self.stack_id = None
+
+    @property
+    def dn(self):
+        """returns distinguished name for object"""
+        return self.name + "." + self._context.name
+
+
+class PlacementGroup(Object):
+    """Class that represents a placement group in the logical model
+    Concept comes from the OVF specification. Policy should be one of
+    "availability" or "affinity (there are more but they are not supported)"
+    """
+    map = {}
+
+    def __init__(self, name, context, policy):
+        if policy not in ["affinity", "availability"]:
+            raise ValueError("placement group '%s', policy '%s' is not valid" %
+                             (name, policy))
+        self.name = name
+        self.members = set()
+        self.stack_name = context.name + "-" + name
+        self.policy = policy
+        PlacementGroup.map[name] = self
+
+    def add_member(self, name):
+        self.members.add(name)
+
+    @staticmethod
+    def get(name):
+        return PlacementGroup.map.get(name)
+
+
+class ServerGroup(Object):     # pragma: no cover
+    """Class that represents a server group in the logical model
+    Policy should be one of "anti-affinity" or "affinity"
+    """
+    map = {}
+
+    def __init__(self, name, context, policy):
+        super(ServerGroup, self).__init__(name, context)
+        if policy not in {"affinity", "anti-affinity"}:
+            raise ValueError("server group '%s', policy '%s' is not valid" %
+                             (name, policy))
+        self.name = name
+        self.members = set()
+        self.stack_name = context.name + "-" + name
+        self.policy = policy
+        ServerGroup.map[name] = self
+
+    def add_member(self, name):
+        self.members.add(name)
+
+    @staticmethod
+    def get(name):
+        return ServerGroup.map.get(name)
+
+
+class Router(Object):
+    """Class that represents a router in the logical model"""
+
+    def __init__(self, name, network_name, context, external_gateway_info):
+        super(Router, self).__init__(name, context)
+
+        self.stack_name = context.name + "-" + network_name + "-" + self.name
+        self.stack_if_name = self.stack_name + "-if0"
+        self.external_gateway_info = external_gateway_info
+
+
+class Network(Object):
+    """Class that represents a network in the logical model"""
+    list = []
+
+    def __init__(self, name, context, attrs):
+        super(Network, self).__init__(name, context)
+        self.stack_name = context.name + "-" + self.name
+        self.subnet_stack_name = self.stack_name + "-subnet"
+        self.subnet_cidr = attrs.get('cidr', '10.0.1.0/24')
+        self.enable_dhcp = attrs.get('enable_dhcp', 'true')
+        self.router = None
+        self.physical_network = attrs.get('physical_network', 'physnet1')
+        self.provider = attrs.get('provider')
+        self.segmentation_id = attrs.get('segmentation_id')
+        self.network_type = attrs.get('network_type')
+        self.port_security_enabled = attrs.get('port_security_enabled')
+        self.vnic_type = attrs.get('vnic_type', 'normal')
+        self.allowed_address_pairs = attrs.get('allowed_address_pairs', [])
+        try:
+            # we require 'null' or '' to disable setting gateway_ip
+            self.gateway_ip = attrs['gateway_ip']
+        except KeyError:
+            # default to explicit None
+            self.gateway_ip = None
+        else:
+            # null is None in YAML, so we have to convert back to string
+            if self.gateway_ip is None:
+                self.gateway_ip = "null"
+
+        self.net_flags = attrs.get('net_flags', {})
+        if self.is_existing():
+            self.subnet = attrs.get('subnet')
+            if not self.subnet:
+                raise Warning('No subnet set in existing netwrok!')
+        else:
+            if "external_network" in attrs:
+                self.router = Router("router", self.name,
+                                     context, attrs["external_network"])
+            Network.list.append(self)
+
+    def is_existing(self):
+        net_is_existing = self.net_flags.get(consts.IS_EXISTING)
+        if net_is_existing and not isinstance(net_is_existing, bool):
+            raise SyntaxError('Network flags should be bool type!')
+        return net_is_existing
+
+    def is_public(self):
+        net_is_public = self.net_flags.get(consts.IS_PUBLIC)
+        if net_is_public and not isinstance(net_is_public, bool):
+            raise SyntaxError('Network flags should be bool type!')
+        return net_is_public
+
+    def has_route_to(self, network_name):
+        """determines if this network has a route to the named network"""
+        if self.router and self.router.external_gateway_info == network_name:
+            return True
+        return False
+
+    @staticmethod
+    def find_by_route_to(external_network):
+        """finds a network that has a route to the specified network"""
+        for network in Network.list:
+            if network.has_route_to(external_network):
+                return network
+
+    @staticmethod
+    def find_external_network():
+        """return the name of an external network some network in this
+        context has a route to
+        """
+        for network in Network.list:
+            if network.router:
+                return network.router.external_gateway_info
+        return None
+
+
+class Server(Object):     # pragma: no cover
+    """Class that represents a server in the logical model"""
+    list = []
+
+    def __init__(self, name, context, attrs):
+        super(Server, self).__init__(name, context)
+        self.stack_name = self.name + "." + context.name
+        self.keypair_name = context.keypair_name
+        self.secgroup_name = context.secgroup_name
+        self.user = context.user
+        self._context = context
+        self.public_ip = None
+        self.private_ip = None
+        self.user_data = ''
+        self.interfaces = {}
+        self.networks = None
+        self.ports = {}
+        self.floating_ip = {}
+
+        if attrs is None:
+            attrs = {}
+
+        self.placement_groups = []
+        placement = attrs.get("placement", [])
+        placement = placement if isinstance(placement, list) else [placement]
+        for p in placement:
+            pg = PlacementGroup.get(p)
+            if not pg:
+                raise ValueError("server '%s', placement '%s' is invalid" %
+                                 (name, p))
+            self.placement_groups.append(pg)
+            pg.add_member(self.stack_name)
+
+        self.volume = None
+        if "volume" in attrs:
+            self.volume = attrs.get("volume")
+
+        self.volume_mountpoint = None
+        if "volume_mountpoint" in attrs:
+            self.volume_mountpoint = attrs.get("volume_mountpoint")
+
+        # support servergroup attr
+        self.server_group = None
+        sg = attrs.get("server_group")
+        if sg:
+            server_group = ServerGroup.get(sg)
+            if not server_group:
+                raise ValueError("server '%s', server_group '%s' is invalid" %
+                                 (name, sg))
+            self.server_group = server_group
+            server_group.add_member(self.stack_name)
+
+        self.instances = 1
+        if "instances" in attrs:
+            self.instances = attrs["instances"]
+
+        if "networks" in attrs:
+            self.networks = attrs["networks"]
+        else:
+            # dict with key network name, each item is a dict with port name and ip
+            self.network_ports = attrs.get("network_ports", {})
+
+            self.floating_ip = None
+            self.floating_ip_assoc = None
+            if "floating_ip" in attrs:
+                self.floating_ip_assoc = {}
+
+            if self.floating_ip is not None:
+                ext_net = Network.find_external_network()
+                assert ext_net is not None
+                self.floating_ip["external_network"] = ext_net
+
+        self._image = None
+        if "image" in attrs:
+            self._image = attrs["image"]
+
+        self._flavor = None
+        if "flavor" in attrs:
+            self._flavor = attrs["flavor"]
+
+        self.user_data = attrs.get('user_data', '')
+        self.availability_zone = attrs.get('availability_zone')
+
+        Server.list.append(self)
+
+    def override_ip(self, network_name, port):
+        def find_port_overrides():
+            for p in ports:
+                # p can be string or dict
+                # we can't just use p[port['port'] in case p is a string
+                # and port['port'] is an int?
+                if isinstance(p, Mapping):
+                    g = p.get(port['port'])
+                    # filter out empty dicts
+                    if g:
+                        yield g
+
+        ports = self.network_ports.get(network_name, [])
+        intf = self.interfaces[port['port']]
+        for override in find_port_overrides():
+            intf['local_ip'] = override.get('local_ip', intf['local_ip'])
+            intf['netmask'] = override.get('netmask', intf['netmask'])
+            # only use the first value
+            break
+
+    @property
+    def image(self):
+        """returns a server's image name"""
+        if self._image:
+            return self._image
+        else:
+            return self._context.image
+
+    @property
+    def flavor(self):
+        """returns a server's flavor name"""
+        if self._flavor:
+            return self._flavor
+        else:
+            return self._context.flavor
+
+    def _add_instance(self, template, server_name, networks, scheduler_hints):
+        """adds to the template one server and corresponding resources"""
+        port_name_list = None
+        if self.networks is None:
+            port_name_list = []
+            for network in networks:
+                # if explicit mapping skip unused networks
+                if self.network_ports:
+                    try:
+                        ports = self.network_ports[network.name]
+                    except KeyError:
+                        # no port for this network
+                        continue
+                    else:
+                        if isinstance(ports, six.string_types):
+                            # because strings are iterable we have to check specifically
+                            raise SyntaxError("network_port must be a list '{}'".format(ports))
+                        # convert port subdicts into their just port name
+                        # port subdicts are used to override Heat IP address,
+                        # but we just need the port name
+                        # we allow duplicates here and let Heat raise the error
+                        ports = [next(iter(p)) if isinstance(p, dict) else p for p in ports]
+                # otherwise add a port for every network with port name as network name
+                else:
+                    ports = [network.name]
+                net_flags = network.net_flags
+                for port in ports:
+                    port_name = "{0}-{1}-port".format(server_name, port)
+                    port_info = {"stack_name": port_name, "port": port}
+                    if net_flags:
+                        port_info['net_flags'] = net_flags
+                    self.ports.setdefault(network.name, []).append(port_info)
+                    # we can't use secgroups if port_security_enabled is False
+                    if network.port_security_enabled is False:
+                        sec_group_id = None
+                    else:
+                        # if port_security_enabled is None we still need to add to secgroup
+                        sec_group_id = self.secgroup_name
+                    # don't refactor to pass in network object, that causes JSON
+                    # circular ref encode errors
+                    template.add_port(port_name, network,
+                                      sec_group_id=sec_group_id,
+                                      provider=network.provider,
+                                      allowed_address_pairs=network.allowed_address_pairs)
+                    if network.is_public():
+                        port_name_list.insert(0, port_name)
+                    else:
+                        port_name_list.append(port_name)
+
+                    if self.floating_ip:
+                        external_network = self.floating_ip["external_network"]
+                        if network.has_route_to(external_network):
+                            self.floating_ip["stack_name"] = server_name + "-fip"
+                            template.add_floating_ip(self.floating_ip["stack_name"],
+                                                     external_network,
+                                                     port_name,
+                                                     network.router.stack_if_name,
+                                                     sec_group_id)
+                            self.floating_ip_assoc["stack_name"] = \
+                                server_name + "-fip-assoc"
+                            template.add_floating_ip_association(
+                                self.floating_ip_assoc["stack_name"],
+                                self.floating_ip["stack_name"],
+                                port_name)
+        if self.flavor:
+            if isinstance(self.flavor, dict):
+                self.flavor["name"] = \
+                    self.flavor.setdefault("name", self.stack_name + "-flavor")
+                template.add_flavor(**self.flavor)
+                self.flavor_name = self.flavor["name"]
+            else:
+                self.flavor_name = self.flavor
+
+        if self.volume:
+            if isinstance(self.volume, dict):
+                self.volume["name"] = \
+                    self.volume.setdefault("name", server_name + "-volume")
+                template.add_volume(**self.volume)
+                template.add_volume_attachment(server_name, self.volume["name"],
+                                               mountpoint=self.volume_mountpoint)
+            else:
+                template.add_volume_attachment(server_name, self.volume,
+                                               mountpoint=self.volume_mountpoint)
+
+        template.add_server(server_name, self.image, flavor=self.flavor_name,
+                            flavors=self._context.flavors, ports=port_name_list,
+                            networks=self.networks,
+                            scheduler_hints=scheduler_hints, user=self.user,
+                            key_name=self.keypair_name, user_data=self.user_data,
+                            availability_zone=self.availability_zone)
+
+    def add_to_template(self, template, networks, scheduler_hints=None):
+        """adds to the template one or more servers (instances)"""
+        if self.instances == 1:
+            server_name = self.stack_name
+            self._add_instance(template, server_name, networks,
+                               scheduler_hints=scheduler_hints)
+        else:
+            # TODO(hafe) fix or remove, no test/sample for this
+            for i in range(self.instances):
+                server_name = "%s-%d" % (self.stack_name, i)
+                self._add_instance(template, server_name, networks,
+                                   scheduler_hints=scheduler_hints)
+
+
+def update_scheduler_hints(scheduler_hints, added_servers, placement_group):
+    """update scheduler hints from server's placement configuration
+    TODO: this code is openstack specific and should move somewhere else
+    """
+    if placement_group.policy == "affinity":
+        if "same_host" in scheduler_hints:
+            host_list = scheduler_hints["same_host"]
+        else:
+            host_list = scheduler_hints["same_host"] = []
+    else:
+        if "different_host" in scheduler_hints:
+            host_list = scheduler_hints["different_host"]
+        else:
+            host_list = scheduler_hints["different_host"] = []
+
+    for name in added_servers:
+        if name in placement_group.members:
+            host_list.append({'get_resource': name})
diff --git a/vnftest/core/task.py b/vnftest/core/task.py
index a9718bb..8797eee 100644
--- a/vnftest/core/task.py
+++ b/vnftest/core/task.py
@@ -25,6 +25,7 @@ import copy
 import logging
 import sys
 import time
+import traceback
 import uuid
 
 import ipaddress
@@ -32,6 +33,7 @@ import os
 import yaml
 from jinja2 import Environment
 from six.moves import filter
+
 from vnftest.runners import base as base_runner
 
 from vnftest.contexts.base import Context
@@ -160,6 +162,7 @@ class Task(object):     # pragma: no cover
                          one_task_end_time - one_task_start_time)
         except Exception as e:
             LOG.error("Task fatal error: %s", e)
+            traceback.print_exc()
             self.task_info.task_fatal()
         finally:
             self.task_info.task_end()
@@ -170,11 +173,6 @@ class Task(object):     # pragma: no cover
         total_end_time = time.time()
         LOG.info("Total finished in %d secs",
                  total_end_time - total_start_time)
-
-        step = steps[0]
-        LOG.info("To generate report, execute command "
-                 "'vnftest report generate %(task_id)s %(tc)s'", step)
-        LOG.info("Task ALL DONE, exiting")
         return self.task_info.result()
 
     def _generate_reporting(self):
@@ -279,6 +277,7 @@ class Task(object):     # pragma: no cover
             return result
         except Exception as e:
             LOG.exception('Case fatal error: %s', e)
+            traceback.print_exc()
             self.task_info.testcase_fatal(case_name)
         finally:
             self.task_info.testcase_end(case_name)
@@ -316,6 +315,7 @@ class Task(object):     # pragma: no cover
         LOG.info("Starting runner of type '%s'", runner_cfg["type"])
         # Previous steps output is the input of the next step.
         inputs.update(self.outputs)
+        _resolve_step_options(step_cfg, self.contexts, inputs)
         runner.run(step_cfg, self.contexts, inputs)
         return runner
 
@@ -330,6 +330,22 @@ class Task(object):     # pragma: no cover
         result.extend(step_result_list)
 
 
+def _resolve_step_options(step_cfg, contexts, inputs):
+    inputs = copy.deepcopy(inputs)
+    contexts_dict = {}
+    inputs['context'] = contexts_dict
+    if contexts is not None:
+        for context in contexts:
+            context_as_dict = utils.normalize_data_struct(context)
+            contexts_dict[context.assigned_name] = context_as_dict
+    options = step_cfg.get("options", {})
+    resolved_options = {}
+    for k, v in options.items():
+        v = utils.format(v, inputs)
+        resolved_options[k] = v
+    step_cfg["options"] = resolved_options
+
+
 class TaskParser(object):       # pragma: no cover
     """Parser for task config files in yaml format"""
 
diff --git a/vnftest/orchestrator/__init__.py b/vnftest/orchestrator/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/vnftest/orchestrator/__init__.py
diff --git a/vnftest/orchestrator/heat.py b/vnftest/orchestrator/heat.py
new file mode 100644
index 0000000..14c6d73
--- /dev/null
+++ b/vnftest/orchestrator/heat.py
@@ -0,0 +1,661 @@
+##############################################################################
+# Copyright 2018 EuropeanSoftwareMarketingLtd.
+# ===================================================================
+#  Licensed under the ApacheLicense, Version2.0 (the"License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under
+# the License
+##############################################################################
+# vnftest comment: this is a modified copy of
+# yardstick/orchestrator/heat.py
+"""Heat template and stack management"""
+
+from __future__ import absolute_import
+import collections
+import datetime
+import getpass
+import logging
+import pkg_resources
+import pprint
+import socket
+import tempfile
+import time
+
+from oslo_serialization import jsonutils
+from oslo_utils import encodeutils
+from shade._heat import event_utils
+
+from vnftest.common import constants as consts
+from vnftest.common import exceptions
+from vnftest.common import template_format
+from vnftest.common import openstack_utils as op_utils
+
+
+log = logging.getLogger(__name__)
+
+
+PROVIDER_SRIOV = "sriov"
+
+_DEPLOYED_STACKS = {}
+
+
+class HeatStack(object):
+    """Represents a Heat stack (deployed template) """
+
+    def __init__(self, name, os_cloud_config=None):
+        self.name = name
+        self.outputs = {}
+        os_cloud_config = {} if not os_cloud_config else os_cloud_config
+        self._cloud = op_utils.get_shade_client(**os_cloud_config)
+        self._stack = None
+
+    def _update_stack_tracking(self):
+        outputs = self._stack.outputs
+        self.outputs = {output['output_key']: output['output_value'] for output
+                        in outputs}
+        if self.uuid:
+            _DEPLOYED_STACKS[self.uuid] = self._stack
+
+    def create(self, template, heat_parameters, wait, timeout):
+        """Creates an OpenStack stack from a template"""
+        with tempfile.NamedTemporaryFile('wb', delete=False) as template_file:
+            template_file.write(jsonutils.dump_as_bytes(template))
+            template_file.close()
+            self._stack = self._cloud.create_stack(
+                self.name, template_file=template_file.name, wait=wait,
+                timeout=timeout, **heat_parameters)
+
+        self._update_stack_tracking()
+
+    def get_failures(self):
+        return event_utils.get_events(self._cloud, self._stack.id,
+                                      event_args={'resource_status': 'FAILED'})
+
+    def get(self):
+        """Retrieves an existing stack from the target cloud
+
+        Returns a bool indicating whether the stack exists in the target cloud
+        If the stack exists, it will be stored as self._stack
+        """
+        self._stack = self._cloud.get_stack(self.name)
+        if not self._stack:
+            return False
+
+        self._update_stack_tracking()
+        return True
+
+    @staticmethod
+    def stacks_exist():
+        """Check if any stack has been deployed"""
+        return len(_DEPLOYED_STACKS) > 0
+
+    def delete(self, wait=True):
+        """Deletes a stack in the target cloud"""
+        if self.uuid is None:
+            return
+
+        try:
+            ret = self._cloud.delete_stack(self.uuid, wait=wait)
+        except TypeError:
+            # NOTE(ralonsoh): this exception catch solves a bug in Shade, which
+            # tries to retrieve and read the stack status when it's already
+            # deleted.
+            ret = True
+
+        _DEPLOYED_STACKS.pop(self.uuid)
+        self._stack = None
+        return ret
+
+    @staticmethod
+    def delete_all():
+        """Delete all deployed stacks"""
+        for stack in _DEPLOYED_STACKS:
+            stack.delete()
+
+    @property
+    def status(self):
+        """Retrieve the current stack status"""
+        if self._stack:
+            return self._stack.status
+
+    @property
+    def uuid(self):
+        """Retrieve the current stack ID"""
+        if self._stack:
+            return self._stack.id
+
+
+class HeatTemplate(object):
+    """Describes a Heat template and a method to deploy template to a stack"""
+
+    DESCRIPTION_TEMPLATE = """
+Stack built by the vnftest framework for %s on host %s %s.
+All referred generated resources are prefixed with the template
+name (i.e. %s).
+"""
+
+    HEAT_WAIT_LOOP_INTERVAL = 2
+    HEAT_STATUS_COMPLETE = 'COMPLETE'
+
+    def _init_template(self):
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self._template = {
+            'heat_template_version': '2013-05-23',
+            'description': self.DESCRIPTION_TEMPLATE % (
+                getpass.getuser(),
+                socket.gethostname(),
+                timestamp,
+                self.name
+            ),
+            'resources': {},
+            'outputs': {}
+        }
+
+        # short hand for resources part of template
+        self.resources = self._template['resources']
+
+    def __init__(self, name, template_file=None, heat_parameters=None,
+                 os_cloud_config=None):
+        self.name = name
+        self.keystone_client = None
+        self.heat_parameters = {}
+        self._os_cloud_config = {} if not os_cloud_config else os_cloud_config
+
+        # heat_parameters is passed to heat in stack create, empty dict when
+        # vnftest creates the template (no get_param in resources part)
+        if heat_parameters:
+            self.heat_parameters = heat_parameters
+
+        if template_file:
+            with open(template_file) as stream:
+                log.info('Parsing external template: %s', template_file)
+                template_str = stream.read()
+            self._template = template_format.parse(template_str)
+            self._parameters = heat_parameters
+        else:
+            self._init_template()
+
+        log.debug("template object '%s' created", name)
+
+    def add_flavor(self, name, vcpus=1, ram=1024, disk=1, ephemeral=0,
+                   is_public=True, rxtx_factor=1.0, swap=0,
+                   extra_specs=None):
+        """add to the template a Flavor description"""
+        if name is None:
+            name = 'auto'
+        log.debug("adding Nova::Flavor '%s' vcpus '%d' ram '%d' disk '%d' "
+                  "ephemeral '%d' is_public '%s' rxtx_factor '%d' "
+                  "swap '%d' extra_specs '%s'",
+                  name, vcpus, ram, disk, ephemeral, is_public,
+                  rxtx_factor, swap, str(extra_specs))
+
+        if extra_specs:
+            assert isinstance(extra_specs, collections.Mapping)
+
+        self.resources[name] = {
+            'type': 'OS::Nova::Flavor',
+            'properties': {'name': name,
+                           'disk': disk,
+                           'vcpus': vcpus,
+                           'swap': swap,
+                           'flavorid': name,
+                           'rxtx_factor': rxtx_factor,
+                           'ram': ram,
+                           'is_public': is_public,
+                           'ephemeral': ephemeral,
+                           'extra_specs': extra_specs}
+        }
+
+        self._template['outputs'][name] = {
+            'description': 'Flavor %s ID' % name,
+            'value': {'get_resource': name}
+        }
+
+    def add_volume(self, name, size=10):
+        """add to the template a volume description"""
+        log.debug("adding Cinder::Volume '%s' size '%d' ", name, size)
+
+        self.resources[name] = {
+            'type': 'OS::Cinder::Volume',
+            'properties': {'name': name,
+                           'size': size}
+        }
+
+        self._template['outputs'][name] = {
+            'description': 'Volume %s ID' % name,
+            'value': {'get_resource': name}
+        }
+
+    def add_volume_attachment(self, server_name, volume_name, mountpoint=None):
+        """add to the template an association of volume to instance"""
+        log.debug("adding Cinder::VolumeAttachment server '%s' volume '%s' ",
+                  server_name, volume_name)
+        name = "%s-%s" % (server_name, volume_name)
+        volume_id = {'get_resource': volume_name}
+        self.resources[name] = {
+            'type': 'OS::Cinder::VolumeAttachment',
+            'properties': {'instance_uuid': {'get_resource': server_name},
+                           'volume_id': volume_id}
+        }
+
+        if mountpoint:
+            self.resources[name]['properties']['mountpoint'] = mountpoint
+
+    def add_network(self, name, physical_network='physnet1', provider=None,
+                    segmentation_id=None, port_security_enabled=None, network_type=None):
+        """add to the template a Neutron Net"""
+        log.debug("adding Neutron::Net '%s'", name)
+        if provider is None:
+            self.resources[name] = {
+                'type': 'OS::Neutron::Net',
+                'properties': {
+                    'name': name,
+                }
+            }
+        else:
+            self.resources[name] = {
+                'type': 'OS::Neutron::ProviderNet',
+                'properties': {
+                    'name': name,
+                    'network_type': 'flat' if network_type is None else network_type,
+                    'physical_network': physical_network,
+                },
+            }
+            if segmentation_id:
+                self.resources[name]['properties']['segmentation_id'] = segmentation_id
+                if network_type is None:
+                    self.resources[name]['properties']['network_type'] = 'vlan'
+        # if port security is not defined then don't add to template:
+        # some deployments don't have port security plugin installed
+        if port_security_enabled is not None:
+            self.resources[name]['properties']['port_security_enabled'] = port_security_enabled
+
+    def add_server_group(self, name, policies):     # pragma: no cover
+        """add to the template a ServerGroup"""
+        log.debug("adding Nova::ServerGroup '%s'", name)
+        policies = policies if isinstance(policies, list) else [policies]
+        self.resources[name] = {
+            'type': 'OS::Nova::ServerGroup',
+            'properties': {'name': name,
+                           'policies': policies}
+        }
+
+    def add_subnet(self, name, network, cidr, enable_dhcp='true', gateway_ip=None):
+        """add to the template a Neutron Subnet
+        """
+        log.debug("adding Neutron::Subnet '%s' in network '%s', cidr '%s'",
+                  name, network, cidr)
+        self.resources[name] = {
+            'type': 'OS::Neutron::Subnet',
+            'depends_on': network,
+            'properties': {
+                'name': name,
+                'cidr': cidr,
+                'network_id': {'get_resource': network},
+                'enable_dhcp': enable_dhcp,
+            }
+        }
+        if gateway_ip == 'null':
+            self.resources[name]['properties']['gateway_ip'] = None
+        elif gateway_ip is not None:
+            self.resources[name]['properties']['gateway_ip'] = gateway_ip
+
+        self._template['outputs'][name] = {
+            'description': 'subnet %s ID' % name,
+            'value': {'get_resource': name}
+        }
+        self._template['outputs'][name + "-cidr"] = {
+            'description': 'subnet %s cidr' % name,
+            'value': {'get_attr': [name, 'cidr']}
+        }
+        self._template['outputs'][name + "-gateway_ip"] = {
+            'description': 'subnet %s gateway_ip' % name,
+            'value': {'get_attr': [name, 'gateway_ip']}
+        }
+
+    def add_router(self, name, ext_gw_net, subnet_name):
+        """add to the template a Neutron Router and interface"""
+        log.debug("adding Neutron::Router:'%s', gw-net:'%s'", name, ext_gw_net)
+        self.resources[name] = {
+            'type': 'OS::Neutron::Router',
+            'depends_on': [subnet_name],
+            'properties': {
+                'name': name,
+                'external_gateway_info': {
+                    'network': ext_gw_net
+                }
+            }
+        }
+
+    def add_router_interface(self, name, router_name, subnet_name):
+        """add to the template a Neutron RouterInterface and interface"""
+        log.debug("adding Neutron::RouterInterface '%s' router:'%s', "
+                  "subnet:'%s'", name, router_name, subnet_name)
+        self.resources[name] = {
+            'type': 'OS::Neutron::RouterInterface',
+            'depends_on': [router_name, subnet_name],
+            'properties': {
+                'router_id': {'get_resource': router_name},
+                'subnet_id': {'get_resource': subnet_name}
+            }
+        }
+
+    def add_port(self, name, network, sec_group_id=None,
+                 provider=None, allowed_address_pairs=None):
+        """add to the template a named Neutron Port
+        """
+        net_is_existing = network.net_flags.get(consts.IS_EXISTING)
+        depends_on = [] if net_is_existing else [network.subnet_stack_name]
+        fixed_ips = [{'subnet': network.subnet}] if net_is_existing else [
+            {'subnet': {'get_resource': network.subnet_stack_name}}]
+        network_ = network.name if net_is_existing else {
+            'get_resource': network.stack_name}
+        self.resources[name] = {
+            'type': 'OS::Neutron::Port',
+            'depends_on': depends_on,
+            'properties': {
+                'name': name,
+                'binding:vnic_type': network.vnic_type,
+                'fixed_ips': fixed_ips,
+                'network': network_,
+            }
+        }
+
+        if provider == PROVIDER_SRIOV:
+            self.resources[name]['properties']['binding:vnic_type'] = \
+                'direct'
+
+        if sec_group_id:
+            self.resources[name]['depends_on'].append(sec_group_id)
+            self.resources[name]['properties']['security_groups'] = \
+                [sec_group_id]
+
+        if allowed_address_pairs:
+            self.resources[name]['properties'][
+                'allowed_address_pairs'] = allowed_address_pairs
+
+        log.debug("adding Neutron::Port %s", self.resources[name])
+
+        self._template['outputs'][name] = {
+            'description': 'Address for interface %s' % name,
+            'value': {'get_attr': [name, 'fixed_ips', 0, 'ip_address']}
+        }
+        self._template['outputs'][name + "-subnet_id"] = {
+            'description': 'Address for interface %s' % name,
+            'value': {'get_attr': [name, 'fixed_ips', 0, 'subnet_id']}
+        }
+        self._template['outputs'][name + "-mac_address"] = {
+            'description': 'MAC Address for interface %s' % name,
+            'value': {'get_attr': [name, 'mac_address']}
+        }
+        self._template['outputs'][name + "-device_id"] = {
+            'description': 'Device ID for interface %s' % name,
+            'value': {'get_attr': [name, 'device_id']}
+        }
+        self._template['outputs'][name + "-network_id"] = {
+            'description': 'Network ID for interface %s' % name,
+            'value': {'get_attr': [name, 'network_id']}
+        }
+
+    def add_floating_ip(self, name, network_name, port_name, router_if_name,
+                        secgroup_name=None):
+        """add to the template a Nova FloatingIP resource
+        see: https://bugs.launchpad.net/heat/+bug/1299259
+        """
+        log.debug("adding Nova::FloatingIP '%s', network '%s', port '%s', "
+                  "rif '%s'", name, network_name, port_name, router_if_name)
+
+        self.resources[name] = {
+            'type': 'OS::Nova::FloatingIP',
+            'depends_on': [port_name, router_if_name],
+            'properties': {
+                'pool': network_name
+            }
+        }
+
+        if secgroup_name:
+            self.resources[name]["depends_on"].append(secgroup_name)
+
+        self._template['outputs'][name] = {
+            'description': 'floating ip %s' % name,
+            'value': {'get_attr': [name, 'ip']}
+        }
+
+    def add_floating_ip_association(self, name, floating_ip_name, port_name):
+        """add to the template a Nova FloatingIP Association resource
+        """
+        log.debug("adding Nova::FloatingIPAssociation '%s', server '%s', "
+                  "floating_ip '%s'", name, port_name, floating_ip_name)
+
+        self.resources[name] = {
+            'type': 'OS::Neutron::FloatingIPAssociation',
+            'depends_on': [port_name],
+            'properties': {
+                'floatingip_id': {'get_resource': floating_ip_name},
+                'port_id': {'get_resource': port_name}
+            }
+        }
+
+    def add_keypair(self, name, key_id):
+        """add to the template a Nova KeyPair"""
+        log.debug("adding Nova::KeyPair '%s'", name)
+        self.resources[name] = {
+            'type': 'OS::Nova::KeyPair',
+            'properties': {
+                'name': name,
+                # resource_string returns bytes, so we must decode to unicode
+                'public_key': encodeutils.safe_decode(
+                    pkg_resources.resource_string(
+                        'vnftest.resources',
+                        'files/vnftest_key-' +
+                        key_id + '.pub'),
+                    'utf-8')
+            }
+        }
+
+    def add_servergroup(self, name, policy):
+        """add to the template a Nova ServerGroup"""
+        log.debug("adding Nova::ServerGroup '%s', policy '%s'", name, policy)
+        if policy not in ["anti-affinity", "affinity"]:
+            raise ValueError(policy)
+
+        self.resources[name] = {
+            'type': 'OS::Nova::ServerGroup',
+            'properties': {
+                'name': name,
+                'policies': [policy]
+            }
+        }
+
+        self._template['outputs'][name] = {
+            'description': 'ID Server Group %s' % name,
+            'value': {'get_resource': name}
+        }
+
+    def add_security_group(self, name, security_group=None):
+        """add to the template a Neutron SecurityGroup"""
+        log.debug("adding Neutron::SecurityGroup '%s'", name)
+        description = ("Group allowing IPv4 and IPv6 for icmp and upd/tcp on"
+                       "all ports")
+        rules = [
+            {'remote_ip_prefix': '0.0.0.0/0',
+             'protocol': 'tcp',
+             'port_range_min': '1',
+             'port_range_max': '65535'},
+            {'remote_ip_prefix': '0.0.0.0/0',
+             'protocol': 'udp',
+             'port_range_min': '1',
+             'port_range_max': '65535'},
+            {'remote_ip_prefix': '0.0.0.0/0',
+             'protocol': 'icmp'},
+            {'remote_ip_prefix': '::/0',
+             'ethertype': 'IPv6',
+             'protocol': 'tcp',
+             'port_range_min': '1',
+             'port_range_max': '65535'},
+            {'remote_ip_prefix': '::/0',
+             'ethertype': 'IPv6',
+             'protocol': 'udp',
+             'port_range_min': '1',
+             'port_range_max': '65535'},
+            {'remote_ip_prefix': '::/0',
+             'ethertype': 'IPv6',
+             'protocol': 'ipv6-icmp'},
+            {'remote_ip_prefix': '0.0.0.0/0',
+             'direction': 'egress',
+             'protocol': 'tcp',
+             'port_range_min': '1',
+             'port_range_max': '65535'},
+            {'remote_ip_prefix': '0.0.0.0/0',
+             'direction': 'egress',
+             'protocol': 'udp',
+             'port_range_min': '1',
+             'port_range_max': '65535'},
+            {'remote_ip_prefix': '0.0.0.0/0',
+             'direction': 'egress',
+             'protocol': 'icmp'},
+            {'remote_ip_prefix': '::/0',
+             'direction': 'egress',
+             'ethertype': 'IPv6',
+             'protocol': 'tcp',
+             'port_range_min': '1',
+             'port_range_max': '65535'},
+            {'remote_ip_prefix': '::/0',
+             'direction': 'egress',
+             'ethertype': 'IPv6',
+             'protocol': 'udp',
+             'port_range_min': '1',
+             'port_range_max': '65535'},
+            {'remote_ip_prefix': '::/0',
+             'direction': 'egress',
+             'ethertype': 'IPv6',
+             'protocol': 'ipv6-icmp'},
+        ]
+        if security_group:
+            description = "Custom security group rules defined by the user"
+            rules = security_group.get('rules')
+
+        log.debug("The security group rules is %s", rules)
+
+        self.resources[name] = {
+            'type': 'OS::Neutron::SecurityGroup',
+            'properties': {
+                'name': name,
+                'description': description,
+                'rules': rules
+            }
+        }
+
+        self._template['outputs'][name] = {
+            'description': 'ID of Security Group',
+            'value': {'get_resource': name}
+        }
+
+    def add_server(self, name, image, flavor, flavors, ports=None, networks=None,
+                   scheduler_hints=None, user=None, key_name=None, user_data=None, metadata=None,
+                   additional_properties=None, availability_zone=None):
+        """add to the template a Nova Server """
+        log.debug("adding Nova::Server '%s', image '%s', flavor '%s', "
+                  "ports %s", name, image, flavor, ports)
+
+        self.resources[name] = {
+            'type': 'OS::Nova::Server',
+            'depends_on': []
+        }
+
+        server_properties = {
+            'name': name,
+            'image': image,
+            'flavor': {},
+            'networks': []  # list of dictionaries
+        }
+        if availability_zone:
+            server_properties["availability_zone"] = availability_zone
+
+        if flavor in flavors:
+            self.resources[name]['depends_on'].append(flavor)
+            server_properties["flavor"] = {'get_resource': flavor}
+        else:
+            server_properties["flavor"] = flavor
+
+        if user:
+            server_properties['admin_user'] = user
+
+        if key_name:
+            self.resources[name]['depends_on'].append(key_name)
+            server_properties['key_name'] = {'get_resource': key_name}
+
+        if ports:
+            self.resources[name]['depends_on'].extend(ports)
+            for port in ports:
+                server_properties['networks'].append(
+                    {'port': {'get_resource': port}}
+                )
+
+        if networks:
+            for n in networks:
+                server_properties['networks'].append(n)
+                if 'network' in n:
+                    network_name = n['network']
+                    self._template['outputs'][name + ".networks.%s-ip" % network_name] = {
+                        'description': 'network %s ip' % network_name,
+                        'value': {'get_attr': [name, 'networks', network_name, 0]}
+                    }
+
+        if scheduler_hints:
+            server_properties['scheduler_hints'] = scheduler_hints
+
+        if user_data:
+            server_properties['user_data'] = user_data
+
+        if metadata:
+            assert isinstance(metadata, collections.Mapping)
+            server_properties['metadata'] = metadata
+
+        if additional_properties:
+            assert isinstance(additional_properties, collections.Mapping)
+            for prop in additional_properties:
+                server_properties[prop] = additional_properties[prop]
+
+        server_properties['config_drive'] = True
+
+        self.resources[name]['properties'] = server_properties
+
+        self._template['outputs'][name] = {
+            'description': 'VM UUID',
+            'value': {'get_resource': name}
+        }
+
+    def create(self, block=True, timeout=3600):
+        """Creates a stack in the target based on the stored template
+
+        :param block: (bool) Wait for Heat create to finish
+        :param timeout: (int) Timeout in seconds for Heat create,
+               default 3600s
+        :return A dict with the requested output values from the template
+        """
+        log.info("Creating stack '%s' START", self.name)
+
+        start_time = time.time()
+        stack = HeatStack(self.name, os_cloud_config=self._os_cloud_config)
+        stack.create(self._template, self.heat_parameters, block, timeout)
+
+        if not block:
+            log.info("Creating stack '%s' DONE in %d secs",
+                     self.name, time.time() - start_time)
+            return stack
+
+        if stack.status != self.HEAT_STATUS_COMPLETE:
+            for event in stack.get_failures():
+                log.error("%s", event.resource_status_reason)
+            log.error(pprint.pformat(self._template))
+            raise exceptions.HeatTemplateError(stack_name=self.name)
+
+        log.info("Creating stack '%s' DONE in %d secs",
+                 self.name, time.time() - start_time)
+        return stack
diff --git a/vnftest/tests/unit/common/test_utils.py b/vnftest/tests/unit/common/test_utils.py
index d152a98..6f82537 100644
--- a/vnftest/tests/unit/common/test_utils.py
+++ b/vnftest/tests/unit/common/test_utils.py
@@ -798,19 +798,6 @@ power management:
         assert sockets == [0, 1]
 
 
-class ChangeObjToDictTestCase(unittest.TestCase):
-
-    def test_change_obj_to_dict(self):
-        class A(object):
-            def __init__(self):
-                self.name = 'vnftest'
-
-        obj = A()
-        obj_r = utils.change_obj_to_dict(obj)
-        obj_s = {'name': 'vnftest'}
-        self.assertEqual(obj_r, obj_s)
-
-
 class SetDictValueTestCase(unittest.TestCase):
 
     def test_set_dict_value(self):