def setUp(self):
"""
Instantiates OpenStack instances that cannot be spawned by Heat
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
stack_name = guid + '-stack'
self.net_name = guid + '-net'
self.subnet_name = guid + '-subnet'
self.router_name = guid + '-router'
env_values = {
'net_name': self.net_name,
'subnet_name': self.subnet_name,
'router_name': self.router_name,
'external_net_name': self.ext_net_name
}
heat_tmplt_path = pkg_resources.resource_filename(
'snaps.openstack.tests.heat', 'router_heat_template.yaml')
self.stack_settings = StackConfig(name=stack_name,
template_path=heat_tmplt_path,
env_values=env_values)
self.stack = None
self.heat_client = heat_utils.heat_client(self.os_creds,
self.os_session)
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
def generate_creator(os_creds,
vm_inst,
image_config,
project_name,
keypair_config=None):
"""
Initializes an OpenStackVmInstance object
:param os_creds: the OpenStack credentials
:param vm_inst: the SNAPS-OO VmInst domain object
:param image_config: the associated ImageConfig object
:param project_name: the associated project ID
:param keypair_config: the associated KeypairConfig object (optional)
:return: an initialized OpenStackVmInstance object
"""
session = keystone_utils.keystone_session(os_creds)
nova = nova_utils.nova_client(os_creds, session)
keystone = keystone_utils.keystone_client(os_creds, session)
neutron = neutron_utils.neutron_client(os_creds, session)
try:
derived_inst_config = settings_utils.create_vm_inst_config(
nova, keystone, neutron, vm_inst, project_name)
derived_inst_creator = OpenStackVmInstance(os_creds,
derived_inst_config,
image_config,
keypair_config)
derived_inst_creator.initialize()
return derived_inst_creator
finally:
keystone_utils.close_session(session)
def __reboot_openstack_node(vm_info):
creds_dict = vm_info.get('os_creds')
os_creds = OSCreds(**creds_dict)
logger.debug('Retrieving keystone session %s', creds_dict)
os_sess = keystone_utils.keystone_session(os_creds)
try:
logger.debug('Retrieving OpenStack clients with %s', creds_dict)
nova = nova_utils.nova_client(os_creds, os_sess)
neutron = neutron_utils.neutron_client(os_creds, os_sess)
keystone = keystone_utils.keystone_client(os_creds, os_sess)
logger.info('Retrieved OpenStack clients')
vm_inst = nova_utils.get_server_object_by_id(nova, neutron, keystone,
vm_info['id'])
logger.info('Looking up VM named [%s]', vm_inst.name)
if vm_inst:
logger.debug('Generating VM SNAPS creator with creds [%s]',
creds_dict)
snaps_vm = create_instance.generate_creator(
os_creds, vm_inst, None, os_creds.project_name)
if snaps_vm:
logger.info('Rebooting VM with name %s', vm_inst.name)
snaps_vm.reboot(RebootType.hard)
else:
logger.warn('Unable to obtain a SNAPS-OO VM creator [%s]',
vm_inst.name)
else:
logger.warn('Unable to locate VM with name %s', vm_inst.name)
finally:
logger.info('Closing keystone session')
keystone_utils.close_session(os_sess)
def tearDown(self):
"""
Cleans the remote OpenStack objects
"""
if self.project:
neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
default_sec_grp = neutron_utils.get_security_group(
neutron,
self.keystone,
sec_grp_name='default',
project_name=self.os_creds.project_name)
if default_sec_grp:
try:
neutron_utils.delete_security_group(
neutron, default_sec_grp)
except:
pass
keystone_utils.delete_project(self.keystone, self.project)
if self.user:
keystone_utils.delete_user(self.keystone, self.user)
if self.role:
keystone_utils.delete_role(self.keystone, self.role)
super(self.__class__, self).__clean__()
def test_update_quotas(self):
"""
Tests the creation of an OpenStack project where the quotas get
updated.
"""
self.project_creator = OpenStackProject(self.os_creds,
self.project_settings)
created_project = self.project_creator.create()
self.assertIsNotNone(created_project)
retrieved_project = keystone_utils.get_project(
keystone=self.keystone, project_settings=self.project_settings)
self.assertIsNotNone(retrieved_project)
self.assertEqual(created_project, retrieved_project)
self.assertTrue(
validate_project(self.keystone, self.project_settings,
created_project))
update_compute_quotas = ComputeQuotas(
**{
'metadata_items': 64,
'cores': 5,
'instances': 5,
'injected_files': 3,
'injected_file_content_bytes': 5120,
'ram': 25600,
'fixed_ips': 100,
'key_pairs': 50
})
self.project_creator.update_compute_quotas(update_compute_quotas)
update_network_quotas = NetworkQuotas(
**{
'security_group': 5,
'security_group_rule': 50,
'floatingip': 25,
'network': 5,
'port': 25,
'router': 6,
'subnet': 7
})
self.project_creator.update_network_quotas(update_network_quotas)
self.assertEqual(update_compute_quotas,
self.project_creator.get_compute_quotas())
self.assertEqual(update_network_quotas,
self.project_creator.get_network_quotas())
nova = nova_utils.nova_client(self.os_creds, self.os_session)
new_compute_quotas = nova_utils.get_compute_quotas(
nova,
self.project_creator.get_project().id)
self.assertEqual(update_compute_quotas, new_compute_quotas)
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
new_network_quotas = neutron_utils.get_network_quotas(
neutron,
self.project_creator.get_project().id)
self.assertEqual(update_network_quotas, new_network_quotas)
def __init__(self):
self.os_creds = openstack_tests.get_credentials(
os_env_file=constants.ENV_FILE)
self.creators = []
self.nova = nova_utils.nova_client(self.os_creds)
self.neutron = neutron_utils.neutron_client(self.os_creds)
self.heat = heat_utils.heat_client(self.os_creds)
self.keystone = keystone_utils.keystone_client(self.os_creds)
def check_neutron(self):
""" checks that a simple neutron operation works """
try:
client = neutron_utils.neutron_client(self.os_creds)
client.list_networks()
LOGGER.info("Neutron service ...OK")
except Exception as error:
LOGGER.error("Neutron service ...FAILED")
raise error
def get_ext_net_name(os_creds):
"""
Returns the first external network name
:param: os_creds: an instance of snaps OSCreds object
:return:
"""
neutron = neutron_utils.neutron_client(os_creds)
ext_nets = neutron_utils.get_external_networks(neutron)
return ext_nets[0].name
def setUp(self):
"""
Setup objects required by VM instances
:return:
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.nova = nova_utils.nova_client(
self.os_creds, self.os_session)
self.keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
self.neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
self.glance = glance_utils.glance_client(
self.os_creds, self.os_session)
self.image_creator = None
self.network_creator = None
self.flavor_creator = None
self.port = None
self.vm_inst = None
try:
image_settings = openstack_tests.cirros_image_settings(
name=guid + '-image', image_metadata=self.image_metadata)
self.image_creator = OpenStackImage(
self.os_creds, image_settings=image_settings)
self.image_creator.create()
network_settings = openstack_tests.get_priv_net_config(
project_name=self.os_creds.project_name,
net_name="{}-{}".format(guid, 'net'),
subnet_name="{}-{}".format(guid, 'subnet')).network_settings
self.network_creator = OpenStackNetwork(
self.os_creds, network_settings)
self.network_creator.create()
flavor_config = openstack_tests.get_flavor_config(
name="{}-{}".format(guid, 'flavor-name'), ram=256, disk=10,
vcpus=1, metadata=self.flavor_metadata)
self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_config)
self.flavor_creator.create()
port_settings = PortConfig(
name=guid + '-port', network_name=network_settings.name)
self.port = neutron_utils.create_port(
self.neutron, self.os_creds, port_settings)
self.instance_settings = VmInstanceConfig(
name=guid + '-vm_inst',
flavor=self.flavor_creator.flavor_settings.name,
port_settings=[port_settings])
except:
self.tearDown()
raise
def setUp(self):
"""
Instantiates OpenStack instances that cannot be spawned by Heat
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.network_name = guid + '-net'
self.subnet_name = guid + '-subnet'
self.net_creator = None
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
def get_ext_net_name():
"""
Returns the first external network name
:return:
"""
os_env_file = CONST.openstack_creds
os_creds = openstack_tests.get_credentials(os_env_file=os_env_file)
neutron = neutron_utils.neutron_client(os_creds)
ext_nets = neutron_utils.get_external_networks(neutron)
return ext_nets[0]['network']['name']
def deploy_vnf(self):
"""Deploy ABOT-OAI-EPC."""
self.__logger.info("Upload VNFD")
descriptor = self.vnf['descriptor']
self.__logger.info("Get or create flavor for all Abot-EPC")
flavor_settings = FlavorConfig(
name=self.vnf['requirements']['flavor']['name'],
ram=self.vnf['requirements']['flavor']['ram_min'],
disk=10,
vcpus=1)
flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
flavor_creator.create()
self.created_object.append(flavor_creator)
self.__logger.info("Deploying Abot-epc bundle file ...")
os.system('juju deploy {}'.format('/' + descriptor.get('file_name')))
self.__logger.info("Waiting for instances .....")
status = os.system('juju-wait')
self.__logger.info("juju wait completed: %s", status)
self.__logger.info("Deployed Abot-epc on Openstack")
nova_client = nova_utils.nova_client(self.snaps_creds)
neutron_client = neutron_utils.neutron_client(self.snaps_creds)
if status == 0:
instances = os_utils.get_instances(nova_client)
for items in instances:
metadata = get_instance_metadata(nova_client, items)
if 'juju-units-deployed' in metadata:
sec_group = ('juju-' + metadata['juju-controller-uuid'] +
'-' + metadata['juju-model-uuid'])
self.sec_group_id = os_utils.get_security_group_id(
neutron_client, sec_group)
break
self.__logger.info("Adding Security group rule....")
os_utils.create_secgroup_rule(
neutron_client, self.sec_group_id, 'ingress', 132)
self.__logger.info("Copying the feature files to Abot_node ")
os.system('juju scp -- -r {}/featureFiles abot-'
'epc-basic/0:~/'.format(self.case_dir))
self.__logger.info("Copying the feature files in Abot_node ")
os.system("juju ssh abot-epc-basic/0 'sudo rsync -azvv "
"~/featureFiles /etc/rebaca-test-suite"
"/featureFiles'")
count = 0
while count < 10:
epcstatus = os.system('juju status oai-epc | '
'grep {} | grep {} | grep {}'
.format('EPC', 'is', 'running'))
if epcstatus == 0:
break
else:
time.sleep(60)
count = count + 1
os.system('juju-wait')
return True
return False
def get_network_quotas(self):
"""
Returns the network quotas as an instance of the NetworkQuotas class
:return:
"""
neutron = neutron_utils.neutron_client(self._os_creds,
self._os_session)
try:
return neutron_utils.get_network_quotas(neutron, self.__project.id)
finally:
neutron.httpclient.session.session.close()
def update_network_quotas(self, network_quotas):
"""
Updates the network quotas for this project
:param network_quotas: a NetworkQuotas object.
"""
neutron = neutron_utils.neutron_client(self._os_creds,
self._os_session)
try:
neutron_utils.update_quotas(neutron, self.__project.id,
network_quotas)
finally:
neutron.httpclient.session.session.close()
def setUp(self):
"""
Sets up object for test
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
# Initialize for cleanup
self.net_creator = None
def setUp(self):
"""
Initializes objects used for router testing
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.router_creator = None
self.network_creator1 = None
self.network_creator2 = None
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
def setUp(self):
"""
Instantiates the CreateSecurityGroup 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.sec_grp_name = guid + 'name'
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
# Initialize for cleanup
self.sec_grp_creator = None
def test_detach_volume_nowait(self):
"""
Tests the nova_utils.detach_volume() with a timeout value that is too
small to have the volume attachment data to be included on the VmInst
object that was supposed to be returned
"""
self.assertIsNotNone(self.volume_creator.get_volume())
self.assertEqual(0, len(self.volume_creator.get_volume().attachments))
# Attach volume to VM
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
nova_utils.attach_volume(
self.nova, neutron, keystone, self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name)
# Check VmInst for attachment
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
latest_vm = nova_utils.get_server_object_by_id(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst().id, self.os_creds.project_name)
self.assertEqual(1, len(latest_vm.volume_ids))
# Check Volume for attachment
vol_attach = None
attached = False
start_time = time.time()
while time.time() < start_time + 120:
vol_attach = cinder_utils.get_volume_by_id(
self.cinder, self.volume_creator.get_volume().id)
if len(vol_attach.attachments) > 0:
attached = True
break
time.sleep(3)
self.assertTrue(attached)
self.assertIsNotNone(vol_attach)
# Detach volume
with self.assertRaises(NovaException):
nova_utils.detach_volume(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name,
0)
def test_create_stack(self):
"""
Tests the creation of an OpenStack Heat stack1 that does not exist.
"""
self.stack1 = heat_utils.create_stack(self.heat_client,
self.stack_settings1)
stack_query_1 = heat_utils.get_stack(
self.heat_client, stack_settings=self.stack_settings1)
self.assertEqual(self.stack1, stack_query_1)
stack_query_2 = heat_utils.get_stack(
self.heat_client, stack_name=self.stack_settings1.name)
self.assertEqual(self.stack1, stack_query_2)
stack_query_3 = heat_utils.get_stack_by_id(self.heat_client,
self.stack1.id)
self.assertEqual(self.stack1, stack_query_3)
resources = heat_utils.get_resources(self.heat_client, self.stack1.id)
self.assertIsNotNone(resources)
self.assertEqual(4, len(resources))
outputs = heat_utils.get_outputs(self.heat_client, self.stack1)
self.assertIsNotNone(outputs)
self.assertEqual(0, len(outputs))
self.assertTrue(stack_active(self.heat_client, self.stack1))
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
networks = heat_utils.get_stack_networks(self.heat_client, neutron,
self.stack1)
self.assertIsNotNone(networks)
self.assertEqual(1, len(networks))
self.assertEqual(self.network_name, networks[0].name)
subnets = neutron_utils.get_subnets_by_network(neutron, networks[0])
self.assertEqual(1, len(subnets))
self.assertEqual(self.subnet_name, subnets[0].name)
nova = nova_utils.nova_client(self.os_creds, self.os_session)
keystone = keystone_utils.keystone_client(self.os_creds,
self.os_session)
servers = heat_utils.get_stack_servers(self.heat_client, nova, neutron,
keystone, self.stack1,
self.os_creds.project_name)
self.assertIsNotNone(servers)
self.assertEqual(1, len(servers))
self.assertEqual(self.vm_inst_name, servers[0].name)
def get_ext_net_name(os_creds):
"""
Returns the configured external network name or
the first retrieved external network name
:param: os_creds: an instance of snaps OSCreds object
:return:
"""
neutron = neutron_utils.neutron_client(os_creds)
ext_nets = neutron_utils.get_external_networks(neutron)
if env.get('EXTERNAL_NETWORK'):
extnet_config = env.get('EXTERNAL_NETWORK')
for ext_net in ext_nets:
if ext_net.name == extnet_config:
return extnet_config
return ext_nets[0].name if ext_nets else ""
def setUp(self):
"""
Sets up object for test
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.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')
self.neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
self.keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
# Initialize for cleanup
self.net_creator = None
def setUp(self):
"""
Initializes objects used for router testing
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.router_creator = None
self.network_creator = None
self.sec_grp_creator = OpenStackSecurityGroup(
self.os_creds, SecurityGroupConfig(name=self.guid + '-sec_grp'))
self.sec_grp_creator.create()
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
def test_create_router_with_ext_port(self):
"""
Test creation of a router with a port to an external network as an
'admin' user.
"""
port_settings = [
create_network.PortConfig(name=self.guid + '-port1',
network_name=self.ext_net_name)
]
router_settings = RouterConfig(name=self.guid + '-pub-router',
port_settings=port_settings)
self.router_creator = create_router.OpenStackRouter(
self.admin_os_creds, router_settings)
self.router_creator.create()
admin_neutron = neutron_utils.neutron_client(self.admin_os_creds,
self.admin_os_session)
admin_keystone = keystone_utils.keystone_client(
self.admin_os_creds, self.admin_os_session)
router = neutron_utils.get_router(
admin_neutron,
admin_keystone,
router_settings=router_settings,
project_name=self.admin_os_creds.project_name)
self.assertIsNotNone(router)
self.assertEquals(router, self.router_creator.get_router())
ext_net = neutron_utils.get_network(admin_neutron,
admin_keystone,
network_name=self.ext_net_name)
self.assertIsNotNone(ext_net)
self.assertIsNotNone(router.port_subnets)
id_found = False
for port, subnets in router.port_subnets:
self.assertIsNotNone(subnets)
self.assertIsNotNone(port)
if ext_net.id == port.network_id:
id_found = True
for subnet in subnets:
self.assertIsNotNone(subnet)
self.assertEqual(ext_net.id, subnet.network_id)
self.assertTrue(id_found)
def clean(self):
"""
Cleanse environment of all artifacts
:return: void
"""
if self.__project:
# Delete security group 'default' if exists
neutron = neutron_utils.neutron_client(self._os_creds,
self._os_session)
try:
default_sec_grp = neutron_utils.get_security_group(
neutron,
self._keystone,
sec_grp_name='default',
project_name=self.__project.name)
if default_sec_grp:
try:
neutron_utils.delete_security_group(
neutron, default_sec_grp)
except:
pass
finally:
neutron.httpclient.session.session.close()
# Delete Project
try:
keystone_utils.delete_project(self._keystone, self.__project)
except NotFound:
pass
self.__project = None
if self.__role:
try:
keystone_utils.delete_role(self._keystone, self.__role)
except NotFound:
pass
self.__project = None
# Final role check in case init was done from an existing instance
role = keystone_utils.get_role_by_name(self._keystone,
self.__role_name)
if role:
keystone_utils.delete_role(self._keystone, role)
super(self.__class__, self).clean()
def initialize(self):
"""
Loads the existing VMInst, Port, FloatingIps
:return: VMInst domain object
"""
super(self.__class__, self).initialize()
self.__neutron = neutron_utils.neutron_client(self._os_creds,
self._os_session)
self.__keystone = keystone_utils.keystone_client(
self._os_creds, self._os_session)
self.__cinder = cinder_utils.cinder_client(self._os_creds,
self._os_session)
self.__glance = glance_utils.glance_client(self._os_creds,
self._os_session)
self.__ports = self.__query_ports(self.instance_settings.port_settings)
self.__lookup_existing_vm_by_name()
def setUp(self):
"""
Initializes objects used for router testing
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.router_creator = None
ext_network_settings = NetworkConfig(
name=self.guid + '-ext-net',
external=True,
subnet_settings=[
create_network.SubnetConfig(cidr=cidr1,
name=self.guid + '-ext-subnet1')
])
self.ext_network_creator = OpenStackNetwork(self.admin_os_creds,
ext_network_settings)
self.ext_network_creator.create()
shared_network_settings = NetworkConfig(
name=self.guid + '-shared-net',
shared=True,
subnet_settings=[
create_network.SubnetConfig(cidr=cidr2,
name=self.guid + '-shared-subnet1')
])
self.shared_network_creator = OpenStackNetwork(
self.admin_os_creds, shared_network_settings)
self.shared_network_creator.create()
overlay_network_settings = NetworkConfig(
name=self.guid + '-overlay-net',
subnet_settings=[
create_network.SubnetConfig(cidr=cidr3,
name=self.guid +
'-overlay-subnet1')
])
self.overlay_network_creator = OpenStackNetwork(
self.os_creds, overlay_network_settings)
self.overlay_network_creator.create()
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
def setUp(self):
"""
Instantiates the CreateSecurityGroup 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.sec_grp_name = guid + 'name'
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
# Initialize for cleanup
self.admin_sec_grp_config = SecurityGroupConfig(
name=self.sec_grp_name, description='hello group')
self.sec_grp_creator_admin = OpenStackSecurityGroup(
self.admin_os_creds, self.admin_sec_grp_config)
self.sec_grp_creator_admin.create()
self.sec_grp_creator_proj = None
def test_attach_volume_nowait(self):
"""
Tests the nova_utils.attach_volume() with a timeout value that is too
small to have the volume attachment data to be included on the VmInst
object that was supposed to be returned
"""
self.assertIsNotNone(self.volume_creator.get_volume())
self.assertEqual(0, len(self.volume_creator.get_volume().attachments))
# Attach volume to VM
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
with self.assertRaises(NovaException):
nova_utils.attach_volume(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name,
0)
def setUp(self):
"""
Sets up object for test
"""
super(self.__class__, self).__start__()
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.net_config = openstack_tests.get_pub_net_config(
project_name=self.os_creds.project_name,
net_name="{}-{}".format(guid, 'pub-net'), mtu=999,
subnet_name="{}-{}".format(guid, 'pub-subnet'),
router_name="{}-{}".format(guid, 'pub-router'),
external_net=self.ext_net_name,
netconf_override=self.netconf_override)
self.neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
# Initialize for cleanup
self.net_creator = None
self.router_creator = None
def initialize(self):
"""
Loads the existing heat stack
:return: The Stack domain object or None
"""
super(self.__class__, self).initialize()
self.__neutron = neutron_utils.neutron_client(self._os_creds,
self._os_session)
self.__nova = nova_utils.nova_client(self._os_creds, self._os_session)
self.__glance = glance_utils.glance_client(self._os_creds,
self._os_session)
self.__cinder = cinder_utils.cinder_client(self._os_creds,
self._os_session)
self.__heat_cli = heat_utils.heat_client(self._os_creds,
self._os_session)
self.__stack = heat_utils.get_stack(self.__heat_cli,
stack_settings=self.stack_settings)
if self.__stack:
logger.info('Found stack with name - ' + self.stack_settings.name)
return self.__stack
