Patch to make flavor configuration for tests more flexible.

[snaps.git] / snaps / openstack / tests / create_instance_tests.py

diff --git a/snaps/openstack/tests/create_instance_tests.py b/snaps/openstack/tests/create_instance_tests.py
index c7a6c83..bdd6d50 100644 (file)
--- a/snaps/openstack/tests/create_instance_tests.py
+++ b/snaps/openstack/tests/create_instance_tests.py
@@ -20,33 +20,36 @@ import unittest
 import uuid
 
 import os
 import uuid
 
 import os

-from neutronclient.common.exceptions import InvalidIpForSubnetClient
-from novaclient.exceptions import BadRequest
+from neutronclient.common.exceptions import (
+    InvalidIpForSubnetClient, BadRequest)

 
 from snaps import file_utils
 
 from snaps import file_utils

-from snaps.config.volume import VolumeConfig
-from snaps.config.router import RouterConfig
+from snaps.config.image import ImageConfig

 from snaps.config.keypair import KeypairConfig
 from snaps.config.keypair import KeypairConfig

-from snaps.openstack import create_network, create_router
-from snaps.config.flavor import FlavorConfig
+from snaps.config.network import PortConfig, NetworkConfig, SubnetConfig
+from snaps.config.router import RouterConfig
+from snaps.config.security_group import (
+    Protocol, SecurityGroupRuleConfig, Direction, SecurityGroupConfig)
+from snaps.config.vm_inst import (
+    VmInstanceConfig, FloatingIpConfig,  VmInstanceConfigError,
+    FloatingIpConfigError)
+from snaps.config.volume import VolumeConfig
+from snaps.openstack import create_network, create_router, create_instance

 from snaps.openstack.create_flavor import OpenStackFlavor
 from snaps.openstack.create_flavor import OpenStackFlavor

-from snaps.config.image import ImageConfig

 from snaps.openstack.create_image import OpenStackImage
 from snaps.openstack.create_instance import (
 from snaps.openstack.create_image import OpenStackImage
 from snaps.openstack.create_instance import (

-    VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings,
-    VmInstanceSettingsError, FloatingIpSettingsError)
+    VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings)

 from snaps.openstack.create_keypairs import OpenStackKeypair
 from snaps.openstack.create_keypairs import OpenStackKeypair

-from snaps.openstack.create_network import (
-    OpenStackNetwork, PortSettings, NetworkSettings, SubnetSettings)
+from snaps.openstack.create_network import OpenStackNetwork

 from snaps.openstack.create_router import OpenStackRouter
 from snaps.openstack.create_router import OpenStackRouter

-from snaps.openstack.create_security_group import (
-    SecurityGroupSettings, OpenStackSecurityGroup, SecurityGroupRuleSettings,
-    Direction, Protocol)
+from snaps.openstack.create_security_group import OpenStackSecurityGroup

 from snaps.openstack.create_volume import OpenStackVolume
 from snaps.openstack.tests import openstack_tests, validation_utils
 from snaps.openstack.tests.os_source_file_test import (
     OSIntegrationTestCase, OSComponentTestCase)
 from snaps.openstack.create_volume import OpenStackVolume
 from snaps.openstack.tests import openstack_tests, validation_utils
 from snaps.openstack.tests.os_source_file_test import (
     OSIntegrationTestCase, OSComponentTestCase)

-from snaps.openstack.utils import nova_utils
+from snaps.openstack.utils import nova_utils, keystone_utils, neutron_utils
+from snaps.openstack.utils.nova_utils import RebootType
+from snaps.openstack.utils import nova_utils, settings_utils, neutron_utils

 
 __author__ = 'spisarski'
 
 
 __author__ = 'spisarski'
 


@@ -61,31 +64,31 @@ class VmInstanceSettingsUnitTests(unittest.TestCase):
     """
 
     def test_no_params(self):
     """
 
     def test_no_params(self):

-        with self.assertRaises(VmInstanceSettingsError):
+        with self.assertRaises(VmInstanceConfigError):

             VmInstanceSettings()
 
     def test_empty_config(self):
             VmInstanceSettings()
 
     def test_empty_config(self):

-        with self.assertRaises(VmInstanceSettingsError):
+        with self.assertRaises(VmInstanceConfigError):

             VmInstanceSettings(config=dict())
 
     def test_name_only(self):
             VmInstanceSettings(config=dict())
 
     def test_name_only(self):

-        with self.assertRaises(VmInstanceSettingsError):
+        with self.assertRaises(VmInstanceConfigError):

             VmInstanceSettings(name='foo')
 
     def test_config_with_name_only(self):
             VmInstanceSettings(name='foo')
 
     def test_config_with_name_only(self):

-        with self.assertRaises(VmInstanceSettingsError):
+        with self.assertRaises(VmInstanceConfigError):

             VmInstanceSettings(config={'name': 'foo'})
 
     def test_name_flavor_only(self):
             VmInstanceSettings(config={'name': 'foo'})
 
     def test_name_flavor_only(self):

-        with self.assertRaises(VmInstanceSettingsError):
+        with self.assertRaises(VmInstanceConfigError):

             VmInstanceSettings(name='foo', flavor='bar')
 
     def test_config_with_name_flavor_only(self):
             VmInstanceSettings(name='foo', flavor='bar')
 
     def test_config_with_name_flavor_only(self):

-        with self.assertRaises(VmInstanceSettingsError):
+        with self.assertRaises(VmInstanceConfigError):

             VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar'})
 
     def test_name_flavor_port_only(self):
             VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar'})
 
     def test_name_flavor_port_only(self):

-        port_settings = PortSettings(name='foo-port', network_name='bar-net')
+        port_settings = PortConfig(name='foo-port', network_name='bar-net')

         settings = VmInstanceSettings(name='foo', flavor='bar',
                                       port_settings=[port_settings])
         self.assertEqual('foo', settings.name)
         settings = VmInstanceSettings(name='foo', flavor='bar',
                                       port_settings=[port_settings])
         self.assertEqual('foo', settings.name)


@@ -103,7 +106,7 @@ class VmInstanceSettingsUnitTests(unittest.TestCase):
         self.assertIsNone(settings.volume_names)
 
     def test_config_with_name_flavor_port_only(self):
         self.assertIsNone(settings.volume_names)
 
     def test_config_with_name_flavor_port_only(self):

-        port_settings = PortSettings(name='foo-port', network_name='bar-net')
+        port_settings = PortConfig(name='foo-port', network_name='bar-net')

         settings = VmInstanceSettings(
             **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
         self.assertEqual('foo', settings.name)
         settings = VmInstanceSettings(
             **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
         self.assertEqual('foo', settings.name)


@@ -121,7 +124,7 @@ class VmInstanceSettingsUnitTests(unittest.TestCase):
         self.assertIsNone(settings.volume_names)
 
     def test_all(self):
         self.assertIsNone(settings.volume_names)
 
     def test_all(self):

-        port_settings = PortSettings(name='foo-port', network_name='bar-net')
+        port_settings = PortConfig(name='foo-port', network_name='bar-net')

         fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
                                           router_name='foo-bar-router')
 
         fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
                                           router_name='foo-bar-router')
 


@@ -153,7 +156,7 @@ class VmInstanceSettingsUnitTests(unittest.TestCase):
         self.assertEqual('vol1', settings.volume_names[0])
 
     def test_config_all(self):
         self.assertEqual('vol1', settings.volume_names[0])
 
     def test_config_all(self):

-        port_settings = PortSettings(name='foo-port', network_name='bar-net')
+        port_settings = PortConfig(name='foo-port', network_name='bar-net')

         fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
                                           router_name='foo-bar-router')
 
         fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
                                           router_name='foo-bar-router')
 


@@ -190,35 +193,35 @@ class FloatingIpSettingsUnitTests(unittest.TestCase):
     """
 
     def test_no_params(self):
     """
 
     def test_no_params(self):

-        with self.assertRaises(FloatingIpSettingsError):
+        with self.assertRaises(FloatingIpConfigError):

             FloatingIpSettings()
 
     def test_empty_config(self):
             FloatingIpSettings()
 
     def test_empty_config(self):

-        with self.assertRaises(FloatingIpSettingsError):
+        with self.assertRaises(FloatingIpConfigError):

             FloatingIpSettings(**dict())
 
     def test_name_only(self):
             FloatingIpSettings(**dict())
 
     def test_name_only(self):

-        with self.assertRaises(FloatingIpSettingsError):
+        with self.assertRaises(FloatingIpConfigError):

             FloatingIpSettings(name='foo')
 
     def test_config_with_name_only(self):
             FloatingIpSettings(name='foo')
 
     def test_config_with_name_only(self):

-        with self.assertRaises(FloatingIpSettingsError):
+        with self.assertRaises(FloatingIpConfigError):

             FloatingIpSettings(**{'name': 'foo'})
 
     def test_name_port_only(self):
             FloatingIpSettings(**{'name': 'foo'})
 
     def test_name_port_only(self):

-        with self.assertRaises(FloatingIpSettingsError):
+        with self.assertRaises(FloatingIpConfigError):

             FloatingIpSettings(name='foo', port_name='bar')
 
     def test_config_with_name_port_only(self):
             FloatingIpSettings(name='foo', port_name='bar')
 
     def test_config_with_name_port_only(self):

-        with self.assertRaises(FloatingIpSettingsError):
+        with self.assertRaises(FloatingIpConfigError):

             FloatingIpSettings(**{'name': 'foo', 'port_name': 'bar'})
 
     def test_name_router_only(self):
             FloatingIpSettings(**{'name': 'foo', 'port_name': 'bar'})
 
     def test_name_router_only(self):

-        with self.assertRaises(FloatingIpSettingsError):
+        with self.assertRaises(FloatingIpConfigError):

             FloatingIpSettings(name='foo', router_name='bar')
 
     def test_config_with_name_router_only(self):
             FloatingIpSettings(name='foo', router_name='bar')
 
     def test_config_with_name_router_only(self):

-        with self.assertRaises(FloatingIpSettingsError):
+        with self.assertRaises(FloatingIpConfigError):

             FloatingIpSettings(**{'name': 'foo', 'router_name': 'bar'})
 
     def test_name_port_router_name_only(self):
             FloatingIpSettings(**{'name': 'foo', 'router_name': 'bar'})
 
     def test_name_port_router_name_only(self):


@@ -290,7 +293,7 @@ class SimpleHealthCheck(OSIntegrationTestCase):
         """
         super(self.__class__, self).__start__()
 
         """
         super(self.__class__, self).__start__()
 

-        self.nova = nova_utils.nova_client(self.os_creds)
+        self.nova = nova_utils.nova_client(self.os_creds, self.os_session)

         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.vm_inst_name = guid + '-inst'
         self.port_1_name = guid + 'port-1'
         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.vm_inst_name = guid + '-inst'
         self.port_1_name = guid + 'port-1'


@@ -302,8 +305,11 @@ class SimpleHealthCheck(OSIntegrationTestCase):
         self.inst_creator = None
 
         self.priv_net_config = openstack_tests.get_priv_net_config(
         self.inst_creator = None
 
         self.priv_net_config = openstack_tests.get_priv_net_config(

-            net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
-        self.port_settings = PortSettings(
+            project_name=self.os_creds.project_name,
+            net_name=guid + '-priv-net',
+            subnet_name=guid + '-priv-subnet',
+            netconf_override=self.netconf_override)
+        self.port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.priv_net_config.network_settings.name)
 
             name=self.port_1_name,
             network_name=self.priv_net_config.network_settings.name)
 


