Merge "Added method to return OpenStackVmInstance from Heat."

8 files changed, 989 insertions, 128 deletions

diff --git a/snaps/openstack/utils/heat_utils.py b/snaps/openstack/utils/heat_utils.py
index c2919cb..6910bfe 100644
--- a/snaps/openstack/utils/heat_utils.py
+++ b/snaps/openstack/utils/heat_utils.py
@@ -17,12 +17,13 @@ import logging
 import yaml
 from heatclient.client import Client
 from heatclient.common.template_format import yaml_loader
+from novaclient.exceptions import NotFound
 from oslo_serialization import jsonutils
 
 from snaps import file_utils
-from snaps.domain.stack import Stack, Resource
+from snaps.domain.stack import Stack, Resource, Output
 
-from snaps.openstack.utils import keystone_utils, neutron_utils
+from snaps.openstack.utils import keystone_utils, neutron_utils, nova_utils
 
 __author__ = 'spisarski'
 
@@ -86,17 +87,6 @@ def get_stack_status(heat_cli, stack_id):
     return heat_cli.stacks.get(stack_id).stack_status
 
 
-def get_stack_outputs(heat_cli, stack_id):
-    """
-    Returns a domain Stack object for a given ID
-    :param heat_cli: the OpenStack heat client
-    :param stack_id: the ID of the heat stack to retrieve
-    :return: the Stack domain object else None
-    """
-    stack = heat_cli.stacks.get(stack_id)
-    return stack.outputs
-
-
 def create_stack(heat_cli, stack_settings):
     """
     Executes an Ansible playbook to the given host
@@ -157,6 +147,29 @@ def get_resources(heat_cli, stack):
         return out
 
 
+def get_outputs(heat_cli, stack):
+    """
+    Returns all of the SNAPS-OO Output domain objects for the defined outputs
+    for given stack
+    :param heat_cli: the OpenStack heat client
+    :param stack: the SNAPS-OO Stack domain object
+    :return: a list
+    """
+    out = list()
+
+    os_stack = heat_cli.stacks.get(stack.id)
+
+    outputs = None
+    if os_stack:
+        outputs = os_stack.outputs
+
+    if outputs:
+        for output in outputs:
+            out.append(Output(**output))
+
+    return out
+
+
 def get_stack_networks(heat_cli, neutron, stack):
     """
     Returns an instance of NetworkSettings for each network owned by this stack
@@ -178,6 +191,31 @@ def get_stack_networks(heat_cli, neutron, stack):
     return out
 
 
+def get_stack_servers(heat_cli, nova, stack):
+    """
+    Returns an instance of NetworkSettings for each network owned by this stack
+    :param heat_cli: the OpenStack heat client object
+    :param nova: the OpenStack nova client object
+    :param stack: the SNAPS-OO Stack domain object
+    :return: a list of NetworkSettings
+    """
+
+    out = list()
+    resources = get_resources(heat_cli, stack)
+    for resource in resources:
+        if resource.type == 'OS::Nova::Server':
+            try:
+                server = nova_utils.get_server_object_by_id(
+                    nova, resource.id)
+                if server:
+                    out.append(server)
+            except NotFound:
+                logger.warn(
+                    'VmInst cannot be located with ID %s', resource.id)
+
+    return out
+
+
 def parse_heat_template_str(tmpl_str):
     """
     Takes a heat template string, performs some simple validation and returns a
diff --git a/snaps/openstack/utils/neutron_utils.py b/snaps/openstack/utils/neutron_utils.py
index e21c905..806bb53 100644
--- a/snaps/openstack/utils/neutron_utils.py
+++ b/snaps/openstack/utils/neutron_utils.py
@@ -248,6 +248,18 @@ def delete_router(neutron, router):
         neutron.delete_router(router=router.id)
 
 
+def get_router_by_id(neutron, router_id):
+    """
+    Returns a router with a given ID, else None if not found
+    :param neutron: the client
+    :param router_id: the Router ID
+    :return: a SNAPS-OO Router domain object
+    """
+    router = neutron.show_router(router_id)
+    if router:
+        return Router(**router['router'])
+
+
 def get_router(neutron, router_settings=None, router_name=None):
     """
     Returns the first router object (dictionary) found the given the settings
@@ -385,23 +397,64 @@ def get_port(neutron, port_settings=None, port_name=None):
     port_filter = dict()
 
     if port_settings:
-        port_filter['name'] = port_settings.name
+        if port_settings.name and len(port_settings.name) > 0:
+            port_filter['name'] = port_settings.name
         if port_settings.admin_state_up:
             port_filter['admin_state_up'] = port_settings.admin_state_up
         if port_settings.device_id:
             port_filter['device_id'] = port_settings.device_id
         if port_settings.mac_address:
             port_filter['mac_address'] = port_settings.mac_address
+        if port_settings.network_name:
+            network = get_network(neutron,
+                                  network_name=port_settings.network_name)
+            port_filter['network_id'] = network.id
     elif port_name:
         port_filter['name'] = port_name
 
     ports = neutron.list_ports(**port_filter)
     for port in ports['ports']:
-        return Port(name=port['name'], id=port['id'],
-                    ips=port['fixed_ips'], mac_address=port['mac_address'])
+        return Port(**port)
+    return None
+
+
+def get_port_by_id(neutron, port_id):
+    """
+    Returns a SNAPS-OO Port domain object for the given ID or none if not found
+    :param neutron: the client
+    :param port_id: the to query
+    :return: a SNAPS-OO Port domain object or None
+    """
+    port = neutron.show_port(port_id)
+    if port:
+        return Port(**port['port'])
     return None
 
 
+def get_ports(neutron, network, ips=None):
+    """
+    Returns a list of SNAPS-OO Port objects for all OpenStack Port objects that
+    are associated with the 'network' parameter
+    :param neutron: the client
+    :param network: SNAPS-OO Network domain object
+    :param ips: the IPs to lookup if not None
+    :return: a SNAPS-OO Port domain object or None if not found
+    """
+    out = list()
+    ports = neutron.list_ports(**{'network_id': network.id})
+    for port in ports['ports']:
+        if ips:
+            for fixed_ips in port['fixed_ips']:
+                if ('ip_address' in fixed_ips and
+                        fixed_ips['ip_address'] in ips) or ips is None:
+                    out.append(Port(**port))
+                    break
+        else:
+            out.append(Port(**port))
+
+    return out
+
+
 def create_security_group(neutron, keystone, sec_grp_settings):
     """
     Creates a security group object in OpenStack
@@ -554,12 +607,13 @@ def get_floating_ips(neutron, ports=None):
     Returns all of the floating IPs
     When ports is not None, FIPs returned must be associated with one of the
     ports in the list and a tuple 2 where the first element being the port's
-    name and the second being the FloatingIp SNAPS-OO domain object.
+    ID and the second being the FloatingIp SNAPS-OO domain object.
     When ports is None, all known FloatingIp SNAPS-OO domain objects will be
     returned in a list
     :param neutron: the Neutron client
-    :param ports: a list of SNAPS-OO Port objects to join
-    :return: a list of tuple 2 (port_name, SNAPS FloatingIp) objects when ports
+    :param ports: a list of tuple 2 where index 0 is the port name and index 1
+                  is the SNAPS-OO Port object
+    :return: a list of tuple 2 (port_id, SNAPS FloatingIp) objects when ports
              is not None else a list of Port objects
     """
     out = list()
