1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
2 # and others. All rights reserved.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
19 from heatclient.exc import HTTPNotFound
22 from snaps.config.stack import StackConfig
23 from snaps.openstack.create_flavor import OpenStackFlavor
24 from snaps.openstack.create_instance import OpenStackVmInstance
25 from snaps.openstack.create_keypairs import OpenStackKeypair
26 from snaps.openstack.create_security_group import OpenStackSecurityGroup
27 from snaps.openstack.create_router import OpenStackRouter
28 from snaps.openstack.create_volume import OpenStackVolume
29 from snaps.openstack.create_volume_type import OpenStackVolumeType
30 from snaps.openstack.openstack_creator import OpenStackCloudObject
31 from snaps.openstack.utils import (
32 nova_utils, settings_utils, glance_utils, cinder_utils, keystone_utils)
34 from snaps.openstack.create_network import OpenStackNetwork
35 from snaps.openstack.utils import heat_utils, neutron_utils
37 __author__ = 'spisarski'
39 logger = logging.getLogger('create_stack')
42 class OpenStackHeatStack(OpenStackCloudObject, object):
44 Class responsible for managing a heat stack in OpenStack
47 def __init__(self, os_creds, stack_settings, image_settings=None,
48 keypair_settings=None):
51 :param os_creds: The OpenStack connection credentials
52 :param stack_settings: The stack settings
53 :param image_settings: A list of ImageConfig objects that were used
54 for spawning this stack
55 :param keypair_settings: A list of KeypairConfig objects that were
56 used for spawning this stack
59 super(self.__class__, self).__init__(os_creds)
61 self.stack_settings = stack_settings
64 self.image_settings = image_settings
66 self.image_settings = None
69 self.keypair_settings = keypair_settings
71 self.keypair_settings = None
74 self.__heat_cli = None
78 Loads the existing heat stack
79 :return: The Stack domain object or None
81 self.__heat_cli = heat_utils.heat_client(self._os_creds)
82 self.__stack = heat_utils.get_stack(
83 self.__heat_cli, stack_settings=self.stack_settings)
85 logger.info('Found stack with name - ' + self.stack_settings.name)
90 Creates the heat stack in OpenStack if it does not already exist and
91 returns the domain Stack object
92 :return: The Stack domain object or None
97 logger.info('Found stack with name - %s', self.stack_settings.name)
100 self.__stack = heat_utils.create_stack(self.__heat_cli,
103 'Created stack with name - %s', self.stack_settings.name)
104 if self.__stack and self.stack_complete(block=True):
105 logger.info('Stack is now active with name - %s',
106 self.stack_settings.name)
109 status = heat_utils.get_stack_status_reason(self.__heat_cli,
111 logger.error('ERROR: STACK CREATION FAILED: %s', status)
112 raise StackCreationError('Failure while creating stack')
116 Cleanse environment of all artifacts
121 logger.info('Deleting stack - %s', self.__stack.name)
122 heat_utils.delete_stack(self.__heat_cli, self.__stack)
125 self.stack_deleted(block=True)
126 except StackError as e:
127 # Stack deletion seems to fail quite a bit
128 logger.warn('Stack did not delete properly - %s', e)
131 for vm_inst_creator in self.get_vm_inst_creators():
133 vm_inst_creator.clean()
134 if not vm_inst_creator.vm_deleted(block=True):
135 logger.warn('Unable to deleted VM - %s',
136 vm_inst_creator.get_vm_inst().name)
138 logger.warn('Unexpected error deleting VM - %s ',
139 vm_inst_creator.get_vm_inst().name)
141 logger.info('Attempting to delete again stack - %s',
145 heat_utils.delete_stack(self.__heat_cli, self.__stack)
146 deleted = self.stack_deleted(block=True)
149 'Stack could not be deleted ' + self.__stack.name)
157 Returns the domain Stack object as it was populated when create() was
162 return heat_utils.get_stack_by_id(self.__heat_cli, self.__stack.id)
164 def get_outputs(self):
166 Returns the list of outputs as contained on the OpenStack Heat Stack
170 return heat_utils.get_outputs(self.__heat_cli, self.__stack)
172 def get_status(self):
174 Returns the list of outputs as contained on the OpenStack Heat Stack
178 stack = self.get_stack()
182 def stack_complete(self, block=False, timeout=None,
183 poll_interval=snaps.config.stack.POLL_INTERVAL):
185 Returns true when the stack status returns the value of
187 :param block: When true, thread will block until active or timeout
188 value in seconds has been exceeded (False)
189 :param timeout: The timeout value
190 :param poll_interval: The polling interval in seconds
194 timeout = self.stack_settings.stack_create_timeout
195 return self._stack_status_check(
196 snaps.config.stack.STATUS_CREATE_COMPLETE, block, timeout,
197 poll_interval, snaps.config.stack.STATUS_CREATE_FAILED)
199 def stack_deleted(self, block=False,
200 timeout=snaps.config.stack.STACK_DELETE_TIMEOUT,
201 poll_interval=snaps.config.stack.POLL_INTERVAL):
203 Returns true when the stack status returns the value of
205 :param block: When true, thread will block until active or timeout
206 value in seconds has been exceeded (False)
207 :param timeout: The timeout value
208 :param poll_interval: The polling interval in seconds
211 return self._stack_status_check(
212 snaps.config.stack.STATUS_DELETE_COMPLETE, block, timeout,
213 poll_interval, snaps.config.stack.STATUS_DELETE_FAILED)
215 def get_network_creators(self):
217 Returns a list of network creator objects as configured by the heat
219 :return: list() of OpenStackNetwork objects
222 neutron = neutron_utils.neutron_client(self._os_creds)
225 stack_networks = heat_utils.get_stack_networks(
226 self.__heat_cli, neutron, self.__stack)
228 for stack_network in stack_networks:
229 net_settings = settings_utils.create_network_config(
230 neutron, stack_network)
231 net_creator = OpenStackNetwork(self._os_creds, net_settings)
232 out.append(net_creator)
233 net_creator.initialize()
237 def get_security_group_creators(self):
239 Returns a list of security group creator objects as configured by the
241 :return: list() of OpenStackNetwork objects
244 neutron = neutron_utils.neutron_client(self._os_creds)
247 stack_security_groups = heat_utils.get_stack_security_groups(
248 self.__heat_cli, neutron, self.__stack)
250 for stack_security_group in stack_security_groups:
251 settings = settings_utils.create_security_group_config(
252 neutron, stack_security_group)
253 creator = OpenStackSecurityGroup(self._os_creds, settings)
259 def get_router_creators(self):
261 Returns a list of router creator objects as configured by the heat
263 :return: list() of OpenStackRouter objects
266 neutron = neutron_utils.neutron_client(self._os_creds)
269 stack_routers = heat_utils.get_stack_routers(
270 self.__heat_cli, neutron, self.__stack)
272 for routers in stack_routers:
273 settings = settings_utils.create_router_config(
275 creator = OpenStackRouter(self._os_creds, settings)
281 def get_vm_inst_creators(self, heat_keypair_option=None):
283 Returns a list of VM Instance creator objects as configured by the heat
285 :return: list() of OpenStackVmInstance objects
290 nova = nova_utils.nova_client(self._os_creds)
291 keystone = keystone_utils.keystone_client(self._os_creds)
292 neutron = neutron_utils.neutron_client(self._os_creds)
293 stack_servers = heat_utils.get_stack_servers(
294 self.__heat_cli, nova, neutron, keystone, self.__stack,
295 self._os_creds.project_name)
297 glance = glance_utils.glance_client(self._os_creds)
299 for stack_server in stack_servers:
300 vm_inst_settings = settings_utils.create_vm_inst_config(
301 nova, keystone, neutron, stack_server,
302 self._os_creds.project_name)
303 image_settings = settings_utils.determine_image_config(
304 glance, stack_server, self.image_settings)
305 keypair_settings = settings_utils.determine_keypair_config(
306 self.__heat_cli, self.__stack, stack_server,
307 keypair_settings=self.keypair_settings,
308 priv_key_key=heat_keypair_option)
309 vm_inst_creator = OpenStackVmInstance(
310 self._os_creds, vm_inst_settings, image_settings,
312 out.append(vm_inst_creator)
313 vm_inst_creator.initialize()
317 def get_volume_creators(self):
319 Returns a list of Volume creator objects as configured by the heat
321 :return: list() of OpenStackVolume objects
325 cinder = cinder_utils.cinder_client(self._os_creds)
327 volumes = heat_utils.get_stack_volumes(
328 self.__heat_cli, cinder, self.__stack)
330 for volume in volumes:
331 settings = settings_utils.create_volume_config(volume)
332 creator = OpenStackVolume(self._os_creds, settings)
337 except Exception as e:
339 'Unexpected error initializing volume creator - %s', e)
343 def get_volume_type_creators(self):
345 Returns a list of VolumeType creator objects as configured by the heat
347 :return: list() of OpenStackVolumeType objects
351 cinder = cinder_utils.cinder_client(self._os_creds)
353 vol_types = heat_utils.get_stack_volume_types(
354 self.__heat_cli, cinder, self.__stack)
356 for volume in vol_types:
357 settings = settings_utils.create_volume_type_config(volume)
358 creator = OpenStackVolumeType(self._os_creds, settings)
363 except Exception as e:
365 'Unexpected error initializing volume type creator - %s',
370 def get_keypair_creators(self, outputs_pk_key=None):
372 Returns a list of keypair creator objects as configured by the heat
374 :return: list() of OpenStackKeypair objects
378 nova = nova_utils.nova_client(self._os_creds)
380 keypairs = heat_utils.get_stack_keypairs(
381 self.__heat_cli, nova, self.__stack)
383 for keypair in keypairs:
384 settings = settings_utils.create_keypair_config(
385 self.__heat_cli, self.__stack, keypair, outputs_pk_key)
386 creator = OpenStackKeypair(self._os_creds, settings)
391 except Exception as e:
393 'Unexpected error initializing volume type creator - %s',
398 def get_flavor_creators(self):
400 Returns a list of Flavor creator objects as configured by the heat
402 :return: list() of OpenStackFlavor objects
406 nova = nova_utils.nova_client(self._os_creds)
408 flavors = heat_utils.get_stack_flavors(
409 self.__heat_cli, nova, self.__stack)
411 for flavor in flavors:
412 settings = settings_utils.create_flavor_config(flavor)
413 creator = OpenStackFlavor(self._os_creds, settings)
418 except Exception as e:
420 'Unexpected error initializing volume creator - %s', e)
424 def _stack_status_check(self, expected_status_code, block, timeout,
425 poll_interval, fail_status):
427 Returns true when the stack status returns the value of
429 :param expected_status_code: stack status evaluated with this string
431 :param block: When true, thread will block until active or timeout
432 value in seconds has been exceeded (False)
433 :param timeout: The timeout value
434 :param poll_interval: The polling interval in seconds
435 :param fail_status: Returns false if the fail_status code is found
438 # sleep and wait for stack status change
442 start = time.time() - timeout
444 while timeout > time.time() - start:
445 status = self._status(expected_status_code, fail_status)
448 'Stack is active with name - ' + self.stack_settings.name)
451 logger.debug('Retry querying stack status in ' + str(
452 poll_interval) + ' seconds')
453 time.sleep(poll_interval)
454 logger.debug('Stack status query timeout in ' + str(
455 timeout - (time.time() - start)))
458 'Timeout checking for stack status for ' + expected_status_code)
461 def _status(self, expected_status_code,
462 fail_status=snaps.config.stack.STATUS_CREATE_FAILED):
464 Returns True when active else False
465 :param expected_status_code: stack status evaluated with this string
469 status = self.get_status()
472 'Cannot stack status for stack with ID - ' + self.__stack.id)
475 if fail_status and status == fail_status:
476 resources = heat_utils.get_resources(
477 self.__heat_cli, self.__stack.id)
478 logger.error('Stack %s failed', self.__stack.name)
479 for resource in resources:
480 if (resource.status !=
481 snaps.config.stack.STATUS_CREATE_COMPLETE):
483 'Resource: [%s] status: [%s] reason: [%s]',
484 resource.name, resource.status, resource.status_reason)
487 'Resource: [%s] status: [%s] reason: [%s]',
488 resource.name, resource.status, resource.status_reason)
490 raise StackError('Stack had an error')
491 logger.debug('Stack status is - ' + status)
492 return status == expected_status_code
495 class StackSettings(StackConfig):
497 Class to hold the configuration settings required for creating OpenStack
502 def __init__(self, **kwargs):
503 from warnings import warn
504 warn('Use snaps.config.stack.StackConfig instead',
506 super(self.__class__, self).__init__(**kwargs)
509 class StackCreationError(Exception):
511 Exception to be thrown when an stack cannot be created
515 class StackError(Exception):