@@ -324,10 +330,15 @@ class SimpleHealthCheck(OSIntegrationTestCase):
             self.network_creator.create()
 
             # Create Flavor
             self.network_creator.create()
 
             # Create Flavor

+            self.flavor_ram = 256
+            if (self.flavor_metadata and
+               self.flavor_metadata.get('hw:mem_page_size') == 'large'):
+                self.flavor_ram = 1024
+            flavor_config = openstack_tests.get_flavor_config(
+                name=guid + '-flavor-name', ram=self.flavor_ram, disk=10,
+                vcpus=1, metadata=self.flavor_metadata)

             self.flavor_creator = OpenStackFlavor(
             self.flavor_creator = OpenStackFlavor(

-                self.admin_os_creds,
-                FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
-                             vcpus=1, metadata=self.flavor_metadata))
+                self.admin_os_creds, flavor_config)

             self.flavor_creator.create()
         except Exception as e:
             self.tearDown()
             self.flavor_creator.create()
         except Exception as e:
             self.tearDown()


@@ -376,7 +387,7 @@ class SimpleHealthCheck(OSIntegrationTestCase):
         Tests the creation of an OpenStack instance with a single port and
         ensures that it's assigned IP address is the actual.
         """
         Tests the creation of an OpenStack instance with a single port and
         ensures that it's assigned IP address is the actual.
         """

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -401,21 +412,16 @@ class CreateInstanceSimpleTests(OSIntegrationTestCase):
 
     def setUp(self):
         """
 
     def setUp(self):
         """

-        Instantiates the CreateImage object that is responsible for downloading
-        and creating an OS image file
-        within OpenStack
+        Setup the objects required for the test

         """
         super(self.__class__, self).__start__()
 
         """
         super(self.__class__, self).__start__()
 

-        guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
-        self.vm_inst_name = guid + '-inst'
+        self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
+        self.vm_inst_name = self.guid + '-inst'

         self.nova = nova_utils.nova_client(self.os_creds)
         self.nova = nova_utils.nova_client(self.os_creds)

+        self.neutron = neutron_utils.neutron_client(self.os_creds)

         os_image_settings = openstack_tests.cirros_image_settings(
         os_image_settings = openstack_tests.cirros_image_settings(

-            name=guid + '-image', image_metadata=self.image_metadata)
-
-        net_config = openstack_tests.get_priv_net_config(
-            net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
-            router_name=guid + '-pub-router', external_net=self.ext_net_name)
+            name=self.guid + '-image', image_metadata=self.image_metadata)

 
         # Initialize for tearDown()
         self.image_creator = None
 
         # Initialize for tearDown()
         self.image_creator = None


@@ -431,21 +437,13 @@ class CreateInstanceSimpleTests(OSIntegrationTestCase):
             self.image_creator.create()
 
             # Create Flavor
             self.image_creator.create()
 
             # Create Flavor

+            flavor_config = openstack_tests.get_flavor_config(
+                name=self.guid + '-flavor-name', ram=256, disk=10,
+                vcpus=2, metadata=self.flavor_metadata)

             self.flavor_creator = OpenStackFlavor(
             self.flavor_creator = OpenStackFlavor(

-                self.admin_os_creds,
-                FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
-                             vcpus=2, metadata=self.flavor_metadata))
+                self.admin_os_creds, flavor_config)

             self.flavor_creator.create()
             self.flavor_creator.create()

-
-            # Create Network
-            self.network_creator = OpenStackNetwork(
-                self.os_creds, net_config.network_settings)
-            self.network_creator.create()
-
-            self.port_settings = PortSettings(
-                name=guid + '-port',
-                network_name=net_config.network_settings.name)
-
+            self.network_creator = None

         except Exception as e:
             self.tearDown()
             raise e
         except Exception as e:
             self.tearDown()
             raise e


@@ -492,7 +490,23 @@ class CreateInstanceSimpleTests(OSIntegrationTestCase):
         Tests the creation of an OpenStack instance with a single port with a
         static IP without a Floating IP.
         """
         Tests the creation of an OpenStack instance with a single port with a
         static IP without a Floating IP.
         """

-        instance_settings = VmInstanceSettings(
+        # Create Network
+        net_config = openstack_tests.get_priv_net_config(
+            project_name=self.os_creds.project_name,
+            net_name=self.guid + '-pub-net',
+            subnet_name=self.guid + '-pub-subnet',
+            router_name=self.guid + '-pub-router',
+            external_net=self.ext_net_name,
+            netconf_override=self.netconf_override)
+        self.network_creator = OpenStackNetwork(
+            self.os_creds, net_config.network_settings)
+        self.network_creator.create()
+
+        self.port_settings = PortConfig(
+            name=self.guid + '-port',
+            network_name=net_config.network_settings.name)
+
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -501,20 +515,174 @@ class CreateInstanceSimpleTests(OSIntegrationTestCase):
             self.os_creds, instance_settings,
             self.image_creator.image_settings)
 
             self.os_creds, instance_settings,
             self.image_creator.image_settings)
 

-        vm_inst = self.inst_creator.create()
-        self.assertIsNotNone(nova_utils.get_server(
-            self.nova, vm_inst_settings=instance_settings))
+        vm_inst = self.inst_creator.create(block=True)
+        vm_inst_get = nova_utils.get_server(
+            self.nova, self.neutron, self.keystone,
+            vm_inst_settings=instance_settings)
+        self.assertEqual(vm_inst, vm_inst_get)
+
+        self.assertIsNotNone(self.inst_creator.get_vm_inst().availability_zone)
+        self.assertIsNone(self.inst_creator.get_vm_inst().compute_host)

 
         # Delete instance
         nova_utils.delete_vm_instance(self.nova, vm_inst)
 
         self.assertTrue(self.inst_creator.vm_deleted(block=True))
         self.assertIsNone(nova_utils.get_server(
 
         # Delete instance
         nova_utils.delete_vm_instance(self.nova, vm_inst)
 
         self.assertTrue(self.inst_creator.vm_deleted(block=True))
         self.assertIsNone(nova_utils.get_server(

-            self.nova, vm_inst_settings=instance_settings))
+            self.nova, self.neutron, self.keystone,
+            vm_inst_settings=instance_settings))

 
         # Exception should not be thrown
         self.inst_creator.clean()
 
 
         # Exception should not be thrown
         self.inst_creator.clean()
 

+    def test_create_admin_instance(self):
+        """
+        Tests the creation of an OpenStack instance with a single port with a
+        static IP without a Floating IP.
+        """
+        # Create Network
+        net_config = openstack_tests.get_priv_net_config(
+            project_name=self.os_creds.project_name,
+            net_name=self.guid + '-pub-net',
+            subnet_name=self.guid + '-pub-subnet',
+            router_name=self.guid + '-pub-router',
+            external_net=self.ext_net_name,
+            netconf_override=self.netconf_override)
+        self.network_creator = OpenStackNetwork(
+            self.admin_os_creds, net_config.network_settings)
+        self.network_creator.create()
+
+        self.port_settings = PortConfig(
+            name=self.guid + '-port',
+            network_name=net_config.network_settings.name)
+
+        instance_settings = VmInstanceConfig(
+            name=self.vm_inst_name,
+            flavor=self.flavor_creator.flavor_settings.name,
+            port_settings=[self.port_settings])
+
+        self.inst_creator = OpenStackVmInstance(
+            self.admin_os_creds, instance_settings,
+            self.image_creator.image_settings)
+
+        admin_nova = nova_utils.nova_client(self.admin_os_creds)
+        admin_neutron = neutron_utils.neutron_client(self.admin_os_creds)
+        admin_key = keystone_utils.keystone_client(self.admin_os_creds)
+        vm_inst = self.inst_creator.create(block=True)
+
+        self.assertIsNotNone(vm_inst)
+        vm_inst_get = nova_utils.get_server(
+            admin_nova, admin_neutron, admin_key,
+            vm_inst_settings=instance_settings)
+        self.assertEqual(vm_inst, vm_inst_get)
+
+        self.assertIsNone(nova_utils.get_server(
+            self.nova, self.neutron, self.keystone,
+            vm_inst_settings=instance_settings))
+
+        self.assertIsNotNone(self.inst_creator.get_vm_inst().availability_zone)
+        self.assertIsNotNone(self.inst_creator.get_vm_inst().compute_host)
+
+
+class CreateInstanceExternalNetTests(OSIntegrationTestCase):
+    """
+    Simple instance creation tests where the network is external
+    """
+
+    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__()
+
+        guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
+        self.vm_inst_name = guid + '-inst'
+        self.nova = nova_utils.nova_client(self.admin_os_creds)
+        self.neutron = neutron_utils.neutron_client(self.admin_os_creds)
+        os_image_settings = openstack_tests.cirros_image_settings(
+            name=guid + '-image', image_metadata=self.image_metadata)
+
+        # Initialize for tearDown()
+        self.image_creator = None
+        self.flavor_creator = None
+        self.inst_creator = None
+
+        try:
+            # Create Image
+            self.image_creator = OpenStackImage(self.os_creds,
+                                                os_image_settings)
+            self.image_creator.create()
+
+            # Create Flavor
+            flavor_config = openstack_tests.get_flavor_config(
+                name=guid + '-flavor-name', ram=256, disk=10,
+                vcpus=2, metadata=self.flavor_metadata)
+            self.flavor_creator = OpenStackFlavor(
+                self.admin_os_creds, flavor_config)
+            self.flavor_creator.create()
+
+            self.port_settings = PortConfig(
+                name=guid + '-port',
+                network_name=self.ext_net_name)
+
+        except Exception as e:
+            self.tearDown()
+            raise e
+
+    def tearDown(self):
+        """
+        Cleans the created object
+        """
+        if self.inst_creator:
+            try:
+                self.inst_creator.clean()
+            except Exception as e:
+                logger.error(
+                    'Unexpected exception cleaning VM instance with message '
+                    '- %s', e)
+
+        if self.flavor_creator:
+            try:
+                self.flavor_creator.clean()
+            except Exception as e:
+                logger.error(
+                    'Unexpected exception cleaning flavor with message - %s',
+                    e)
+
+        if self.image_creator and not self.image_creator.image_settings.exists:
+            try:
+                self.image_creator.clean()
+            except Exception as e:
+                logger.error(
+                    'Unexpected exception cleaning image with message - %s', e)
+
+        super(self.__class__, self).__clean__()
+
+    def test_create_instance_public_net(self):
+        """
+        Tests the creation of an OpenStack instance with a single port to
+        the external network.
+        """
+        instance_settings = VmInstanceConfig(
+            name=self.vm_inst_name,
+            flavor=self.flavor_creator.flavor_settings.name,
+            port_settings=[self.port_settings])
+
+        self.inst_creator = OpenStackVmInstance(
+            self.admin_os_creds, instance_settings,
+            self.image_creator.image_settings)
+
+        vm_inst = self.inst_creator.create(block=True)
+        vm_inst_get = nova_utils.get_server(
+            self.nova, self.neutron, self.keystone,
+            vm_inst_settings=instance_settings)
+        self.assertEqual(vm_inst, vm_inst_get)
+        ip = self.inst_creator.get_port_ip(self.port_settings.name)
+
+        check_dhcp_lease(self.inst_creator, ip)
+

 
 class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
     """
 
 class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
     """