@@ -567,13 +621,11 @@ def get_floating_ips(neutron, ports=None):
     for fip in fips['floatingips']:
         if ports:
             for port_name, port in ports:
-                if fip['port_id'] == port.id:
-                    out.append((port.name, FloatingIp(
-                        inst_id=fip['id'], ip=fip['floating_ip_address'])))
+                if port and port.id == fip['port_id']:
+                    out.append((port.id, FloatingIp(**fip)))
                     break
         else:
-            out.append(FloatingIp(inst_id=fip['id'],
-                                  ip=fip['floating_ip_address']))
+            out.append(FloatingIp(**fip))
 
     return out
 
@@ -593,7 +645,7 @@ def create_floating_ip(neutron, ext_net_name):
             body={'floatingip':
                   {'floating_network_id': ext_net.id}})
 
-        return FloatingIp(inst_id=fip['floatingip']['id'],
+        return FloatingIp(id=fip['floatingip']['id'],
                           ip=fip['floatingip']['floating_ip_address'])
     else:
         raise NeutronException(
@@ -612,8 +664,7 @@ def get_floating_ip(neutron, floating_ip):
                  floating_ip.ip)
     os_fip = __get_os_floating_ip(neutron, floating_ip)
     if os_fip:
-        return FloatingIp(
-            inst_id=os_fip['id'], ip=os_fip['floating_ip_address'])
+        return FloatingIp(id=os_fip['id'], ip=os_fip['floating_ip_address'])
 
 
 def __get_os_floating_ip(neutron, floating_ip):
@@ -648,7 +699,7 @@ def delete_floating_ip(neutron, floating_ip):
 def get_network_quotas(neutron, project_id):
     """
     Returns a list of all available keypairs
-    :param nova: the Nova client
+    :param neutron: the neutron client
     :param project_id: the project's ID of the quotas to lookup
     :return: an object of type NetworkQuotas or None if not found
     """
diff --git a/snaps/openstack/utils/nova_utils.py b/snaps/openstack/utils/nova_utils.py
index 0a259b0..fe53211 100644
--- a/snaps/openstack/utils/nova_utils.py
+++ b/snaps/openstack/utils/nova_utils.py
@@ -99,8 +99,8 @@ def create_server(nova, neutron, glance, instance_settings, image_settings,
             args['availability_zone'] = instance_settings.availability_zone
 
         server = nova.servers.create(**args)
-        return VmInst(name=server.name, inst_id=server.id,
-                      networks=server.networks)
+
+        return __map_os_server_obj_to_vm_inst(server)
     else:
         raise NovaException(
             'Cannot create instance, image cannot be located with name %s',
@@ -125,8 +125,27 @@ def get_server(nova, vm_inst_settings=None, server_name=None):
 
     servers = nova.servers.list(search_opts=search_opts)
     for server in servers:
-        return VmInst(name=server.name, inst_id=server.id,
-                      networks=server.networks)
+        return __map_os_server_obj_to_vm_inst(server)
+
+
+def __map_os_server_obj_to_vm_inst(os_server):
+    """
+    Returns a VmInst object for an OpenStack Server object
+    :param os_server: the OpenStack server object
+    :return: an equivalent SNAPS-OO VmInst domain object
+    """
+    sec_grp_names = list()
+    # VM must be active for 'security_groups' attr to be initialized
+    if hasattr(os_server, 'security_groups'):
+        for sec_group in os_server.security_groups:
+            if sec_group.get('name'):
+                sec_grp_names.append(sec_group.get('name'))
+
+    return VmInst(
+        name=os_server.name, inst_id=os_server.id,
+        image_id=os_server.image['id'], flavor_id=os_server.flavor['id'],
+        networks=os_server.networks, keypair_name=os_server.key_name,
+        sec_grp_names=sec_grp_names)
 
 
 def __get_latest_server_os_object(nova, server):
@@ -136,7 +155,17 @@ def __get_latest_server_os_object(nova, server):
     :param server: the domain VmInst object
     :return: the list of servers or None if not found
     """
-    return nova.servers.get(server.id)
+    return __get_latest_server_os_object_by_id(nova, server.id)
+
+
+def __get_latest_server_os_object_by_id(nova, server_id):
+    """
+    Returns a server with a given id
+    :param nova: the Nova client
+    :param server_id: the server's ID
+    :return: the list of servers or None if not found
+    """
+    return nova.servers.get(server_id)
 
 
 def get_server_status(nova, server):
@@ -173,8 +202,18 @@ def get_latest_server_object(nova, server):
     :return: the list of servers or None if not found
     """
     server = __get_latest_server_os_object(nova, server)
-    return VmInst(name=server.name, inst_id=server.id,
-                  networks=server.networks)
+    return __map_os_server_obj_to_vm_inst(server)
+
+
+def get_server_object_by_id(nova, server_id):
+    """
+    Returns a server with a given id
+    :param nova: the Nova client
+    :param server_id: the server's id
+    :return: an SNAPS-OO VmInst object or None if not found
+    """
+    server = __get_latest_server_os_object_by_id(nova, server_id)
+    return __map_os_server_obj_to_vm_inst(server)
 
 
 def get_server_security_group_names(nova, server):
@@ -225,58 +264,6 @@ def public_key_openssh(keys):
                                           serialization.PublicFormat.OpenSSH)
 
 
-def save_keys_to_files(keys=None, pub_file_path=None, priv_file_path=None):
-    """
-    Saves the generated RSA generated keys to the filesystem
-    :param keys: the keys to save generated by cryptography
-    :param pub_file_path: the path to the public keys
-    :param priv_file_path: the path to the private keys
-    """
-    if keys:
-        if pub_file_path:
-            # To support '~'
-            pub_expand_file = os.path.expanduser(pub_file_path)
-            pub_dir = os.path.dirname(pub_expand_file)
-
-            if not os.path.isdir(pub_dir):
-                os.mkdir(pub_dir)
-
-            public_handle = None
-            try:
-                public_handle = open(pub_expand_file, 'wb')
-                public_bytes = keys.public_key().public_bytes(
-                    serialization.Encoding.OpenSSH,
-                    serialization.PublicFormat.OpenSSH)
-                public_handle.write(public_bytes)
-            finally:
-                if public_handle:
-                    public_handle.close()
-
-            os.chmod(pub_expand_file, 0o400)
-            logger.info("Saved public key to - " + pub_expand_file)
-        if priv_file_path:
-            # To support '~'
-            priv_expand_file = os.path.expanduser(priv_file_path)
-            priv_dir = os.path.dirname(priv_expand_file)
-            if not os.path.isdir(priv_dir):
-                os.mkdir(priv_dir)
-
-            private_handle = None
-            try:
-                private_handle = open(priv_expand_file, 'wb')
-                private_handle.write(
-                    keys.private_bytes(
-                        encoding=serialization.Encoding.PEM,
-                        format=serialization.PrivateFormat.TraditionalOpenSSL,
-                        encryption_algorithm=serialization.NoEncryption()))
-            finally:
-                if private_handle:
-                    private_handle.close()
-
-            os.chmod(priv_expand_file, 0o400)
-            logger.info("Saved private key to - " + priv_expand_file)
-
-
 def upload_keypair_file(nova, name, file_path):
     """
     Uploads a public key from a file
@@ -305,7 +292,8 @@ def upload_keypair(nova, name, key):
     """
     logger.info('Creating keypair with name - ' + name)
     os_kp = nova.keypairs.create(name=name, public_key=key.decode('utf-8'))
-    return Keypair(name=os_kp.name, id=os_kp.id, public_key=os_kp.public_key)
+    return Keypair(name=os_kp.name, kp_id=os_kp.id,
+                   public_key=os_kp.public_key, fingerprint=os_kp.fingerprint)
 
 
 def keypair_exists(nova, keypair_obj):
@@ -317,7 +305,7 @@ def keypair_exists(nova, keypair_obj):
     """
     try:
         os_kp = nova.keypairs.get(keypair_obj)
-        return Keypair(name=os_kp.name, id=os_kp.id,
+        return Keypair(name=os_kp.name, kp_id=os_kp.id,
                        public_key=os_kp.public_key)
     except:
         return None
@@ -334,7 +322,7 @@ def get_keypair_by_name(nova, name):
 
     for keypair in keypairs:
         if keypair.name == name:
-            return Keypair(name=keypair.name, id=keypair.id,
+            return Keypair(name=keypair.name, kp_id=keypair.id,
                            public_key=keypair.public_key)
 
     return None
@@ -377,15 +365,15 @@ def delete_vm_instance(nova, vm_inst):
     nova.servers.delete(vm_inst.id)
 
 
-def __get_os_flavor(nova, flavor):
+def __get_os_flavor(nova, flavor_id):
     """
     Returns to OpenStack flavor object by name
     :param nova: the Nova client
-    :param flavor: the SNAPS flavor domain object
+    :param flavor_id: the flavor's ID value
     :return: the OpenStack Flavor object
     """
     try:
-        return nova.flavors.get(flavor.id)
+        return nova.flavors.get(flavor_id)
     except NotFound:
         return None
 
@@ -397,7 +385,7 @@ def get_flavor(nova, flavor):
     :param flavor: the SNAPS flavor domain object
     :return: the SNAPS Flavor domain object
     """
-    os_flavor = __get_os_flavor(nova, flavor)
+    os_flavor = __get_os_flavor(nova, flavor.id)
     if os_flavor:
         return Flavor(
             name=os_flavor.name, id=os_flavor.id, ram=os_flavor.ram,
@@ -410,6 +398,22 @@ def get_flavor(nova, flavor):
         return None
 
 
+def get_flavor_by_id(nova, flavor_id):
+    """
+    Returns to OpenStack flavor object by name
+    :param nova: the Nova client
+    :param flavor_id: the flavor ID value
+    :return: the SNAPS Flavor domain object
+    """
+    os_flavor = __get_os_flavor(nova, flavor_id)
+    if os_flavor:
+        return Flavor(
+            name=os_flavor.name, id=os_flavor.id, ram=os_flavor.ram,
+            disk=os_flavor.disk, vcpus=os_flavor.vcpus,
+            ephemeral=os_flavor.ephemeral, swap=os_flavor.swap,
+            rxtx_factor=os_flavor.rxtx_factor, is_public=os_flavor.is_public)
+
+
 def __get_os_flavor_by_name(nova, name):
     """
     Returns to OpenStack flavor object by name
@@ -475,7 +479,7 @@ def set_flavor_keys(nova, flavor, metadata):
     :param flavor: the SNAPS flavor domain object
     :param metadata: the metadata to set
     """
-    os_flavor = __get_os_flavor(nova, flavor)
+    os_flavor = __get_os_flavor(nova, flavor.id)
     if os_flavor:
         os_flavor.set_keys(metadata)
 
@@ -486,7 +490,7 @@ def get_flavor_keys(nova, flavor):
     :param nova: the Nova client
     :param flavor: the SNAPS flavor domain object
     """
-    os_flavor = __get_os_flavor(nova, flavor)
+    os_flavor = __get_os_flavor(nova, flavor.id)
     if os_flavor:
         return os_flavor.get_keys()
 
diff --git a/snaps/openstack/utils/settings_utils.py b/snaps/openstack/utils/settings_utils.py
new file mode 100644
index 0000000..7f00075
--- /dev/null
+++ b/snaps/openstack/utils/settings_utils.py
@@ -0,0 +1,219 @@
+# Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
+#                    and others.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.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
+#
+# Unless required by applicable law or agreed to in writing, 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.
+import uuid
+
+from snaps import file_utils
+from snaps.openstack.create_instance import (
+    VmInstanceSettings, FloatingIpSettings)
+from snaps.openstack.create_keypairs import KeypairSettings
+from snaps.openstack.create_network import (
+    PortSettings, SubnetSettings, NetworkSettings)
+from snaps.openstack.utils import (
+    neutron_utils, nova_utils, heat_utils, glance_utils)
+
+
+def create_network_settings(neutron, network):
+    """
+    Returns a NetworkSettings object
+    :param neutron: the neutron client
+    :param network: a SNAPS-OO Network domain object
+    :return:
+    """
+    return NetworkSettings(
+        name=network.name, network_type=network.type,
+        subnet_settings=create_subnet_settings(neutron, network))
+
+
+def create_subnet_settings(neutron, network):
+    """
+    Returns a list of SubnetSettings objects for a given network
+    :param neutron: the OpenStack neutron client
+    :param network: the SNAPS-OO Network domain object
+    :return: a list
+    """
+    out = list()
+
+    subnets = neutron_utils.get_subnets_by_network(neutron, network)
+    for subnet in subnets:
+        kwargs = dict()
+        kwargs['cidr'] = subnet.cidr
+        kwargs['ip_version'] = subnet.ip_version
+        kwargs['name'] = subnet.name
+        kwargs['start'] = subnet.start
+        kwargs['end'] = subnet.end
+        kwargs['gateway_ip'] = subnet.gateway_ip
+        kwargs['enable_dhcp'] = subnet.enable_dhcp
+        kwargs['dns_nameservers'] = subnet.dns_nameservers
+        kwargs['host_routes'] = subnet.host_routes
+        kwargs['ipv6_ra_mode'] = subnet.ipv6_ra_mode
+        kwargs['ipv6_address_mode'] = subnet.ipv6_address_mode
+        out.append(SubnetSettings(**kwargs))
+    return out
+
+
+def create_vm_inst_settings(nova, neutron, server):
+    """
+    Returns a NetworkSettings object
+    :param nova: the nova client
+    :param neutron: the neutron client
+    :param server: a SNAPS-OO VmInst domain object
+    :return:
+    """
+
+    flavor_name = nova_utils.get_flavor_by_id(nova, server.flavor_id)
+
+    kwargs = dict()
+    kwargs['name'] = server.name
+    kwargs['flavor'] = flavor_name
+    kwargs['port_settings'] = __create_port_settings(
+        neutron, server.networks)
+    kwargs['security_group_names'] = server.sec_grp_names
+    kwargs['floating_ip_settings'] = __create_floatingip_settings(
+        neutron, kwargs['port_settings'])
+
+    return VmInstanceSettings(**kwargs)
+
+
+def __create_port_settings(neutron, networks):
+    """
+    Returns a list of port settings based on the networks parameter
+    :param neutron: the neutron client
+    :param networks: a dict where the key is the network name and the value
+                     is a list of IP addresses
+    :return:
+    """
+    out = list()
+
+    for net_name, ips in networks.items():
+        network = neutron_utils.get_network(neutron, network_name=net_name)
+        ports = neutron_utils.get_ports(neutron, network, ips)
+        for port in ports:
+            kwargs = dict()
+            if port.name:
+                kwargs['name'] = port.name
+            kwargs['network_name'] = network.name
+            kwargs['mac_address'] = port.mac_address
+            kwargs['allowed_address_pairs'] = port.allowed_address_pairs
+            kwargs['admin_state_up'] = port.admin_state_up
+            out.append(PortSettings(**kwargs))
+
+    return out
+
+
+def __create_floatingip_settings(neutron, port_settings):
+    """
+    Returns a list of FloatingIPSettings objects as they pertain to an
+    existing deployed server instance
+    :param neutron: the neutron client
+    :param port_settings: list of SNAPS-OO PortSettings objects
+    :return: a list of FloatingIPSettings objects or an empty list if no
+             floating IPs have been created
+    """
+    base_fip_name = 'fip-'
+    fip_ctr = 1
+    out = list()
+
+    fip_ports = list()
+    for port_setting in port_settings:
+        setting_port = neutron_utils.get_port(neutron, port_setting)
+        if setting_port:
+            network = neutron_utils.get_network(
+                neutron, network_name=port_setting.network_name)
+            network_ports = neutron_utils.get_ports(neutron, network)
+            if network_ports:
+                for setting_port in network_ports:
+                    if port_setting.mac_address == setting_port.mac_address:
+                        fip_ports.append((port_setting.name, setting_port))
+                        break
+
+    floating_ips = neutron_utils.get_floating_ips(neutron, fip_ports)
+
+    for port_id, floating_ip in floating_ips:
+        router = neutron_utils.get_router_by_id(neutron, floating_ip.router_id)
+        setting_port = neutron_utils.get_port_by_id(
+            neutron, floating_ip.port_id)
+        kwargs = dict()
+        kwargs['name'] = base_fip_name + str(fip_ctr)
+        kwargs['port_name'] = setting_port.name
+        kwargs['port_id'] = setting_port.id
+        kwargs['router_name'] = router.name
+
+        if setting_port:
+            for ip_dict in setting_port.ips:
+                if ('ip_address' in ip_dict and
+                        'subnet_id' in ip_dict and
+                        ip_dict['ip_address'] == floating_ip.fixed_ip_address):
+                    subnet = neutron_utils.get_subnet_by_id(
+                        neutron, ip_dict['subnet_id'])
+                    if subnet:
+                        kwargs['subnet_name'] = subnet.name
+
+        out.append(FloatingIpSettings(**kwargs))
+
+        fip_ctr += 1
+
+    return out
+
+
+def determine_image_settings(glance, server, image_settings):
+    """
+    Returns a ImageSettings object from the list that matches the name in one
+    of the image_settings parameter
+    :param glance: the glance client
+    :param server: a SNAPS-OO VmInst domain object
+    :param image_settings: list of ImageSettings objects
+    :return: ImageSettings or None
+    """
+    if image_settings:
+        for image_setting in image_settings:
+            image = glance_utils.get_image_by_id(glance, server.image_id)
+            if image and image.name == image_setting.name:
+                return image_setting
+
+
+def determine_keypair_settings(heat_cli, stack, server, keypair_settings=None,
+                               priv_key_key=None):
+    """
+    Returns a KeypairSettings object from the list that matches the
+    server.keypair_name value in the keypair_settings parameter if not None,
+    else if the output_key is not None, the output's value when contains the
+    string 'BEGIN RSA PRIVATE KEY', this value will be stored into a file and
+    encoded into the KeypairSettings object returned
+    :param heat_cli: the OpenStack heat client
+    :param stack: a SNAPS-OO Stack domain object
+    :param server: a SNAPS-OO VmInst domain object
+    :param keypair_settings: list of KeypairSettings objects
+    :param priv_key_key: the stack options that holds the private key value
+    :return: KeypairSettings or None
+    """
+    # Existing keypair being used by Heat Template
+    if keypair_settings:
+        for keypair_setting in keypair_settings:
+            if server.keypair_name == keypair_setting.name:
+                return keypair_setting
+
+    # Keypair created by Heat template
+    if priv_key_key:
+        outputs = heat_utils.get_outputs(heat_cli, stack)
+        for output in outputs:
+            if output.key == priv_key_key:
+                # Save to file
+                guid = uuid.uuid4()
+                key_file = file_utils.save_string_to_file(
+                    output.value, str(guid), 0o400)
+
+                # Use outputs, file and resources for the KeypairSettings
+                return KeypairSettings(
+                    name=server.keypair_name, private_filepath=key_file.name)
diff --git a/snaps/openstack/utils/tests/heat_utils_tests.py b/snaps/openstack/utils/tests/heat_utils_tests.py
index 3293b2f..e7d6265 100644
--- a/snaps/openstack/utils/tests/heat_utils_tests.py
+++ b/snaps/openstack/utils/tests/heat_utils_tests.py
@@ -22,10 +22,12 @@ from snaps.openstack import create_stack
 from snaps.openstack.create_flavor import OpenStackFlavor, FlavorSettings
 
 from snaps.openstack.create_image import OpenStackImage
+from snaps.openstack.create_instance import OpenStackVmInstance
 from snaps.openstack.create_stack import StackSettings
 from snaps.openstack.tests import openstack_tests
 from snaps.openstack.tests.os_source_file_test import OSComponentTestCase
-from snaps.openstack.utils import heat_utils, neutron_utils
+from snaps.openstack.utils import (
+    heat_utils, neutron_utils, nova_utils, settings_utils, glance_utils)
 
 __author__ = 'spisarski'
 
@@ -67,7 +69,7 @@ class HeatSmokeTests(OSComponentTestCase):
                 print stack
 
 
-class HeatUtilsCreateStackTests(OSComponentTestCase):
+class HeatUtilsCreateSimpleStackTests(OSComponentTestCase):
     """
     Test basic Heat functionality
     """
@@ -81,6 +83,7 @@ class HeatUtilsCreateStackTests(OSComponentTestCase):
         stack_name2 = guid + '-stack2'
         self.network_name = guid + '-net'
         self.subnet_name = guid + '-subnet'
+        self.vm_inst_name = guid + '-inst'
 
         self.image_creator = OpenStackImage(
             self.os_creds, openstack_tests.cirros_image_settings(
@@ -96,7 +99,8 @@ class HeatUtilsCreateStackTests(OSComponentTestCase):
         env_values = {'image_name': self.image_creator.image_settings.name,
                       'flavor_name': self.flavor_creator.flavor_settings.name,
                       'net_name': self.network_name,
-                      'subnet_name': self.subnet_name}
+                      'subnet_name': self.subnet_name,
+                      'inst_name': self.vm_inst_name}
         heat_tmplt_path = pkg_resources.resource_filename(
             'snaps.openstack.tests.heat', 'test_heat_template.yaml')
         self.stack_settings1 = StackSettings(
@@ -156,13 +160,16 @@ class HeatUtilsCreateStackTests(OSComponentTestCase):
                                                    self.stack1.id)
         self.assertEqual(self.stack1, stack_query_3)
 
-        outputs = heat_utils.get_stack_outputs(
-            self.heat_client, self.stack1.id)
+        resources = heat_utils.get_resources(self.heat_client, self.stack1)
+        self.assertIsNotNone(resources)
+        self.assertEqual(4, len(resources))
+
+        outputs = heat_utils.get_outputs(self.heat_client, self.stack1)
         self.assertIsNotNone(outputs)
         self.assertEqual(0, len(outputs))
 
+        # Wait until stack deployment has completed
         end_time = time.time() + create_stack.STACK_COMPLETE_TIMEOUT
-
         is_active = False
         while time.time() < end_time:
             status = heat_utils.get_stack_status(self.heat_client,
@@ -178,10 +185,6 @@ class HeatUtilsCreateStackTests(OSComponentTestCase):
 
         self.assertTrue(is_active)
 
-        resources = heat_utils.get_resources(self.heat_client, self.stack1)
-        self.assertIsNotNone(resources)
-        self.assertEqual(4, len(resources))
-
         neutron = neutron_utils.neutron_client(self.os_creds)
         networks = heat_utils.get_stack_networks(
             self.heat_client, neutron, self.stack1)
@@ -193,6 +196,13 @@ class HeatUtilsCreateStackTests(OSComponentTestCase):
         self.assertEqual(1, len(subnets))
         self.assertEqual(self.subnet_name, subnets[0].name)
 
+        nova = nova_utils.nova_client(self.os_creds)
+        servers = heat_utils.get_stack_servers(
+            self.heat_client, nova, self.stack1)
+        self.assertIsNotNone(servers)
+        self.assertEqual(1, len(servers))
+        self.assertEqual(self.vm_inst_name, servers[0].name)
+
     def test_create_stack_x2(self):
         """
         Tests the creation of an OpenStack keypair that does not exist.
@@ -212,13 +222,7 @@ class HeatUtilsCreateStackTests(OSComponentTestCase):
                                                     self.stack1.id)
         self.assertEqual(self.stack1, stack1_query_3)
 
-        outputs = heat_utils.get_stack_outputs(self.heat_client,
-                                               self.stack1.id)
-        self.assertIsNotNone(outputs)
-        self.assertEqual(0, len(outputs))
-
         end_time = time.time() + create_stack.STACK_COMPLETE_TIMEOUT
-
         is_active = False
         while time.time() < end_time:
             status = heat_utils.get_stack_status(self.heat_client,
@@ -249,11 +253,6 @@ class HeatUtilsCreateStackTests(OSComponentTestCase):
                                                     self.stack2.id)
         self.assertEqual(self.stack2, stack2_query_3)
 
-        outputs = heat_utils.get_stack_outputs(self.heat_client,
-                                               self.stack2.id)
-        self.assertIsNotNone(outputs)
-        self.assertEqual(0, len(outputs))
-
         end_time = time.time() + create_stack.STACK_COMPLETE_TIMEOUT
 
         is_active = False
@@ -270,3 +269,194 @@ class HeatUtilsCreateStackTests(OSComponentTestCase):
             time.sleep(3)
 
         self.assertTrue(is_active)
+
+
+class HeatUtilsCreateComplexStackTests(OSComponentTestCase):
+    """
+    Test basic Heat functionality
+    """
+
+    def setUp(self):
+        """
+        Instantiates OpenStack instances that cannot be spawned by Heat
+        """
+        guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
+        stack_name = guid + '-stack'
+        self.network_name = guid + '-net'
+        self.subnet_name = guid + '-subnet'
+        self.vm_inst1_name = guid + '-inst1'
+        self.vm_inst2_name = guid + '-inst2'
+        self.flavor1_name = guid + '-flavor1'
+        self.flavor2_name = guid + '-flavor2'
+        self.keypair_name = guid + '-keypair'
+
+        self.image_creator1 = OpenStackImage(
+            self.os_creds, openstack_tests.cirros_image_settings(
+                name=guid + '-image1', image_metadata=self.image_metadata))
+        self.image_creator1.create()
+
+        self.image_creator2 = OpenStackImage(
+            self.os_creds, openstack_tests.cirros_image_settings(
+                name=guid + '-image2', image_metadata=self.image_metadata))
+        self.image_creator2.create()
+
+        env_values = {'image1_name': self.image_creator1.image_settings.name,
+                      'image2_name': self.image_creator2.image_settings.name,
+                      'flavor1_name': self.flavor1_name,
+                      'flavor2_name': self.flavor2_name,
+                      'net_name': self.network_name,
+                      'subnet_name': self.subnet_name,
+                      'keypair_name': self.keypair_name,
+                      'inst1_name': self.vm_inst1_name,
+                      'inst2_name': self.vm_inst2_name,
+                      'external_net_name': self.ext_net_name}
+        heat_tmplt_path = pkg_resources.resource_filename(
+            'snaps.openstack.tests.heat', 'floating_ip_heat_template.yaml')
+        stack_settings = StackSettings(
+            name=stack_name, template_path=heat_tmplt_path,
+            env_values=env_values)
+        self.heat_client = heat_utils.heat_client(self.os_creds)
+        self.stack = heat_utils.create_stack(self.heat_client, stack_settings)
+
+        # Wait until stack deployment has completed
+        end_time = time.time() + create_stack.STACK_COMPLETE_TIMEOUT
+        is_active = False
+        while time.time() < end_time:
+            status = heat_utils.get_stack_status(self.heat_client,
+                                                 self.stack.id)
+            if status == create_stack.STATUS_CREATE_COMPLETE:
+                is_active = True
+                break
+            elif status == create_stack.STATUS_CREATE_FAILED:
+                is_active = False
+                break
+
+            time.sleep(3)
+        self.assertTrue(is_active)
+
+    def tearDown(self):
+        """
+        Cleans the image and downloaded image file
+        """
+        if self.stack:
+            try:
+                heat_utils.delete_stack(self.heat_client, self.stack)
+                # Wait until stack deployment has completed
+                end_time = time.time() + create_stack.STACK_COMPLETE_TIMEOUT
+                is_deleted = False
+                while time.time() < end_time:
+                    status = heat_utils.get_stack_status(self.heat_client,
+                                                         self.stack.id)
+                    if status == create_stack.STATUS_DELETE_COMPLETE:
+                        is_deleted = True
+                        break
+                    elif status == create_stack.STATUS_DELETE_FAILED:
+                        is_deleted = False
+                        break
+
+                    time.sleep(3)
+
+                if not is_deleted:
+                    nova = nova_utils.nova_client(self.os_creds)
+                    neutron = neutron_utils.neutron_client(self.os_creds)
+                    glance = glance_utils.glance_client(self.os_creds)
+                    servers = heat_utils.get_stack_servers(
+                        self.heat_client, nova, self.stack)
+                    for server in servers:
+                        vm_settings = settings_utils.create_vm_inst_settings(
+                            nova, neutron, server)
+                        img_settings = settings_utils.determine_image_settings(
+                            glance, server,
+                            [self.image_creator1.image_settings,
+                             self.image_creator2.image_settings])
+                        vm_creator = OpenStackVmInstance(
+                            self.os_creds, vm_settings, img_settings)
+                        vm_creator.create(cleanup=False)
+                        vm_creator.clean()
+                        vm_creator.vm_deleted(block=True)
+
+                    heat_utils.delete_stack(self.heat_client, self.stack)
+                    time.sleep(20)
+            except:
+                    raise
+
+        if self.image_creator1:
+            try:
+                self.image_creator1.clean()
+            except:
+                pass
+
+        if self.image_creator2:
+            try:
+                self.image_creator2.clean()
+            except:
+                pass
+
+    def test_get_settings_from_stack(self):
+        """
+        Tests that a heat template with floating IPs and can have the proper
+        settings derived from settings_utils.py.
+        """
+        resources = heat_utils.get_resources(self.heat_client, self.stack)
+        self.assertIsNotNone(resources)
+        self.assertEqual(11, len(resources))
+
+        options = heat_utils.get_outputs(self.heat_client, self.stack)
+        self.assertIsNotNone(options)
+        self.assertEqual(1, len(options))
+
+        neutron = neutron_utils.neutron_client(self.os_creds)
+        networks = heat_utils.get_stack_networks(
+            self.heat_client, neutron, self.stack)
+        self.assertIsNotNone(networks)
+        self.assertEqual(1, len(networks))
+        self.assertEqual(self.network_name, networks[0].name)
+
+        network_settings = settings_utils.create_network_settings(
+            neutron, networks[0])
+        self.assertIsNotNone(network_settings)
+        self.assertEqual(self.network_name, network_settings.name)
+
+        nova = nova_utils.nova_client(self.os_creds)
+        glance = glance_utils.glance_client(self.os_creds)
+
+        servers = heat_utils.get_stack_servers(
+            self.heat_client, nova, self.stack)
+        self.assertIsNotNone(servers)
+        self.assertEqual(2, len(servers))
+
+        image_settings = settings_utils.determine_image_settings(
+            glance, servers[0],
+            [self.image_creator1.image_settings,
+             self.image_creator2.image_settings])
+
+        self.assertIsNotNone(image_settings)
+        if image_settings.name.endswith('1'):
+            self.assertEqual(
+                self.image_creator1.image_settings.name, image_settings.name)
+        else:
+            self.assertEqual(
+                self.image_creator2.image_settings.name, image_settings.name)
+
+        image_settings = settings_utils.determine_image_settings(
+            glance, servers[1],
+            [self.image_creator1.image_settings,
+             self.image_creator2.image_settings])
+        if image_settings.name.endswith('1'):
+            self.assertEqual(
+                self.image_creator1.image_settings.name, image_settings.name)
+        else:
+            self.assertEqual(
+                self.image_creator2.image_settings.name, image_settings.name)
+
+        keypair1_settings = settings_utils.determine_keypair_settings(
+            self.heat_client, self.stack, servers[0],
+            priv_key_key='private_key')
+        self.assertIsNotNone(keypair1_settings)
+        self.assertEqual(self.keypair_name, keypair1_settings.name)
+
+        keypair2_settings = settings_utils.determine_keypair_settings(
+            self.heat_client, self.stack, servers[1],
+            priv_key_key='private_key')
+        self.assertIsNotNone(keypair2_settings)
+        self.assertEqual(self.keypair_name, keypair2_settings.name)
diff --git a/snaps/openstack/utils/tests/neutron_utils_tests.py b/snaps/openstack/utils/tests/neutron_utils_tests.py
index 5493f5b..05d508d 100644
--- a/snaps/openstack/utils/tests/neutron_utils_tests.py
+++ b/snaps/openstack/utils/tests/neutron_utils_tests.py
@@ -502,8 +502,7 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
 
     def test_create_port_null_name(self):
         """
-        Tests the neutron_utils.create_port() function for an Exception when
-        the port name value is None
+        Tests the neutron_utils.create_port() when the port name value is None
         """
         self.network = neutron_utils.create_network(
             self.neutron, self.os_creds, self.net_config.network_settings)
@@ -519,14 +518,16 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         self.assertTrue(validate_subnet(
             self.neutron, subnet_setting.name, subnet_setting.cidr, True))
 
-        with self.assertRaises(Exception):
-            self.port = neutron_utils.create_port(
-                self.neutron, self.os_creds,
-                PortSettings(
-                    network_name=self.net_config.network_settings.name,
-                    ip_addrs=[{
-                        'subnet_name': subnet_setting.name,
-                        'ip': ip_1}]))
+        self.port = neutron_utils.create_port(
+            self.neutron, self.os_creds,
+            PortSettings(
+                network_name=self.net_config.network_settings.name,
+                ip_addrs=[{
+                    'subnet_name': subnet_setting.name,
+                    'ip': ip_1}]))
+
+        port = neutron_utils.get_port_by_id(self.neutron, self.port.id)
+        self.assertEqual(self.port, port)
 
     def test_create_port_null_network_object(self):
         """
diff --git a/snaps/openstack/utils/tests/nova_utils_tests.py b/snaps/openstack/utils/tests/nova_utils_tests.py
index b2eda97..c5b29b5 100644
--- a/snaps/openstack/utils/tests/nova_utils_tests.py
+++ b/snaps/openstack/utils/tests/nova_utils_tests.py
@@ -16,6 +16,10 @@ import logging
 import uuid
 
 import os
+import time
+
+from snaps import file_utils
+from snaps.openstack import create_instance
 from snaps.openstack.create_flavor import FlavorSettings, OpenStackFlavor
 from snaps.openstack.create_image import OpenStackImage
 from snaps.openstack.create_instance import VmInstanceSettings
@@ -130,7 +134,7 @@ class NovaUtilsKeypairTests(OSComponentTestCase):
         Tests that the generated RSA keys are properly saved to files
         :return:
         """
-        nova_utils.save_keys_to_files(self.keys, self.pub_key_file_path,
+        file_utils.save_keys_to_files(self.keys, self.pub_key_file_path,
                                       self.priv_key_file_path)
         self.keypair = nova_utils.upload_keypair_file(self.nova,
                                                       self.keypair_name,
@@ -308,6 +312,19 @@ class NovaUtilsInstanceTests(OSComponentTestCase):
 
         self.assertIsNotNone(self.vm_inst)
 
+        # Wait until instance is ACTIVE
+        iters = 0
+        active = False
+        while iters < 60:
+            if create_instance.STATUS_ACTIVE == nova_utils.get_server_status(
+                    self.nova, self.vm_inst):
+                active = True
+                break
+
+            time.sleep(3)
+            iters += 1
+
+        self.assertTrue(active)
         vm_inst = nova_utils.get_latest_server_object(self.nova, self.vm_inst)
 
         self.assertEqual(self.vm_inst.name, vm_inst.name)
diff --git a/snaps/openstack/utils/tests/settings_utils_tests.py b/snaps/openstack/utils/tests/settings_utils_tests.py
new file mode 100644
index 0000000..f84e6a0
--- /dev/null
+++ b/snaps/openstack/utils/tests/settings_utils_tests.py
@@ -0,0 +1,341 @@
+# Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
+#                    and others.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.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
+#
+# Unless required by applicable law or agreed to in writing, 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.
+import logging
+import os
+import uuid
+
+from snaps.openstack import (
+    create_image, create_network, create_router, create_flavor,
+    create_keypairs, create_instance)
+from snaps.openstack.create_network import (
+    NetworkSettings, OpenStackNetwork, SubnetSettings)
+from snaps.openstack.create_security_group import (
+    SecurityGroupRuleSettings,  Direction, Protocol, OpenStackSecurityGroup,
+    SecurityGroupSettings)
+from snaps.openstack.tests import openstack_tests
+from snaps.openstack.tests.os_source_file_test import OSComponentTestCase
+from snaps.openstack.utils import (
+    neutron_utils, settings_utils, nova_utils, glance_utils)
+
+__author__ = 'spisarski'
+
+logger = logging.getLogger('nova_utils_tests')
+
+
+class SettingsUtilsNetworkingTests(OSComponentTestCase):
+    """
+    Tests the ability to reverse engineer NetworkSettings objects from existing
+    networks deployed to OpenStack
+    """
+
+    def setUp(self):
+        """
+        Instantiates OpenStack instances that cannot be spawned by Heat
+        """
+        guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
+        self.network_name = guid + '-net'
+        self.subnet_name = guid + '-subnet'
+        self.net_creator = None
+        self.neutron = neutron_utils.neutron_client(self.os_creds)
+
+    def tearDown(self):
+        """
+        Cleans the image and downloaded image file
+        """
+        if self.net_creator:
+            try:
+                self.net_creator.clean()
+            except:
+                pass
+
+    def test_derive_net_settings_no_subnet(self):
+        """
+        Validates the utility function settings_utils#create_network_settings
+        returns an acceptable NetworkSettings object and ensures that the
+        new settings object will not cause the new OpenStackNetwork instance
+        to create another network
+        """
+        net_settings = NetworkSettings(name=self.network_name)
+        self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
+        network = self.net_creator.create()
+
+        derived_settings = settings_utils.create_network_settings(
+            self.neutron, network)
+
+        self.assertIsNotNone(derived_settings)
+        self.assertEqual(net_settings.name, derived_settings.name)
+        self.assertEqual(net_settings.admin_state_up,
+                         derived_settings.admin_state_up)
+        self.assertEqual(net_settings.external, derived_settings.external)
+        self.assertEqual(len(net_settings.subnet_settings),
+                         len(derived_settings.subnet_settings))
+
+        net_creator = OpenStackNetwork(self.os_creds, derived_settings)
+        derived_network = net_creator.create()
+
+        self.assertEqual(network, derived_network)
+
+    def test_derive_net_settings_two_subnets(self):
+        """
+        Validates the utility function settings_utils#create_network_settings
+        returns an acceptable NetworkSettings object
+        """
+        subnet_settings = list()
+        subnet_settings.append(SubnetSettings(name='sub1', cidr='10.0.0.0/24'))
+        subnet_settings.append(SubnetSettings(name='sub2', cidr='10.0.1.0/24'))
+        net_settings = NetworkSettings(name=self.network_name,
+                                       subnet_settings=subnet_settings)
+        self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
+        network = self.net_creator.create()
+
+        derived_settings = settings_utils.create_network_settings(
+            self.neutron, network)
+
+        self.assertIsNotNone(derived_settings)
+        self.assertEqual(net_settings.name, derived_settings.name)
+        self.assertEqual(net_settings.admin_state_up,
+                         derived_settings.admin_state_up)
+        self.assertEqual(net_settings.external, derived_settings.external)
+        self.assertEqual(len(net_settings.subnet_settings),
+                         len(derived_settings.subnet_settings))
+
+        # Validate the first subnet
+        orig_sub1 = net_settings.subnet_settings[0]
+        found = False
+        for derived_sub in derived_settings.subnet_settings:
+            if orig_sub1.name == derived_sub.name:
+                self.assertEqual(orig_sub1.cidr, derived_sub.cidr)
+                found = True
+
+        self.assertTrue(found)
+
+        # Validate the second subnet
+        orig_sub2 = net_settings.subnet_settings[1]
+        found = False
+        for derived_sub in derived_settings.subnet_settings:
+            if orig_sub2.name == derived_sub.name:
+                self.assertEqual(orig_sub2.cidr, derived_sub.cidr)
+                self.assertEqual(orig_sub2.ip_version, derived_sub.ip_version)
+                found = True
+
+        self.assertTrue(found)
+
+
+class SettingsUtilsVmInstTests(OSComponentTestCase):
+    """
+    Tests the ability to reverse engineer VmInstanceSettings objects from
+    existing VMs/servers deployed to OpenStack
+    """
+
+    def setUp(self):
+        """
+        Instantiates the CreateImage object that is responsible for downloading
+        and creating an OS image file within OpenStack
+        """
+        # super(self.__class__, self).__start__()
+
+        self.nova = nova_utils.nova_client(self.os_creds)
+        self.glance = glance_utils.glance_client(self.os_creds)
+        self.neutron = neutron_utils.neutron_client(self.os_creds)
+
+        guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
+        self.keypair_priv_filepath = 'tmp/' + guid
+        self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
+        self.keypair_name = guid + '-kp'
+        self.vm_inst_name = guid + '-inst'
+        self.test_file_local_path = 'tmp/' + guid + '-hello.txt'
+        self.port_1_name = guid + '-port-1'
+        self.port_2_name = guid + '-port-2'
+        self.floating_ip_name = guid + 'fip1'
+
+        # Setup members to cleanup just in case they don't get created
+        self.inst_creator = None
+        self.keypair_creator = None
+        self.sec_grp_creator = None
+        self.flavor_creator = None
+        self.router_creator = None
+        self.network_creator = None
+        self.image_creator = None
+
+        try:
+            # Create Image
+            os_image_settings = openstack_tests.cirros_image_settings(
+                name=guid + '-' + '-image',
+                image_metadata=self.image_metadata)
+            self.image_creator = create_image.OpenStackImage(self.os_creds,
+                                                             os_image_settings)
+            self.image_creator.create()
+
+            # First network is public
+            self.pub_net_config = openstack_tests.get_pub_net_config(
+                net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
+                router_name=guid + '-pub-router',
+                external_net=self.ext_net_name)
+
+            self.network_creator = create_network.OpenStackNetwork(
+                self.os_creds, self.pub_net_config.network_settings)
+            self.network_creator.create()
+
+            # Create routers
+            self.router_creator = create_router.OpenStackRouter(
+                self.os_creds, self.pub_net_config.router_settings)
+            self.router_creator.create()
+
+            # Create Flavor
+            self.flavor_creator = create_flavor.OpenStackFlavor(
+                self.os_creds,
+                create_flavor.FlavorSettings(name=guid + '-flavor-name',
+                                             ram=256, disk=1, vcpus=1))
+            self.flavor_creator.create()
+
+            # Create Key/Pair
+            self.keypair_creator = create_keypairs.OpenStackKeypair(
+                self.os_creds, create_keypairs.KeypairSettings(
+                    name=self.keypair_name,
+                    public_filepath=self.keypair_pub_filepath,
+                    private_filepath=self.keypair_priv_filepath))
+            self.keypair_creator.create()
+
+            # Create Security Group
+            sec_grp_name = guid + '-sec-grp'
+            rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
+                                              direction=Direction.ingress,
+                                              protocol=Protocol.icmp)
+            rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
+                                              direction=Direction.ingress,
+                                              protocol=Protocol.tcp,
+                                              port_range_min=22,
+                                              port_range_max=22)
+            self.sec_grp_creator = OpenStackSecurityGroup(
+                self.os_creds,
+                SecurityGroupSettings(name=sec_grp_name,
+                                      rule_settings=[rule1, rule2]))
+            self.sec_grp_creator.create()
+
+            # Create instance
+            ports_settings = list()
+            ports_settings.append(
+                create_network.PortSettings(
+                    name=self.port_1_name,
+                    network_name=self.pub_net_config.network_settings.name))
+
+            instance_settings = create_instance.VmInstanceSettings(
+                name=self.vm_inst_name,
+                flavor=self.flavor_creator.flavor_settings.name,
+                port_settings=ports_settings,
+                floating_ip_settings=[create_instance.FloatingIpSettings(
+                    name=self.floating_ip_name, port_name=self.port_1_name,
+                    router_name=self.pub_net_config.router_settings.name)])
+
+            self.inst_creator = create_instance.OpenStackVmInstance(
+                self.os_creds, instance_settings,
+                self.image_creator.image_settings,
+                keypair_settings=self.keypair_creator.keypair_settings)
+        except:
+            self.tearDown()
+            raise
+
+    def tearDown(self):
+        """
+        Cleans the created objects
+        """
+        if self.inst_creator:
+            try:
+                self.inst_creator.clean()
+            except:
+                pass
+
+        if self.sec_grp_creator:
+            try:
+                self.sec_grp_creator.clean()
+            except:
+                pass
+
+        if self.keypair_creator:
+            try:
+                self.keypair_creator.clean()
+            except:
+                pass
+
+        if self.flavor_creator:
+            try:
+                self.flavor_creator.clean()
+            except:
+                pass
+
+        if os.path.isfile(self.keypair_pub_filepath):
+            try:
+                os.remove(self.keypair_pub_filepath)
+            except:
+                pass
+
+        if os.path.isfile(self.keypair_priv_filepath):
+            try:
+                os.remove(self.keypair_priv_filepath)
+            except:
+                pass
+
+        if self.router_creator:
+            try:
+                self.router_creator.clean()
+            except:
+                pass
+
+        if self.network_creator:
+            try:
+                self.network_creator.clean()
+            except:
+                pass
+
+        if self.image_creator and not self.image_creator.image_settings.exists:
+            try:
+                self.image_creator.clean()
+            except:
+                pass
+
+        if os.path.isfile(self.test_file_local_path):
+            os.remove(self.test_file_local_path)
+
+        # super(self.__class__, self).__clean__()
+
+    def test_derive_vm_inst_settings(self):
+        """
+        Validates the utility function settings_utils#create_vm_inst_settings
+        returns an acceptable VmInstanceSettings object
+        """
+        self.inst_creator.create(block=True)
+
+        server = nova_utils.get_server(
+            self.nova, vm_inst_settings=self.inst_creator.instance_settings)
+        derived_vm_settings = settings_utils.create_vm_inst_settings(
+            self.nova, self.neutron, server)
+        self.assertIsNotNone(derived_vm_settings)
+        self.assertIsNotNone(derived_vm_settings.port_settings)
+        self.assertIsNotNone(derived_vm_settings.floating_ip_settings)
+
+    def test_derive_image_settings(self):
+        """
+        Validates the utility function settings_utils#create_image_settings
+        returns an acceptable ImageSettings object
+        """
+        self.inst_creator.create(block=True)
+
+        server = nova_utils.get_server(
+            self.nova, vm_inst_settings=self.inst_creator.instance_settings)
+        derived_image_settings = settings_utils.determine_image_settings(
+            self.glance, server, [self.image_creator.image_settings])
+        self.assertIsNotNone(derived_image_settings)
+        self.assertEqual(self.image_creator.image_settings.name,
+                         derived_image_settings.name)