self.__stack = None
self.__heat_cli = None
+ self.__neutron = None
+ self.__nova = None
+ self.__glance = None
+ self.__cinder = None
+
def initialize(self):
"""
Loads the existing heat stack
:return: The Stack domain object or None
"""
- self.__heat_cli = heat_utils.heat_client(self._os_creds)
+ 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:
self.__stack = None
+ self.__neutron.httpclient.session.session.close()
+ self.__nova.client.session.session.close()
+ self.__glance.http_client.session.session.close()
+ self.__cinder.client.session.session.close()
+
+ super(self.__class__, self).clean()
+
def get_stack(self):
"""
Returns the domain Stack object as it was populated when create() was
called
:return: the object
"""
- return self.__stack
+ if self.__stack:
+ return heat_utils.get_stack_by_id(self.__heat_cli, self.__stack.id)
def get_outputs(self):
"""
object
:return:
"""
- return heat_utils.get_stack_status(self.__heat_cli, self.__stack.id)
+ stack = self.get_stack()
+ if stack:
+ return stack.status
def stack_complete(self, block=False, timeout=None,
poll_interval=snaps.config.stack.POLL_INTERVAL):
:return: list() of OpenStackNetwork objects
"""
- neutron = neutron_utils.neutron_client(self._os_creds)
-
out = list()
stack_networks = heat_utils.get_stack_networks(
- self.__heat_cli, neutron, self.__stack)
+ self.__heat_cli, self.__neutron, self.__stack)
for stack_network in stack_networks:
- net_settings = settings_utils.create_network_settings(
- neutron, stack_network)
+ net_settings = settings_utils.create_network_config(
+ self.__neutron, stack_network)
net_creator = OpenStackNetwork(self._os_creds, net_settings)
out.append(net_creator)
net_creator.initialize()
:return: list() of OpenStackNetwork objects
"""
- neutron = neutron_utils.neutron_client(self._os_creds)
-
out = list()
stack_security_groups = heat_utils.get_stack_security_groups(
- self.__heat_cli, neutron, self.__stack)
+ self.__heat_cli, self.__neutron, self.__stack)
for stack_security_group in stack_security_groups:
- settings = settings_utils.create_security_group_settings(
- neutron, stack_security_group)
+ settings = settings_utils.create_security_group_config(
+ self.__neutron, stack_security_group)
creator = OpenStackSecurityGroup(self._os_creds, settings)
out.append(creator)
creator.initialize()
:return: list() of OpenStackRouter objects
"""
- neutron = neutron_utils.neutron_client(self._os_creds)
-
out = list()
stack_routers = heat_utils.get_stack_routers(
- self.__heat_cli, neutron, self.__stack)
+ self.__heat_cli, self.__neutron, self.__stack)
for routers in stack_routers:
- settings = settings_utils.create_router_settings(
- neutron, routers)
+ settings = settings_utils.create_router_config(
+ self.__neutron, routers)
creator = OpenStackRouter(self._os_creds, settings)
out.append(creator)
creator.initialize()
"""
out = list()
- nova = nova_utils.nova_client(self._os_creds)
stack_servers = heat_utils.get_stack_servers(
- self.__heat_cli, nova, self.__stack)
-
- neutron = neutron_utils.neutron_client(self._os_creds)
- glance = glance_utils.glance_client(self._os_creds)
+ self.__heat_cli, self.__nova, self.__neutron, self._keystone,
+ self.__stack, self._os_creds.project_name)
for stack_server in stack_servers:
- vm_inst_settings = settings_utils.create_vm_inst_settings(
- nova, neutron, stack_server)
+ vm_inst_settings = settings_utils.create_vm_inst_config(
+ self.__nova, self._keystone, self.__neutron, stack_server,
+ self._os_creds.project_name)
image_settings = settings_utils.determine_image_config(
- glance, stack_server, self.image_settings)
+ self.__glance, stack_server, self.image_settings)
keypair_settings = settings_utils.determine_keypair_config(
self.__heat_cli, self.__stack, stack_server,
keypair_settings=self.keypair_settings,
"""
out = list()
- cinder = cinder_utils.cinder_client(self._os_creds)
-
volumes = heat_utils.get_stack_volumes(
- self.__heat_cli, cinder, self.__stack)
+ self.__heat_cli, self.__cinder, self.__stack)
for volume in volumes:
- settings = settings_utils.create_volume_settings(volume)
+ settings = settings_utils.create_volume_config(volume)
creator = OpenStackVolume(self._os_creds, settings)
out.append(creator)
"""
out = list()
- cinder = cinder_utils.cinder_client(self._os_creds)
-
vol_types = heat_utils.get_stack_volume_types(
- self.__heat_cli, cinder, self.__stack)
+ self.__heat_cli, self.__cinder, self.__stack)
for volume in vol_types:
- settings = settings_utils.create_volume_type_settings(volume)
+ settings = settings_utils.create_volume_type_config(volume)
creator = OpenStackVolumeType(self._os_creds, settings)
out.append(creator)
"""
out = list()
- nova = nova_utils.nova_client(self._os_creds)
keypairs = heat_utils.get_stack_keypairs(
- self.__heat_cli, nova, self.__stack)
+ self.__heat_cli, self.__nova, self.__stack)
for keypair in keypairs:
- settings = settings_utils.create_keypair_settings(
+ settings = settings_utils.create_keypair_config(
self.__heat_cli, self.__stack, keypair, outputs_pk_key)
creator = OpenStackKeypair(self._os_creds, settings)
out.append(creator)
"""
out = list()
- nova = nova_utils.nova_client(self._os_creds)
flavors = heat_utils.get_stack_flavors(
- self.__heat_cli, nova, self.__stack)
+ self.__heat_cli, self.__nova, self.__stack)
for flavor in flavors:
settings = settings_utils.create_flavor_config(flavor)
return False
if fail_status and status == fail_status:
- resources = heat_utils.get_resources(self.__heat_cli, self.__stack)
+ resources = heat_utils.get_resources(
+ self.__heat_cli, self.__stack.id)
logger.error('Stack %s failed', self.__stack.name)
for resource in resources:
if (resource.status !=
return status == expected_status_code
+def generate_creator(os_creds, stack_inst, image_settings):
+ """
+ Initializes an OpenStackHeatStack object
+ :param os_creds: the OpenStack credentials
+ :param stack_inst: the SNAPS-OO VmInst domain object
+ :param image_settings: list of SNAPS-OO ImageConfig objects
+ :return: an initialized OpenStackHeatStack object
+ """
+
+ heat_config = StackConfig(
+ name=stack_inst.name, template={'place': 'holder'})
+ heat_creator = OpenStackHeatStack(os_creds, heat_config, image_settings)
+ heat_creator.initialize()
+ return heat_creator
+
+
class StackSettings(StackConfig):
"""
Class to hold the configuration settings required for creating OpenStack
Code Review / snaps.git / blobdiff