@@ -528,7 +696,7 @@ class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
         """
         super(self.__class__, self).__start__()
 
         """
         super(self.__class__, self).__start__()
 

-        self.nova = nova_utils.nova_client(self.os_creds)
+        self.nova = nova_utils.nova_client(self.os_creds, self.os_session)

         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.keypair_priv_filepath = 'tmp/' + guid
         self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.keypair_priv_filepath = 'tmp/' + guid
         self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'


@@ -548,8 +716,10 @@ class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
         self.inst_creators = list()
 
         self.pub_net_config = openstack_tests.get_pub_net_config(
         self.inst_creators = list()
 
         self.pub_net_config = openstack_tests.get_pub_net_config(

+            project_name=self.os_creds.project_name,

             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',

-            router_name=guid + '-pub-router', external_net=self.ext_net_name)
+            router_name=guid + '-pub-router', external_net=self.ext_net_name,
+            netconf_override=self.netconf_override)

         os_image_settings = openstack_tests.cirros_image_settings(
             name=guid + '-image', image_metadata=self.image_metadata)
         try:
         os_image_settings = openstack_tests.cirros_image_settings(
             name=guid + '-image', image_metadata=self.image_metadata)
         try:


@@ -569,10 +739,11 @@ class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
             self.router_creator.create()
 
             # Create Flavor
             self.router_creator.create()
 
             # Create Flavor

+            flavor_config = openstack_tests.get_flavor_config(
+                name=guid + '-flavor-name', ram=256, disk=10,
+                vcpus=2, metadata=self.flavor_metadata)

             self.flavor_creator = OpenStackFlavor(
             self.flavor_creator = OpenStackFlavor(

-                self.admin_os_creds,
-                FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
-                             vcpus=2, metadata=self.flavor_metadata))
+                self.admin_os_creds, flavor_config)

             self.flavor_creator.create()
 
             self.keypair_creator = OpenStackKeypair(
             self.flavor_creator.create()
 
             self.keypair_creator = OpenStackKeypair(


@@ -583,18 +754,16 @@ class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
             self.keypair_creator.create()
 
             sec_grp_name = guid + '-sec-grp'
             self.keypair_creator.create()
 
             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)
+            rule1 = SecurityGroupRuleConfig(
+                sec_grp_name=sec_grp_name, direction=Direction.ingress,
+                protocol=Protocol.icmp)
+            rule2 = SecurityGroupRuleConfig(
+                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,
             self.sec_grp_creator = OpenStackSecurityGroup(
                 self.os_creds,

-                SecurityGroupSettings(name=sec_grp_name,
-                                      rule_settings=[rule1, rule2]))
+                SecurityGroupConfig(
+                    name=sec_grp_name, rule_settings=[rule1, rule2]))

             self.sec_grp_creator.create()
         except Exception as e:
             self.tearDown()
             self.sec_grp_creator.create()
         except Exception as e:
             self.tearDown()


@@ -668,17 +837,17 @@ class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
         """
         ip_1 = '10.55.1.100'
         sub_settings = self.pub_net_config.network_settings.subnet_settings
         """
         ip_1 = '10.55.1.100'
         sub_settings = self.pub_net_config.network_settings.subnet_settings

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.pub_net_config.network_settings.name,
             ip_addrs=[
                 {'subnet_name': sub_settings[0].name, 'ip': ip_1}])
 
             name=self.port_1_name,
             network_name=self.pub_net_config.network_settings.name,
             ip_addrs=[
                 {'subnet_name': sub_settings[0].name, 'ip': ip_1}])
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],

-            floating_ip_settings=[FloatingIpSettings(
+            floating_ip_settings=[FloatingIpConfig(

                 name=self.floating_ip_name, port_name=self.port_1_name,
                 router_name=self.pub_net_config.router_settings.name)])
 
                 name=self.floating_ip_name, port_name=self.port_1_name,
                 router_name=self.pub_net_config.router_settings.name)])
 


@@ -698,16 +867,16 @@ class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
         Tests the ability to access a VM via SSH and a floating IP when it has
         been assigned prior to being active.
         """
         Tests the ability to access a VM via SSH and a floating IP when it has
         been assigned prior to being active.
         """

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.pub_net_config.network_settings.name)
 
             name=self.port_1_name,
             network_name=self.pub_net_config.network_settings.name)
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],
             security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],
             security_group_names=[self.sec_grp_creator.sec_grp_settings.name],

-            floating_ip_settings=[FloatingIpSettings(
+            floating_ip_settings=[FloatingIpConfig(

                 name=self.floating_ip_name, port_name=self.port_1_name,
                 router_name=self.pub_net_config.router_settings.name)])
 
                 name=self.floating_ip_name, port_name=self.port_1_name,
                 router_name=self.pub_net_config.router_settings.name)])
 


@@ -733,16 +902,53 @@ class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
         Tests the ability to access a VM via SSH and a floating IP when it has
         been assigned prior to being active.
         """
         Tests the ability to access a VM via SSH and a floating IP when it has
         been assigned prior to being active.
         """

-        port_settings = PortSettings(
+        port_settings = PortConfig(
+            name=self.port_1_name,
+            network_name=self.pub_net_config.network_settings.name)
+
+        instance_settings = VmInstanceConfig(
+            name=self.vm_inst_name,
+            flavor=self.flavor_creator.flavor_settings.name,
+            port_settings=[port_settings],
+            security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
+            floating_ip_settings=[FloatingIpConfig(
+                name=self.floating_ip_name, port_name=self.port_1_name,
+                router_name=self.pub_net_config.router_settings.name)])
+
+        inst_creator = OpenStackVmInstance(
+            self.os_creds, instance_settings,
+            self.image_creator.image_settings,
+            keypair_settings=self.keypair_creator.keypair_settings)
+        self.inst_creators.append(inst_creator)
+
+        # block=True will force the create() method to block until the
+        vm_inst = inst_creator.create(block=True)
+        self.assertIsNotNone(vm_inst)
+
+        self.assertTrue(inst_creator.vm_active(block=True))
+
+        ip = inst_creator.get_port_ip(port_settings.name)
+        self.assertTrue(check_dhcp_lease(inst_creator, ip))
+
+        self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
+
+        self.assertTrue(validate_ssh_client(inst_creator))
+
+    def test_ssh_client_fip_after_reboot(self):
+        """
+        Tests the ability to access a VM via SSH and a floating IP after it has
+        been rebooted.
+        """
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.pub_net_config.network_settings.name)
 
             name=self.port_1_name,
             network_name=self.pub_net_config.network_settings.name)
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],
             security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],
             security_group_names=[self.sec_grp_creator.sec_grp_settings.name],

-            floating_ip_settings=[FloatingIpSettings(
+            floating_ip_settings=[FloatingIpConfig(

                 name=self.floating_ip_name, port_name=self.port_1_name,
                 router_name=self.pub_net_config.router_settings.name)])
 
                 name=self.floating_ip_name, port_name=self.port_1_name,
                 router_name=self.pub_net_config.router_settings.name)])
 


@@ -765,21 +971,117 @@ class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
 
         self.assertTrue(validate_ssh_client(inst_creator))
 
 
         self.assertTrue(validate_ssh_client(inst_creator))
 

+        # Test default reboot which should be 'SOFT'
+        inst_creator.reboot()
+        # Lag time to allow for shutdown routine to take effect
+        time.sleep(15)
+        self.assertTrue(check_dhcp_lease(inst_creator, ip))
+        self.assertTrue(validate_ssh_client(inst_creator))
+
+        # Test 'SOFT' reboot
+        inst_creator.reboot(reboot_type=RebootType.soft)
+        time.sleep(15)
+        self.assertTrue(check_dhcp_lease(inst_creator, ip))
+        self.assertTrue(validate_ssh_client(inst_creator))
+
+        # Test 'HARD' reboot
+        inst_creator.reboot(reboot_type=RebootType.hard)
+        time.sleep(15)
+        self.assertTrue(check_dhcp_lease(inst_creator, ip))
+        self.assertTrue(validate_ssh_client(inst_creator))
+
+    def test_ssh_client_fip_after_init(self):
+        """
+        Tests the ability to assign a floating IP to an already initialized
+        OpenStackVmInstance object. After the floating IP has been allocated
+        and assigned, this test will ensure that it can be accessed via SSH.
+        """
+        port_settings = PortConfig(
+            name=self.port_1_name,
+            network_name=self.pub_net_config.network_settings.name)
+
+        instance_settings = VmInstanceConfig(
+            name=self.vm_inst_name,
+            flavor=self.flavor_creator.flavor_settings.name,
+            port_settings=[port_settings],
+            security_group_names=[self.sec_grp_creator.sec_grp_settings.name])
+
+        inst_creator = OpenStackVmInstance(
+            self.os_creds, instance_settings,
+            self.image_creator.image_settings,
+            keypair_settings=self.keypair_creator.keypair_settings)
+        self.inst_creators.append(inst_creator)
+
+        # block=True will force the create() method to block until the
+        vm_inst = inst_creator.create(block=True)
+        self.assertIsNotNone(vm_inst)
+
+        self.assertTrue(inst_creator.vm_active(block=True))
+        ip = inst_creator.get_port_ip(port_settings.name)
+        self.assertTrue(check_dhcp_lease(inst_creator, ip))
+        self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
+
+        inst_creator.add_floating_ip(FloatingIpConfig(
+            name=self.floating_ip_name, port_name=self.port_1_name,
+            router_name=self.pub_net_config.router_settings.name))
+
+        self.assertTrue(validate_ssh_client(inst_creator))
+
+    def test_ssh_client_fip_reverse_engineer(self):
+        """
+        Tests the ability to assign a floating IP to a reverse engineered
+        OpenStackVmInstance object. After the floating IP has been allocated
+        and assigned, this test will ensure that it can be accessed via SSH.
+        """
+        port_settings = PortConfig(
+            name=self.port_1_name,
+            network_name=self.pub_net_config.network_settings.name)
+
+        instance_settings = VmInstanceConfig(
+            name=self.vm_inst_name,
+            flavor=self.flavor_creator.flavor_settings.name,
+            port_settings=[port_settings],
+            security_group_names=[self.sec_grp_creator.sec_grp_settings.name])
+
+        inst_creator = OpenStackVmInstance(
+            self.os_creds, instance_settings,
+            self.image_creator.image_settings,
+            keypair_settings=self.keypair_creator.keypair_settings)
+        self.inst_creators.append(inst_creator)
+
+        # block=True will force the create() method to block until the
+        vm_inst = inst_creator.create(block=True)
+        self.assertIsNotNone(vm_inst)
+
+        self.assertTrue(inst_creator.vm_active(block=True))
+
+        derived_inst_creator = create_instance.generate_creator(
+            self.os_creds, vm_inst, self.image_creator.image_settings,
+            self.os_creds.project_name, self.keypair_creator.keypair_settings)
+
+        derived_inst_creator.add_floating_ip(FloatingIpConfig(
+            name=self.floating_ip_name, port_name=self.port_1_name,
+            router_name=self.pub_net_config.router_settings.name))
+        self.inst_creators.append(derived_inst_creator)
+
+        self.assertTrue(validate_ssh_client(
+            derived_inst_creator, fip_name=self.floating_ip_name))
+

     def test_ssh_client_fip_second_creator(self):
         """
         Tests the ability to access a VM via SSH and a floating IP via a
         creator that is identical to the original creator.
         """
     def test_ssh_client_fip_second_creator(self):
         """
         Tests the ability to access a VM via SSH and a floating IP via a
         creator that is identical to the original creator.
         """

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.pub_net_config.network_settings.name)
 
             name=self.port_1_name,
             network_name=self.pub_net_config.network_settings.name)
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],
             security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],
             security_group_names=[self.sec_grp_creator.sec_grp_settings.name],

-            floating_ip_settings=[FloatingIpSettings(
+            floating_ip_settings=[FloatingIpConfig(

                 name=self.floating_ip_name, port_name=self.port_1_name,
                 router_name=self.pub_net_config.router_settings.name)])
 
                 name=self.floating_ip_name, port_name=self.port_1_name,
                 router_name=self.pub_net_config.router_settings.name)])
 


@@ -822,7 +1124,7 @@ class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
         """
         super(self.__class__, self).__start__()
 
         """
         super(self.__class__, self).__start__()
 

-        self.nova = nova_utils.nova_client(self.os_creds)
+        self.nova = nova_utils.nova_client(self.os_creds, self.os_session)

         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.keypair_priv_filepath = 'tmp/' + self.guid
         self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.keypair_priv_filepath = 'tmp/' + self.guid
         self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'


@@ -847,11 +1149,11 @@ class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
                 self.os_creds, os_image_settings)
             self.image_creator.create()
 
                 self.os_creds, os_image_settings)
             self.image_creator.create()
 

+            flavor_config = openstack_tests.get_flavor_config(
+                name=self.guid + '-flavor-name', ram=256, disk=10,
+                vcpus=2, metadata=self.flavor_metadata)

             self.flavor_creator = OpenStackFlavor(
             self.flavor_creator = OpenStackFlavor(

-                self.admin_os_creds,
-                FlavorConfig(
-                    name=self.guid + '-flavor-name', ram=256, disk=10, vcpus=2,
-                    metadata=self.flavor_metadata))
+                self.admin_os_creds, flavor_config)

             self.flavor_creator.create()
 
             self.keypair_creator = OpenStackKeypair(
             self.flavor_creator.create()
 
             self.keypair_creator = OpenStackKeypair(


@@ -862,18 +1164,16 @@ class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
             self.keypair_creator.create()
 
             sec_grp_name = self.guid + '-sec-grp'
             self.keypair_creator.create()
 
             sec_grp_name = self.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)
+            rule1 = SecurityGroupRuleConfig(
+                sec_grp_name=sec_grp_name, direction=Direction.ingress,
+                protocol=Protocol.icmp)
+            rule2 = SecurityGroupRuleConfig(
+                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,
             self.sec_grp_creator = OpenStackSecurityGroup(
                 self.os_creds,

-                SecurityGroupSettings(name=sec_grp_name,
-                                      rule_settings=[rule1, rule2]))
+                SecurityGroupConfig(
+                    name=sec_grp_name, rule_settings=[rule1, rule2]))

             self.sec_grp_creator.create()
         except Exception as e:
             self.tearDown()
             self.sec_grp_creator.create()
         except Exception as e:
             self.tearDown()


@@ -945,14 +1245,17 @@ class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
         Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
         network when the external network does not have an IPv6 subnet.
         """
         Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
         network when the external network does not have an IPv6 subnet.
         """

-        subnet_settings = SubnetSettings(
+        subnet_settings = SubnetConfig(

             name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
             ip_version=6)
             name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
             ip_version=6)

-        network_settings = NetworkSettings(
+        network_settings = NetworkConfig(

             name=self.guid + '-net', subnet_settings=[subnet_settings])
         router_settings = RouterConfig(
             name=self.guid + '-router', external_gateway=self.ext_net_name,
             name=self.guid + '-net', subnet_settings=[subnet_settings])
         router_settings = RouterConfig(
             name=self.guid + '-router', external_gateway=self.ext_net_name,

-            internal_subnets=[subnet_settings.name])
+            internal_subnets=[{'subnet': {
+                'project_name': self.os_creds.project_name,
+                'network_name': network_settings.name,
+                'subnet_name': subnet_settings.name}}])

 
         # Create Network
         self.network_creator = OpenStackNetwork(
 
         # Create Network
         self.network_creator = OpenStackNetwork(


@@ -964,15 +1267,15 @@ class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
             self.os_creds, router_settings)
         self.router_creator.create()
 
             self.os_creds, router_settings)
         self.router_creator.create()
 

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port1_name, network_name=network_settings.name)
 
             name=self.port1_name, network_name=network_settings.name)
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],
             security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],
             security_group_names=[self.sec_grp_creator.sec_grp_settings.name],

-            floating_ip_settings=[FloatingIpSettings(
+            floating_ip_settings=[FloatingIpConfig(

                 name='fip1', port_name=self.port1_name,
                 router_name=router_settings.name)])
 
                 name='fip1', port_name=self.port1_name,
                 router_name=router_settings.name)])
 


@@ -989,18 +1292,21 @@ class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
         Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
         network when the external network does not have an IPv6 subnet.
         """
         Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
         network when the external network does not have an IPv6 subnet.
         """

-        subnet4_settings = SubnetSettings(
+        subnet4_settings = SubnetConfig(

             name=self.guid + '-subnet4', cidr='10.0.1.0/24',
             ip_version=4)
             name=self.guid + '-subnet4', cidr='10.0.1.0/24',
             ip_version=4)

-        subnet6_settings = SubnetSettings(
+        subnet6_settings = SubnetConfig(

             name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
             ip_version=6)
             name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
             ip_version=6)

-        network_settings = NetworkSettings(
+        network_settings = NetworkConfig(

             name=self.guid + '-net',
             subnet_settings=[subnet4_settings, subnet6_settings])
         router_settings = RouterConfig(
             name=self.guid + '-router', external_gateway=self.ext_net_name,
             name=self.guid + '-net',
             subnet_settings=[subnet4_settings, subnet6_settings])
         router_settings = RouterConfig(
             name=self.guid + '-router', external_gateway=self.ext_net_name,

-            internal_subnets=[subnet4_settings.name])
+            internal_subnets=[{'subnet': {
+                'project_name': self.os_creds.project_name,
+                'network_name': network_settings.name,
+                'subnet_name': subnet4_settings.name}}])

 
         # Create Network
         self.network_creator = OpenStackNetwork(
 
         # Create Network
         self.network_creator = OpenStackNetwork(


@@ -1012,15 +1318,15 @@ class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
             self.os_creds, router_settings)
         self.router_creator.create()
 
             self.os_creds, router_settings)
         self.router_creator.create()
 

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port1_name, network_name=network_settings.name)
 
             name=self.port1_name, network_name=network_settings.name)
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],
             security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings],
             security_group_names=[self.sec_grp_creator.sec_grp_settings.name],

-            floating_ip_settings=[FloatingIpSettings(
+            floating_ip_settings=[FloatingIpConfig(

                 name='fip1', port_name=self.port1_name,
                 router_name=router_settings.name)])
 
                 name='fip1', port_name=self.port1_name,
                 router_name=router_settings.name)])
 


@@ -1047,23 +1353,28 @@ class CreateInstancePortManipulationTests(OSIntegrationTestCase):
         """
         super(self.__class__, self).__start__()
 
         """
         super(self.__class__, self).__start__()
 

-        guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
-        self.vm_inst_name = guid + '-inst'
-        self.port_1_name = guid + 'port-1'
-        self.port_2_name = guid + 'port-2'
-        self.floating_ip_name = guid + 'fip1'
+        self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
+        self.vm_inst_name = self.guid + '-inst'
+        self.port_1_name = self.guid + 'port-1'
+        self.port_2_name = self.guid + 'port-2'
+        self.floating_ip_name = self.guid + 'fip1'

 
         # Initialize for tearDown()
         self.image_creator = None
         self.network_creator = None
 
         # Initialize for tearDown()
         self.image_creator = None
         self.network_creator = None

+        self.network_creator2 = None

         self.flavor_creator = None
         self.inst_creator = None
 
         self.net_config = openstack_tests.get_priv_net_config(
         self.flavor_creator = None
         self.inst_creator = None
 
         self.net_config = openstack_tests.get_priv_net_config(

-            net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
-            router_name=guid + '-pub-router', external_net=self.ext_net_name)
+            project_name=self.os_creds.project_name,
+            net_name=self.guid + '-pub-net',
+            subnet_name=self.guid + '-pub-subnet',
+            router_name=self.guid + '-pub-router',
+            external_net=self.ext_net_name,
+            netconf_override=self.netconf_override)

         os_image_settings = openstack_tests.cirros_image_settings(
         os_image_settings = openstack_tests.cirros_image_settings(

-            name=guid + '-image', image_metadata=self.image_metadata)
+            name=self.guid + '-image', image_metadata=self.image_metadata)

 
         try:
             # Create Image
 
         try:
             # Create Image


@@ -1077,10 +1388,11 @@ class CreateInstancePortManipulationTests(OSIntegrationTestCase):
             self.network_creator.create()
 
             # Create Flavor
             self.network_creator.create()
 
             # Create Flavor

+            flavor_config = openstack_tests.get_flavor_config(
+                name=self.guid + '-flavor-name', ram=256, disk=10,
+                vcpus=2, metadata=self.flavor_metadata)

             self.flavor_creator = OpenStackFlavor(
             self.flavor_creator = OpenStackFlavor(

-                self.admin_os_creds,
-                FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
-                             vcpus=2, metadata=self.flavor_metadata))
+                self.admin_os_creds, flavor_config)

             self.flavor_creator.create()
         except Exception as e:
             self.tearDown()
             self.flavor_creator.create()
         except Exception as e:
             self.tearDown()


@@ -1130,12 +1442,12 @@ class CreateInstancePortManipulationTests(OSIntegrationTestCase):
         """
         ip = '10.55.0.101'
         sub_settings = self.net_config.network_settings.subnet_settings
         """
         ip = '10.55.0.101'
         sub_settings = self.net_config.network_settings.subnet_settings

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
 
             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])


@@ -1150,6 +1462,86 @@ class CreateInstancePortManipulationTests(OSIntegrationTestCase):
             subnet_name=self.net_config.network_settings.subnet_settings[
                 0].name))
 
             subnet_name=self.net_config.network_settings.subnet_settings[
                 0].name))
 

+    def test_set_one_port_two_ip_one_subnet(self):
+        """
+        Tests the creation of an OpenStack instance with a single port with a
+        two static IPs on a network with one subnet.
+        """
+        ip1 = '10.55.0.101'
+        ip2 = '10.55.0.102'
+        sub_settings = self.net_config.network_settings.subnet_settings
+        port_settings = PortConfig(
+            name=self.port_1_name,
+            network_name=self.net_config.network_settings.name,
+            ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip1},
+                      {'subnet_name': sub_settings[0].name, 'ip': ip2}])
+
+        instance_settings = VmInstanceConfig(
+            name=self.vm_inst_name,
+            flavor=self.flavor_creator.flavor_settings.name,
+            port_settings=[port_settings])
+
+        self.inst_creator = OpenStackVmInstance(
+            self.os_creds, instance_settings,
+            self.image_creator.image_settings)
+        vm_inst = self.inst_creator.create(block=True)
+
+        self.assertEqual(ip1, vm_inst.ports[0].ips[0]['ip_address'])
+        self.assertEqual(self.network_creator.get_network().subnets[0].id,
+                         vm_inst.ports[0].ips[0]['subnet_id'])
+        self.assertEqual(ip2, vm_inst.ports[0].ips[1]['ip_address'])
+        self.assertEqual(self.network_creator.get_network().subnets[0].id,
+                         vm_inst.ports[0].ips[1]['subnet_id'])
+
+    def test_set_one_port_two_ip_two_subnets(self):
+        """
+        Tests the creation of an OpenStack instance with a single port with a
+        two static IPs on a network with one subnet.
+        """
+        net2_config = NetworkConfig(
+            name=self.guid + 'net2', subnets=[
+                SubnetConfig(name=self.guid + '-subnet1', cidr='10.55.0.0/24'),
+                SubnetConfig(name=self.guid + '-subnet2', cidr='10.65.0.0/24'),
+            ])
+
+        # Create Network
+        self.network_creator2 = OpenStackNetwork(self.os_creds, net2_config)
+        net2 = self.network_creator2.create()
+
+        ip1 = '10.55.0.101'
+        ip2 = '10.65.0.101'
+
+        port_settings = PortConfig(
+            name=self.port_1_name,
+            network_name=net2_config.name,
+            ip_addrs=[
+                {'subnet_name': net2_config.subnet_settings[0].name,
+                 'ip': ip1},
+                {'subnet_name': net2_config.subnet_settings[1].name,
+                 'ip': ip2}])
+
+        instance_settings = VmInstanceConfig(
+            name=self.vm_inst_name,
+            flavor=self.flavor_creator.flavor_settings.name,
+            port_settings=[port_settings])
+
+        self.inst_creator = OpenStackVmInstance(
+            self.os_creds, instance_settings,
+            self.image_creator.image_settings)
+        vm_inst = self.inst_creator.create(block=True)
+
+        subnet1_id = None
+        subnet2_id = None
+        for subnet in net2.subnets:
+            if subnet.name == net2_config.subnet_settings[0].name:
+                subnet1_id = subnet.id
+            if subnet.name == net2_config.subnet_settings[1].name:
+                subnet2_id = subnet.id
+        self.assertEqual(ip1, vm_inst.ports[0].ips[0]['ip_address'])
+        self.assertEqual(subnet1_id, vm_inst.ports[0].ips[0]['subnet_id'])
+        self.assertEqual(ip2, vm_inst.ports[0].ips[1]['ip_address'])
+        self.assertEqual(subnet2_id, vm_inst.ports[0].ips[1]['subnet_id'])
+

     def test_set_custom_invalid_ip_one_subnet(self):
         """
         Tests the creation of an OpenStack instance with a single port with a
     def test_set_custom_invalid_ip_one_subnet(self):
         """
         Tests the creation of an OpenStack instance with a single port with a


@@ -1157,12 +1549,12 @@ class CreateInstancePortManipulationTests(OSIntegrationTestCase):
         """
         ip = '10.66.0.101'
         sub_settings = self.net_config.network_settings.subnet_settings
         """
         ip = '10.66.0.101'
         sub_settings = self.net_config.network_settings.subnet_settings

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
 
             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])


@@ -1180,12 +1572,12 @@ class CreateInstancePortManipulationTests(OSIntegrationTestCase):
         the MAC address is assigned.
         """
         mac_addr = '0a:1b:2c:3d:4e:5f'
         the MAC address is assigned.
         """
         mac_addr = '0a:1b:2c:3d:4e:5f'

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             mac_address=mac_addr)
 
             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             mac_address=mac_addr)
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])


@@ -1204,12 +1596,12 @@ class CreateInstancePortManipulationTests(OSIntegrationTestCase):
         invalid MAC address value is being
         assigned. This should raise an Exception
         """
         invalid MAC address value is being
         assigned. This should raise an Exception
         """

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             mac_address='foo')
 
             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             mac_address='foo')
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])


@@ -1229,13 +1621,13 @@ class CreateInstancePortManipulationTests(OSIntegrationTestCase):
         ip = '10.55.0.101'
         mac_addr = '0a:1b:2c:3d:4e:5f'
         sub_settings = self.net_config.network_settings.subnet_settings
         ip = '10.55.0.101'
         mac_addr = '0a:1b:2c:3d:4e:5f'
         sub_settings = self.net_config.network_settings.subnet_settings

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             mac_address=mac_addr,
             ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
 
             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             mac_address=mac_addr,
             ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])


@@ -1260,12 +1652,12 @@ class CreateInstancePortManipulationTests(OSIntegrationTestCase):
         ip = '10.55.0.101'
         mac_addr = '0a:1b:2c:3d:4e:5f'
         pair = {'ip_address': ip, 'mac_address': mac_addr}
         ip = '10.55.0.101'
         mac_addr = '0a:1b:2c:3d:4e:5f'
         pair = {'ip_address': ip, 'mac_address': mac_addr}

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             allowed_address_pairs=[pair])
 
             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             allowed_address_pairs=[pair])
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])


@@ -1292,12 +1684,12 @@ class CreateInstancePortManipulationTests(OSIntegrationTestCase):
         pair = {'ip_address': ip, 'mac_address': mac_addr}
         pairs = set()
         pairs.add((ip, mac_addr))
         pair = {'ip_address': ip, 'mac_address': mac_addr}
         pairs = set()
         pairs.add((ip, mac_addr))

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             allowed_address_pairs=[pair])
 
             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             allowed_address_pairs=[pair])
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])


@@ -1318,12 +1710,12 @@ class CreateInstancePortManipulationTests(OSIntegrationTestCase):
         pair = {'ip_address': ip, 'mac_address': mac_addr}
         pairs = set()
         pairs.add((ip, mac_addr))
         pair = {'ip_address': ip, 'mac_address': mac_addr}
         pairs = set()
         pairs.add((ip, mac_addr))

-        port_settings = PortSettings(
+        port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             allowed_address_pairs=[pair])
 
             name=self.port_1_name,
             network_name=self.net_config.network_settings.name,
             allowed_address_pairs=[pair])
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[port_settings])


@@ -1358,7 +1750,9 @@ class CreateInstanceOnComputeHost(OSIntegrationTestCase):
         self.inst_creators = list()
 
         self.priv_net_config = openstack_tests.get_priv_net_config(
         self.inst_creators = list()
 
         self.priv_net_config = openstack_tests.get_priv_net_config(

-            net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
+            project_name=self.os_creds.project_name,
+            net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet',
+            netconf_override=self.netconf_override)

 
         os_image_settings = openstack_tests.cirros_image_settings(
             name=guid + '-image', image_metadata=self.image_metadata)
 
         os_image_settings = openstack_tests.cirros_image_settings(
             name=guid + '-image', image_metadata=self.image_metadata)


@@ -1370,10 +1764,11 @@ class CreateInstanceOnComputeHost(OSIntegrationTestCase):
             self.network_creator.create()
 
             # Create Flavor
             self.network_creator.create()
 
             # Create Flavor

+            flavor_config = openstack_tests.get_flavor_config(
+                name=guid + '-flavor-name', ram=512, disk=1,
+                vcpus=1, metadata=self.flavor_metadata)

             self.flavor_creator = OpenStackFlavor(
             self.flavor_creator = OpenStackFlavor(

-                self.admin_os_creds,
-                FlavorConfig(name=guid + '-flavor-name', ram=512, disk=1,
-                             vcpus=1, metadata=self.flavor_metadata))
+                self.admin_os_creds, flavor_config)

             self.flavor_creator.create()
 
             # Create Image
             self.flavor_creator.create()
 
             # Create Image


@@ -1427,7 +1822,8 @@ class CreateInstanceOnComputeHost(OSIntegrationTestCase):
         Tests the creation of OpenStack VM instances to each compute node.
         """
         from snaps.openstack.utils import nova_utils
         Tests the creation of OpenStack VM instances to each compute node.
         """
         from snaps.openstack.utils import nova_utils

-        nova = nova_utils.nova_client(self.admin_os_creds)
+        nova = nova_utils.nova_client(
+            self.admin_os_creds, self.admin_os_session)

         zone_hosts = nova_utils.get_availability_zone_hosts(nova)
 
         # Create Instance on each server/zone
         zone_hosts = nova_utils.get_availability_zone_hosts(nova)
 
         # Create Instance on each server/zone


@@ -1435,11 +1831,11 @@ class CreateInstanceOnComputeHost(OSIntegrationTestCase):
         for zone in zone_hosts:
             inst_name = self.vm_inst_name + '-' + zone
             ctr += 1
         for zone in zone_hosts:
             inst_name = self.vm_inst_name + '-' + zone
             ctr += 1

-            port_settings = PortSettings(
+            port_settings = PortConfig(

                 name=self.port_base_name + '-' + str(ctr),
                 network_name=self.priv_net_config.network_settings.name)
 
                 name=self.port_base_name + '-' + str(ctr),
                 network_name=self.priv_net_config.network_settings.name)
 

-            instance_settings = VmInstanceSettings(
+            instance_settings = VmInstanceConfig(

                 name=inst_name,
                 flavor=self.flavor_creator.flavor_settings.name,
                 availability_zone=zone,
                 name=inst_name,
                 flavor=self.flavor_creator.flavor_settings.name,
                 availability_zone=zone,


@@ -1448,7 +1844,11 @@ class CreateInstanceOnComputeHost(OSIntegrationTestCase):
                 self.admin_os_creds, instance_settings,
                 self.image_creator.image_settings)
             self.inst_creators.append(inst_creator)
                 self.admin_os_creds, instance_settings,
                 self.image_creator.image_settings)
             self.inst_creators.append(inst_creator)

-            inst_creator.create()
+            inst_creator.create(block=True)
+            avail_zone = inst_creator.get_vm_inst().availability_zone
+            self.assertTrue(avail_zone in zone)
+            compute_host = inst_creator.get_vm_inst().compute_host
+            self.assertTrue(compute_host in zone)

 
         # Validate instances to ensure they've been deployed to the correct
         # server
 
         # Validate instances to ensure they've been deployed to the correct
         # server


@@ -1463,226 +1863,6 @@ class CreateInstanceOnComputeHost(OSIntegrationTestCase):
             index += 1
 
 
             index += 1
 
 

-class CreateInstancePubPrivNetTests(OSIntegrationTestCase):
-    """
-    Test for the CreateInstance class with two NIC/Ports, eth0 with floating IP
-    and eth1 w/o.
-    These tests require a Centos image
-    """
-
-    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)
-
-        # Initialize for tearDown()
-        self.image_creator = None
-        self.network_creators = list()
-        self.router_creators = list()
-        self.flavor_creator = None
-        self.keypair_creator = None
-        self.sec_grp_creator = None
-        self.inst_creator = None
-
-        self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
-        self.keypair_priv_filepath = 'tmp/' + self.guid
-        self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
-        self.keypair_name = self.guid + '-kp'
-        self.vm_inst_name = self.guid + '-inst'
-        self.port_1_name = self.guid + '-port-1'
-        self.port_2_name = self.guid + '-port-2'
-        self.floating_ip_name = self.guid + 'fip1'
-        self.priv_net_config = openstack_tests.get_priv_net_config(
-            net_name=self.guid + '-priv-net',
-            subnet_name=self.guid + '-priv-subnet',
-            router_name=self.guid + '-priv-router',
-            external_net=self.ext_net_name)
-        self.pub_net_config = openstack_tests.get_pub_net_config(
-            net_name=self.guid + '-pub-net',
-            subnet_name=self.guid + '-pub-subnet',
-            router_name=self.guid + '-pub-router',
-            external_net=self.ext_net_name)
-
-        image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
-        os_image_settings = openstack_tests.centos_image_settings(
-            name=image_name, image_metadata=self.image_metadata)
-
-        try:
-            # Create Image
-            self.image_creator = OpenStackImage(self.os_creds,
-                                                os_image_settings)
-            self.image_creator.create()
-
-            # First network is public
-            self.network_creators.append(OpenStackNetwork(
-                self.os_creds, self.pub_net_config.network_settings))
-            # Second network is private
-            self.network_creators.append(OpenStackNetwork(
-                self.os_creds, self.priv_net_config.network_settings))
-            for network_creator in self.network_creators:
-                network_creator.create()
-
-            self.router_creators.append(OpenStackRouter(
-                self.os_creds, self.pub_net_config.router_settings))
-            self.router_creators.append(OpenStackRouter(
-                self.os_creds, self.priv_net_config.router_settings))
-
-            # Create Routers
-            for router_creator in self.router_creators:
-                router_creator.create()
-
-            # Create Flavor
-            self.flavor_creator = OpenStackFlavor(
-                self.admin_os_creds,
-                FlavorConfig(name=self.guid + '-flavor-name', ram=512,
-                             disk=10, vcpus=2,
-                             metadata=self.flavor_metadata))
-            self.flavor_creator.create()
-
-            # Create Keypair
-            self.keypair_creator = OpenStackKeypair(
-                self.os_creds, KeypairConfig(
-                    name=self.keypair_name,
-                    public_filepath=self.keypair_pub_filepath,
-                    private_filepath=self.keypair_priv_filepath))
-            self.keypair_creator.create()
-
-            sec_grp_name = self.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()
-        except:
-            self.tearDown()
-            raise
-
-    def tearDown(self):
-        """
-        Cleans the created objects
-        """
-        if self.inst_creator:
-            try:
-                self.inst_creator.clean()
-            except Exception as e:
-                logger.error(
-                    'Unexpected exception cleaning VM instance with message '
-                    '- %s', e)
-
-        if self.keypair_creator:
-            try:
-                self.keypair_creator.clean()
-            except Exception as e:
-                logger.error(
-                    'Unexpected exception cleaning keypair with message - %s',
-                    e)
-
-        if self.flavor_creator:
-            try:
-                self.flavor_creator.clean()
-            except Exception as e:
-                logger.error(
-                    'Unexpected exception cleaning flavor with message - %s',
-                    e)
-
-        for router_creator in self.router_creators:
-            try:
-                router_creator.clean()
-            except Exception as e:
-                logger.error(
-                    'Unexpected exception cleaning router with message - %s',
-                    e)
-
-        for network_creator in self.network_creators:
-            try:
-                network_creator.clean()
-            except Exception as e:
-                logger.error(
-                    'Unexpected exception cleaning network with message - %s',
-                    e)
-
-        if self.sec_grp_creator:
-            try:
-                self.sec_grp_creator.clean()
-            except Exception as e:
-                logger.error(
-                    'Unexpected exception cleaning security group with message'
-                    ' - %s', e)
-
-        if self.image_creator and not self.image_creator.image_settings.exists:
-            try:
-                self.image_creator.clean()
-            except Exception as e:
-                logger.error(
-                    'Unexpected exception cleaning image with message - %s', e)
-
-        super(self.__class__, self).__clean__()
-
-    def test_dual_ports_dhcp(self):
-        """
-        Tests the creation of an OpenStack instance with a dual ports/NICs with
-        a DHCP assigned IP.
-        NOTE: This test and any others that call ansible will most likely fail
-        unless you do one of two things:
-        1. Have a ~/.ansible.cfg (or alternate means) to
-           set host_key_checking = False
-        2. Set the following environment variable in your executing shell:
-           ANSIBLE_HOST_KEY_CHECKING=False
-        Should this not be performed, the creation of the host ssh key will
-        cause your ansible calls to fail.
-        """
-        # Create ports/NICs for instance
-        ports_settings = []
-        ctr = 1
-        for network_creator in self.network_creators:
-            ports_settings.append(PortSettings(
-                name=self.guid + '-port-' + str(ctr),
-                network_name=network_creator.network_settings.name))
-            ctr += 1
-
-        # Create instance
-        instance_settings = VmInstanceSettings(
-            name=self.vm_inst_name,
-            flavor=self.flavor_creator.flavor_settings.name,
-            port_settings=ports_settings,
-            security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
-            floating_ip_settings=[FloatingIpSettings(
-                name=self.floating_ip_name, port_name=self.port_1_name,
-                router_name=self.pub_net_config.router_settings.name)])
-
-        self.inst_creator = OpenStackVmInstance(
-            self.os_creds, instance_settings,
-            self.image_creator.image_settings,
-            keypair_settings=self.keypair_creator.keypair_settings)
-
-        vm_inst = self.inst_creator.create(block=True)
-
-        self.assertEqual(vm_inst.id, self.inst_creator.get_vm_inst().id)
-
-        # Effectively blocks until VM has been properly activated
-        self.assertTrue(self.inst_creator.vm_active(block=True))
-
-        ip = self.inst_creator.get_port_ip(ports_settings[0].name)
-        self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
-
-        # Effectively blocks until VM's ssh port has been opened
-        self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
-
-        self.assertEqual(0, self.inst_creator.config_nics())
-
-

 class InstanceSecurityGroupTests(OSIntegrationTestCase):
     """
     Tests that include, add, and remove security groups from VM instances
 class InstanceSecurityGroupTests(OSIntegrationTestCase):
     """
     Tests that include, add, and remove security groups from VM instances


@@ -1697,7 +1877,7 @@ class InstanceSecurityGroupTests(OSIntegrationTestCase):
 
         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.vm_inst_name = self.guid + '-inst'
 
         self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.vm_inst_name = self.guid + '-inst'

-        self.nova = nova_utils.nova_client(self.os_creds)
+        self.nova = nova_utils.nova_client(self.os_creds, self.os_session)

         os_image_settings = openstack_tests.cirros_image_settings(
             name=self.guid + '-image', image_metadata=self.image_metadata)
 
         os_image_settings = openstack_tests.cirros_image_settings(
             name=self.guid + '-image', image_metadata=self.image_metadata)
 


@@ -1707,10 +1887,12 @@ class InstanceSecurityGroupTests(OSIntegrationTestCase):
         self.floating_ip_name = self.guid + 'fip1'
 
         net_config = openstack_tests.get_priv_net_config(
         self.floating_ip_name = self.guid + 'fip1'
 
         net_config = openstack_tests.get_priv_net_config(

+            project_name=self.os_creds.project_name,

             net_name=self.guid + '-pub-net',
             subnet_name=self.guid + '-pub-subnet',
             router_name=self.guid + '-pub-router',
             net_name=self.guid + '-pub-net',
             subnet_name=self.guid + '-pub-subnet',
             router_name=self.guid + '-pub-router',

-            external_net=self.ext_net_name)
+            external_net=self.ext_net_name,
+            netconf_override=self.netconf_override)

 
         # Initialize for tearDown()
         self.image_creator = None
 
         # Initialize for tearDown()
         self.image_creator = None


@@ -1732,14 +1914,14 @@ class InstanceSecurityGroupTests(OSIntegrationTestCase):
             self.network_creator.create()
 
             # Create Flavor
             self.network_creator.create()
 
             # Create Flavor

+            flavor_config = openstack_tests.get_flavor_config(
+                name=self.guid + '-flavor-name', ram=256, disk=10,
+                vcpus=2, metadata=self.flavor_metadata)

             self.flavor_creator = OpenStackFlavor(
             self.flavor_creator = OpenStackFlavor(

-                self.admin_os_creds,
-                FlavorConfig(name=self.guid + '-flavor-name', ram=256,
-                             disk=10, vcpus=2,
-                             metadata=self.flavor_metadata))
+                self.admin_os_creds, flavor_config)

             self.flavor_creator.create()
 
             self.flavor_creator.create()
 

-            self.port_settings = PortSettings(
+            self.port_settings = PortConfig(

                 name=self.guid + '-port',
                 network_name=net_config.network_settings.name)
         except Exception as e:
                 name=self.guid + '-port',
                 network_name=net_config.network_settings.name)
         except Exception as e:


@@ -1796,7 +1978,7 @@ class InstanceSecurityGroupTests(OSIntegrationTestCase):
         Tests the addition of a security group created after the instance.
         """
         # Create instance
         Tests the addition of a security group created after the instance.
         """
         # Create instance

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -1807,8 +1989,8 @@ class InstanceSecurityGroupTests(OSIntegrationTestCase):
         self.assertIsNotNone(vm_inst)
 
         # Create security group object to add to instance
         self.assertIsNotNone(vm_inst)
 
         # Create security group object to add to instance

-        sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
-                                                 description='hello group')
+        sec_grp_settings = SecurityGroupConfig(
+            name=self.guid + '-name', description='hello group')

         sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
                                                  sec_grp_settings)
         sec_grp = sec_grp_creator.create()
         sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
                                                  sec_grp_settings)
         sec_grp = sec_grp_creator.create()


@@ -1830,7 +2012,7 @@ class InstanceSecurityGroupTests(OSIntegrationTestCase):
         Tests the addition of a security group that no longer exists.
         """
         # Create instance
         Tests the addition of a security group that no longer exists.
         """
         # Create instance

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -1841,8 +2023,8 @@ class InstanceSecurityGroupTests(OSIntegrationTestCase):
         self.assertIsNotNone(vm_inst)
 
         # Create security group object to add to instance
         self.assertIsNotNone(vm_inst)
 
         # Create security group object to add to instance

-        sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
-                                                 description='hello group')
+        sec_grp_settings = SecurityGroupConfig(
+            name=self.guid + '-name', description='hello group')

         sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
                                                  sec_grp_settings)
         sec_grp = sec_grp_creator.create()
         sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
                                                  sec_grp_settings)
         sec_grp = sec_grp_creator.create()


@@ -1866,15 +2048,15 @@ class InstanceSecurityGroupTests(OSIntegrationTestCase):
         instance.
         """
         # Create security group object to add to instance
         instance.
         """
         # Create security group object to add to instance

-        sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
-                                                 description='hello group')
+        sec_grp_settings = SecurityGroupConfig(
+            name=self.guid + '-name', description='hello group')

         sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
                                                  sec_grp_settings)
         sec_grp = sec_grp_creator.create()
         self.sec_grp_creators.append(sec_grp_creator)
 
         # Create instance
         sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
                                                  sec_grp_settings)
         sec_grp = sec_grp_creator.create()
         self.sec_grp_creators.append(sec_grp_creator)
 
         # Create instance

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             security_group_names=[sec_grp_settings.name],
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             security_group_names=[sec_grp_settings.name],


@@ -1902,15 +2084,15 @@ class InstanceSecurityGroupTests(OSIntegrationTestCase):
         place.
         """
         # Create security group object to add to instance
         place.
         """
         # Create security group object to add to instance

-        sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
-                                                 description='hello group')
+        sec_grp_settings = SecurityGroupConfig(
+            name=self.guid + '-name', description='hello group')

         sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
                                                  sec_grp_settings)
         sec_grp = sec_grp_creator.create()
         self.sec_grp_creators.append(sec_grp_creator)
 
         # Create instance
         sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
                                                  sec_grp_settings)
         sec_grp = sec_grp_creator.create()
         self.sec_grp_creators.append(sec_grp_creator)
 
         # Create instance

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -1937,15 +2119,15 @@ class InstanceSecurityGroupTests(OSIntegrationTestCase):
         instance.
         """
         # Create security group object to add to instance
         instance.
         """
         # Create security group object to add to instance

-        sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
-                                                 description='hello group')
+        sec_grp_settings = SecurityGroupConfig(
+            name=self.guid + '-name', description='hello group')

         sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
                                                  sec_grp_settings)
         sec_grp = sec_grp_creator.create()
         self.sec_grp_creators.append(sec_grp_creator)
 
         # Create instance
         sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
                                                  sec_grp_settings)
         sec_grp = sec_grp_creator.create()
         self.sec_grp_creators.append(sec_grp_creator)
 
         # Create instance

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             security_group_names=[sec_grp_settings.name],
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             security_group_names=[sec_grp_settings.name],


@@ -1983,17 +2165,18 @@ def inst_has_sec_grp(nova, vm_inst, sec_grp_name):
     return False
 
 
     return False
 
 

-def validate_ssh_client(instance_creator):
+def validate_ssh_client(instance_creator, fip_name=None):

     """
     Returns True if instance_creator returns an SSH client that is valid
     :param instance_creator: the object responsible for creating the VM
                              instance
     """
     Returns True if instance_creator returns an SSH client that is valid
     :param instance_creator: the object responsible for creating the VM
                              instance

+    :param fip_name: the name of the floating IP to use

     :return: T/F
     """
     ssh_active = instance_creator.vm_ssh_active(block=True)
 
     if ssh_active:
     :return: T/F
     """
     ssh_active = instance_creator.vm_ssh_active(block=True)
 
     if ssh_active:

-        ssh_client = instance_creator.ssh_client()
+        ssh_client = instance_creator.ssh_client(fip_name=fip_name)

         if ssh_client:
             try:
                 out = ssh_client.exec_command('pwd')[1]
         if ssh_client:
             try:
                 out = ssh_client.exec_command('pwd')[1]


@@ -2026,11 +2209,13 @@ class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.image_name = guid
         self.vm_inst_name = guid + '-inst'
         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.image_name = guid
         self.vm_inst_name = guid + '-inst'

-        self.nova = nova_utils.nova_client(self.os_creds)
+        self.nova = nova_utils.nova_client(self.os_creds, self.os_session)

 
         net_config = openstack_tests.get_priv_net_config(
 
         net_config = openstack_tests.get_priv_net_config(

+            project_name=self.os_creds.project_name,

             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',

-            router_name=guid + '-pub-router', external_net=self.ext_net_name)
+            router_name=guid + '-pub-router', external_net=self.ext_net_name,
+            netconf_override=self.netconf_override)

 
         # Initialize for tearDown()
         self.image_creator = None
 
         # Initialize for tearDown()
         self.image_creator = None


@@ -2066,10 +2251,11 @@ class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
             self.image_creator.create()
 
             # Create Flavor
             self.image_creator.create()
 
             # Create Flavor

+            flavor_config = openstack_tests.get_flavor_config(
+                name=guid + '-flavor-name', ram=256, disk=10,
+                vcpus=2, metadata=self.flavor_metadata)

             self.flavor_creator = OpenStackFlavor(
             self.flavor_creator = OpenStackFlavor(

-                self.admin_os_creds,
-                FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
-                             vcpus=2, metadata=self.flavor_metadata))
+                self.admin_os_creds, flavor_config)

             self.flavor_creator.create()
 
             # Create Network
             self.flavor_creator.create()
 
             # Create Network


@@ -2077,7 +2263,7 @@ class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
                 self.os_creds, net_config.network_settings)
             self.network_creator.create()
 
                 self.os_creds, net_config.network_settings)
             self.network_creator.create()
 

-            self.port_settings = PortSettings(
+            self.port_settings = PortConfig(

                 name=guid + '-port',
                 network_name=net_config.network_settings.name)
         except Exception as e:
                 name=guid + '-port',
                 network_name=net_config.network_settings.name)
         except Exception as e:


@@ -2125,7 +2311,7 @@ class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
         """
         Tests the creation of an OpenStack instance from a 3-part image.
         """
         """
         Tests the creation of an OpenStack instance from a 3-part image.
         """

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -2170,9 +2356,10 @@ class CreateInstanceMockOfflineTests(OSComponentTestCase):
         self.inst_creator = None
 
         self.priv_net_config = openstack_tests.get_priv_net_config(
         self.inst_creator = None
 
         self.priv_net_config = openstack_tests.get_priv_net_config(

+            project_name=self.os_creds.project_name,

             net_name=self.guid + '-priv-net',
             subnet_name=self.guid + '-priv-subnet')
             net_name=self.guid + '-priv-net',
             subnet_name=self.guid + '-priv-subnet')

-        self.port_settings = PortSettings(
+        self.port_settings = PortConfig(

             name=self.port_1_name,
             network_name=self.priv_net_config.network_settings.name)
 
             name=self.port_1_name,
             network_name=self.priv_net_config.network_settings.name)
 


@@ -2187,11 +2374,11 @@ class CreateInstanceMockOfflineTests(OSComponentTestCase):
             self.network_creator.create()
 
             # Create Flavor
             self.network_creator.create()
 
             # Create Flavor

+            flavor_config = openstack_tests.get_flavor_config(
+                name=self.guid + '-flavor-name', ram=256, disk=10,
+                vcpus=2, metadata=self.flavor_metadata)

             self.flavor_creator = OpenStackFlavor(
             self.flavor_creator = OpenStackFlavor(

-                self.os_creds,
-                FlavorConfig(
-                    name=self.guid + '-flavor-name', ram=256, disk=10,
-                    vcpus=1))
+                self.os_creds, flavor_config)

             self.flavor_creator.create()
         except Exception as e:
             self.tearDown()
             self.flavor_creator.create()
         except Exception as e:
             self.tearDown()


@@ -2235,6 +2422,8 @@ class CreateInstanceMockOfflineTests(OSComponentTestCase):
         if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
             shutil.rmtree(self.tmpDir)
 
         if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
             shutil.rmtree(self.tmpDir)
 

+        super(self.__class__, self).__clean__()
+

     def test_inst_from_file_image_simple_flat(self):
         """
         Creates a VM instance from a locally sourced file image using simply
     def test_inst_from_file_image_simple_flat(self):
         """
         Creates a VM instance from a locally sourced file image using simply


@@ -2260,7 +2449,7 @@ class CreateInstanceMockOfflineTests(OSComponentTestCase):
         self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
         self.image_creator.create()
 
         self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
         self.image_creator.create()
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -2296,7 +2485,7 @@ class CreateInstanceMockOfflineTests(OSComponentTestCase):
         self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
         self.image_creator.create()
 
         self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
         self.image_creator.create()
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -2328,7 +2517,7 @@ class CreateInstanceMockOfflineTests(OSComponentTestCase):
         self.assertEqual(self.image_creator.get_image().id,
                          test_image_creator.get_image().id)
 
         self.assertEqual(self.image_creator.get_image().id,
                          test_image_creator.get_image().id)
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -2363,7 +2552,7 @@ class CreateInstanceMockOfflineTests(OSComponentTestCase):
         test_image = OpenStackImage(self.os_creds, test_image_settings)
         test_image.create()
 
         test_image = OpenStackImage(self.os_creds, test_image_settings)
         test_image.create()
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -2443,7 +2632,7 @@ class CreateInstanceMockOfflineTests(OSComponentTestCase):
         self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
         self.image_creator.create()
 
         self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
         self.image_creator.create()
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -2513,7 +2702,7 @@ class CreateInstanceMockOfflineTests(OSComponentTestCase):
         self.assertIsNotNone(self.image_creator.get_kernel_image())
         self.assertIsNotNone(self.image_creator.get_ramdisk_image())
 
         self.assertIsNotNone(self.image_creator.get_kernel_image())
         self.assertIsNotNone(self.image_creator.get_ramdisk_image())
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -2583,7 +2772,7 @@ class CreateInstanceMockOfflineTests(OSComponentTestCase):
         self.assertIsNotNone(self.image_creator.get_kernel_image())
         self.assertIsNotNone(self.image_creator.get_ramdisk_image())
 
         self.assertIsNotNone(self.image_creator.get_kernel_image())
         self.assertIsNotNone(self.image_creator.get_ramdisk_image())
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -2623,7 +2812,7 @@ class CreateInstanceMockOfflineTests(OSComponentTestCase):
         self.assertEqual(self.image_creator.get_image().id,
                          test_image_creator.get_image().id)
 
         self.assertEqual(self.image_creator.get_image().id,
                          test_image_creator.get_image().id)
 

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings])


@@ -2655,7 +2844,7 @@ class CreateInstanceTwoNetTests(OSIntegrationTestCase):
         self.ip1 = '10.200.201.5'
         self.ip2 = '10.200.202.5'
 
         self.ip1 = '10.200.201.5'
         self.ip2 = '10.200.202.5'
 

-        self.nova = nova_utils.nova_client(self.os_creds)
+        self.nova = nova_utils.nova_client(self.os_creds, self.os_session)

 
         # Initialize for tearDown()
         self.image_creator = None
 
         # Initialize for tearDown()
         self.image_creator = None


@@ -2670,16 +2859,16 @@ class CreateInstanceTwoNetTests(OSIntegrationTestCase):
         self.vm_inst2_name = self.guid + '-inst2'
         self.port_1_name = self.guid + '-vm1-port'
         self.port_2_name = self.guid + '-vm2-port'
         self.vm_inst2_name = self.guid + '-inst2'
         self.port_1_name = self.guid + '-vm1-port'
         self.port_2_name = self.guid + '-vm2-port'

-        self.net_config_1 = NetworkSettings(
+        self.net_config_1 = NetworkConfig(

             name=self.guid + '-net1',
             subnet_settings=[
             name=self.guid + '-net1',
             subnet_settings=[

-                create_network.SubnetSettings(
+                create_network.SubnetConfig(

                     cidr=cidr1, name=self.guid + '-subnet1',
                     gateway_ip=static_gateway_ip1)])
                     cidr=cidr1, name=self.guid + '-subnet1',
                     gateway_ip=static_gateway_ip1)])

-        self.net_config_2 = NetworkSettings(
+        self.net_config_2 = NetworkConfig(

             name=self.guid + '-net2',
             subnet_settings=[
             name=self.guid + '-net2',
             subnet_settings=[

-                create_network.SubnetSettings(
+                create_network.SubnetConfig(

                     cidr=cidr2, name=self.guid + '-subnet2',
                     gateway_ip=static_gateway_ip2)])
 
                     cidr=cidr2, name=self.guid + '-subnet2',
                     gateway_ip=static_gateway_ip2)])
 


@@ -2689,13 +2878,14 @@ class CreateInstanceTwoNetTests(OSIntegrationTestCase):
 
         try:
             # Create Image
 
         try:
             # Create Image

-            self.image_creator = OpenStackImage(self.os_creds,
-                                                os_image_settings)
+            self.image_creator = OpenStackImage(
+                self.os_creds, os_image_settings)

             self.image_creator.create()
 
             # First network is public
             self.network_creators.append(OpenStackNetwork(
                 self.os_creds, self.net_config_1))
             self.image_creator.create()
 
             # First network is public
             self.network_creators.append(OpenStackNetwork(
                 self.os_creds, self.net_config_1))

+

             # Second network is private
             self.network_creators.append(OpenStackNetwork(
                 self.os_creds, self.net_config_2))
             # Second network is private
             self.network_creators.append(OpenStackNetwork(
                 self.os_creds, self.net_config_2))


@@ -2703,47 +2893,47 @@ class CreateInstanceTwoNetTests(OSIntegrationTestCase):
                 network_creator.create()
 
             port_settings = [
                 network_creator.create()
 
             port_settings = [

-                create_network.PortSettings(
+                PortConfig(

                     name=self.guid + '-router-port1',
                     ip_addrs=[{
                         'subnet_name':
                             self.net_config_1.subnet_settings[0].name,
                         'ip': static_gateway_ip1
                     }],
                     name=self.guid + '-router-port1',
                     ip_addrs=[{
                         'subnet_name':
                             self.net_config_1.subnet_settings[0].name,
                         'ip': static_gateway_ip1
                     }],

-                    network_name=self.net_config_1.name,
-                    project_name=self.os_creds.project_name),
-                create_network.PortSettings(
+                    network_name=self.net_config_1.name),
+                PortConfig(

                     name=self.guid + '-router-port2',
                     ip_addrs=[{
                         'subnet_name':
                             self.net_config_2.subnet_settings[0].name,
                         'ip': static_gateway_ip2
                     }],
                     name=self.guid + '-router-port2',
                     ip_addrs=[{
                         'subnet_name':
                             self.net_config_2.subnet_settings[0].name,
                         'ip': static_gateway_ip2
                     }],

-                    network_name=self.net_config_2.name,
-                    project_name=self.os_creds.project_name)]
+                    network_name=self.net_config_2.name)]

 
             router_settings = RouterConfig(
                 name=self.guid + '-pub-router', port_settings=port_settings)
 
             router_settings = RouterConfig(
                 name=self.guid + '-pub-router', port_settings=port_settings)

-            self.router_creator = create_router.OpenStackRouter(
+            self.router_creator = OpenStackRouter(

                 self.os_creds, router_settings)
             self.router_creator.create()
 
                 self.os_creds, router_settings)
             self.router_creator.create()
 

-            # Create Flavor
+            flavor_config = openstack_tests.get_flavor_config(
+                name=self.guid + '-flavor-name', ram=512, disk=10,
+                vcpus=2, metadata=self.flavor_metadata)

             self.flavor_creator = OpenStackFlavor(
             self.flavor_creator = OpenStackFlavor(

-                self.admin_os_creds,
-                FlavorConfig(name=self.guid + '-flavor-name', ram=512,
-                             disk=10, vcpus=2,
-                             metadata=self.flavor_metadata))
+                self.admin_os_creds, flavor_config)

             self.flavor_creator.create()
 
             self.flavor_creator.create()
 

-            sec_grp_name = self.guid + '-sec-grp'
-            rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
-                                              direction=Direction.ingress,
-                                              protocol=Protocol.icmp)
+            self.sec_grp_name = self.guid + '-sec-grp'
+            rule1 = SecurityGroupRuleConfig(
+                sec_grp_name=self.sec_grp_name, direction=Direction.ingress,
+                protocol=Protocol.icmp)
+            rule2 = SecurityGroupRuleConfig(
+                sec_grp_name=self.sec_grp_name, direction=Direction.egress,
+                protocol=Protocol.icmp)

             self.sec_grp_creator = OpenStackSecurityGroup(
                 self.os_creds,
             self.sec_grp_creator = OpenStackSecurityGroup(
                 self.os_creds,

-                SecurityGroupSettings(name=sec_grp_name,
-                                      rule_settings=[rule1]))
+                SecurityGroupConfig(
+                    name=self.sec_grp_name, rule_settings=[rule1, rule2]))

             self.sec_grp_creator.create()
         except:
             self.tearDown()
             self.sec_grp_creator.create()
         except:
             self.tearDown()


@@ -2813,17 +3003,18 @@ class CreateInstanceTwoNetTests(OSIntegrationTestCase):
         ports_settings = []
         ctr = 1
         for network_creator in self.network_creators:
         ports_settings = []
         ctr = 1
         for network_creator in self.network_creators:

-            ports_settings.append(PortSettings(
+            ports_settings.append(PortConfig(

                 name=self.guid + '-port-' + str(ctr),
                 network_name=network_creator.network_settings.name))
             ctr += 1
 
         # Configure instances
                 name=self.guid + '-port-' + str(ctr),
                 network_name=network_creator.network_settings.name))
             ctr += 1
 
         # Configure instances

-        instance1_settings = VmInstanceSettings(
+        instance1_settings = VmInstanceConfig(

             name=self.vm_inst1_name,
             flavor=self.flavor_creator.flavor_settings.name,
             userdata=_get_ping_userdata(self.ip2),
             name=self.vm_inst1_name,
             flavor=self.flavor_creator.flavor_settings.name,
             userdata=_get_ping_userdata(self.ip2),

-            port_settings=[PortSettings(
+            security_group_names=self.sec_grp_name,
+            port_settings=[PortConfig(

                 name=self.port_1_name,
                 ip_addrs=[{
                     'subnet_name':
                 name=self.port_1_name,
                 ip_addrs=[{
                     'subnet_name':


@@ -2831,11 +3022,12 @@ class CreateInstanceTwoNetTests(OSIntegrationTestCase):
                     'ip': self.ip1
                 }],
                 network_name=self.network_creators[0].network_settings.name)])
                     'ip': self.ip1
                 }],
                 network_name=self.network_creators[0].network_settings.name)])

-        instance2_settings = VmInstanceSettings(
+        instance2_settings = VmInstanceConfig(

             name=self.vm_inst2_name,
             flavor=self.flavor_creator.flavor_settings.name,
             userdata=_get_ping_userdata(self.ip1),
             name=self.vm_inst2_name,
             flavor=self.flavor_creator.flavor_settings.name,
             userdata=_get_ping_userdata(self.ip1),

-            port_settings=[PortSettings(
+            security_group_names=self.sec_grp_name,
+            port_settings=[PortConfig(

                 name=self.port_2_name,
                 ip_addrs=[{
                     'subnet_name':
                 name=self.port_2_name,
                 ip_addrs=[{
                     'subnet_name':


@@ -2879,13 +3071,18 @@ class CreateInstanceVolumeTests(OSIntegrationTestCase):
 
         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.vm_inst_name = guid + '-inst'
 
         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.vm_inst_name = guid + '-inst'

-        self.nova = nova_utils.nova_client(self.os_creds)
+        self.nova = nova_utils.nova_client(
+            self.os_creds, self.os_session)
+        self.neutron = neutron_utils.neutron_client(
+            self.os_creds, self.os_session)

         os_image_settings = openstack_tests.cirros_image_settings(
             name=guid + '-image', image_metadata=self.image_metadata)
 
         net_config = openstack_tests.get_priv_net_config(
         os_image_settings = openstack_tests.cirros_image_settings(
             name=guid + '-image', image_metadata=self.image_metadata)
 
         net_config = openstack_tests.get_priv_net_config(

+            project_name=self.os_creds.project_name,

             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',

-            router_name=guid + '-pub-router', external_net=self.ext_net_name)
+            router_name=guid + '-pub-router', external_net=self.ext_net_name,
+            netconf_override=self.netconf_override)

 
         self.volume_settings1 = VolumeConfig(
             name=self.__class__.__name__ + '-' + str(guid) + '-1')
 
         self.volume_settings1 = VolumeConfig(
             name=self.__class__.__name__ + '-' + str(guid) + '-1')


@@ -2908,10 +3105,11 @@ class CreateInstanceVolumeTests(OSIntegrationTestCase):
             self.image_creator.create()
 
             # Create Flavor
             self.image_creator.create()
 
             # Create Flavor

+            flavor_config = openstack_tests.get_flavor_config(
+                name=guid + '-flavor-name', ram=256, disk=1,
+                vcpus=2, metadata=self.flavor_metadata)

             self.flavor_creator = OpenStackFlavor(
             self.flavor_creator = OpenStackFlavor(

-                self.admin_os_creds,
-                FlavorConfig(name=guid + '-flavor-name', ram=256, disk=1,
-                             vcpus=2, metadata=self.flavor_metadata))
+                self.admin_os_creds, flavor_config)

             self.flavor_creator.create()
 
             # Create Network
             self.flavor_creator.create()
 
             # Create Network


@@ -2919,7 +3117,7 @@ class CreateInstanceVolumeTests(OSIntegrationTestCase):
                 self.os_creds, net_config.network_settings)
             self.network_creator.create()
 
                 self.os_creds, net_config.network_settings)
             self.network_creator.create()
 

-            self.port_settings = PortSettings(
+            self.port_settings = PortConfig(

                 name=guid + '-port',
                 network_name=net_config.network_settings.name)
 
                 name=guid + '-port',
                 network_name=net_config.network_settings.name)
 


@@ -2992,7 +3190,7 @@ class CreateInstanceVolumeTests(OSIntegrationTestCase):
         """
         Tests the creation of an OpenStack instance with a single volume.
         """
         """
         Tests the creation of an OpenStack instance with a single volume.
         """

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings],
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings],


@@ -3004,7 +3202,8 @@ class CreateInstanceVolumeTests(OSIntegrationTestCase):
 
         vm_inst = self.inst_creator.create(block=True)
         self.assertIsNotNone(nova_utils.get_server(
 
         vm_inst = self.inst_creator.create(block=True)
         self.assertIsNotNone(nova_utils.get_server(

-            self.nova, vm_inst_settings=instance_settings))
+            self.nova, self.neutron, self.keystone,
+            vm_inst_settings=instance_settings))

 
         self.assertIsNotNone(vm_inst)
         self.assertEqual(1, len(vm_inst.volume_ids))
 
         self.assertIsNotNone(vm_inst)
         self.assertEqual(1, len(vm_inst.volume_ids))


@@ -3015,7 +3214,7 @@ class CreateInstanceVolumeTests(OSIntegrationTestCase):
         """
         Tests the creation of an OpenStack instance with a single volume.
         """
         """
         Tests the creation of an OpenStack instance with a single volume.
         """

-        instance_settings = VmInstanceSettings(
+        instance_settings = VmInstanceConfig(

             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings],
             name=self.vm_inst_name,
             flavor=self.flavor_creator.flavor_settings.name,
             port_settings=[self.port_settings],


@@ -3028,7 +3227,8 @@ class CreateInstanceVolumeTests(OSIntegrationTestCase):
 
         vm_inst = self.inst_creator.create(block=True)
         self.assertIsNotNone(nova_utils.get_server(
 
         vm_inst = self.inst_creator.create(block=True)
         self.assertIsNotNone(nova_utils.get_server(

-            self.nova, vm_inst_settings=instance_settings))
+            self.nova, self.neutron, self.keystone,
+            vm_inst_settings=instance_settings))

 
         self.assertIsNotNone(vm_inst)
         self.assertEqual(2, len(vm_inst.volume_ids))
 
         self.assertIsNotNone(vm_inst)
         self.assertEqual(2, len(vm_inst.volume_ids))