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
21 from snaps.openstack.create_instance import OpenStackVmInstance
22 from snaps.openstack.create_keypairs import OpenStackKeypair
23 from snaps.openstack.create_volume import OpenStackVolume
24 from snaps.openstack.create_volume_type import OpenStackVolumeType
25 from snaps.openstack.openstack_creator import OpenStackCloudObject
26 from snaps.openstack.utils import (
27 nova_utils, settings_utils, glance_utils, cinder_utils)
29 from snaps.openstack.create_network import OpenStackNetwork
30 from snaps.openstack.utils import heat_utils, neutron_utils
32 __author__ = 'spisarski'
34 logger = logging.getLogger('create_stack')
36 STACK_DELETE_TIMEOUT = 1200
37 STACK_COMPLETE_TIMEOUT = 1200
39 STATUS_CREATE_FAILED = 'CREATE_FAILED'
40 STATUS_CREATE_COMPLETE = 'CREATE_COMPLETE'
41 STATUS_DELETE_COMPLETE = 'DELETE_COMPLETE'
42 STATUS_DELETE_FAILED = 'DELETE_FAILED'
45 class OpenStackHeatStack(OpenStackCloudObject, object):
47 Class responsible for managing a heat stack in OpenStack
50 def __init__(self, os_creds, stack_settings, image_settings=None,
51 keypair_settings=None):
54 :param os_creds: The OpenStack connection credentials
55 :param stack_settings: The stack settings
56 :param image_settings: A list of ImageSettings objects that were used
57 for spawning this stack
58 :param image_settings: A list of ImageSettings objects that were used
59 for spawning this stack
60 :param keypair_settings: A list of KeypairSettings objects that were
61 used for spawning this stack
64 super(self.__class__, self).__init__(os_creds)
66 self.stack_settings = stack_settings
69 self.image_settings = image_settings
71 self.image_settings = None
74 self.keypair_settings = keypair_settings
76 self.keypair_settings = None
79 self.__heat_cli = None
83 Loads the existing heat stack
84 :return: The Stack domain object or None
86 self.__heat_cli = heat_utils.heat_client(self._os_creds)
87 self.__stack = heat_utils.get_stack(
88 self.__heat_cli, stack_settings=self.stack_settings)
90 logger.info('Found stack with name - ' + self.stack_settings.name)
95 Creates the heat stack in OpenStack if it does not already exist and
96 returns the domain Stack object
97 :return: The Stack domain object or None
102 logger.info('Found stack with name - %s', self.stack_settings.name)
105 self.__stack = heat_utils.create_stack(self.__heat_cli,
108 'Created stack with name - %s', self.stack_settings.name)
109 if self.__stack and self.stack_complete(block=True):
110 logger.info('Stack is now active with name - %s',
111 self.stack_settings.name)
114 status = heat_utils.get_stack_status_reason(self.__heat_cli,
116 logger.error('ERROR: STACK CREATION FAILED: %s', status)
117 raise StackCreationError('Failure while creating stack')
121 Cleanse environment of all artifacts
126 logger.info('Deleting stack - %s', self.__stack.name)
127 heat_utils.delete_stack(self.__heat_cli, self.__stack)
130 self.stack_deleted(block=True)
131 except StackError as e:
132 # Stack deletion seems to fail quite a bit
133 logger.warn('Stack did not delete properly - %s', e)
136 for vm_inst_creator in self.get_vm_inst_creators():
138 vm_inst_creator.clean()
139 if not vm_inst_creator.vm_deleted(block=True):
140 logger.warn('Unable to deleted VM - %s',
141 vm_inst_creator.get_vm_inst().name)
143 logger.warn('Unexpected error deleting VM - %s ',
144 vm_inst_creator.get_vm_inst().name)
146 logger.info('Attempting to delete again stack - %s',
150 heat_utils.delete_stack(self.__heat_cli, self.__stack)
151 deleted = self.stack_deleted(block=True)
154 'Stack could not be deleted ' + self.__stack.name)
162 Returns the domain Stack object as it was populated when create() was
168 def get_outputs(self):
170 Returns the list of outputs as contained on the OpenStack Heat Stack
174 return heat_utils.get_outputs(self.__heat_cli, self.__stack)
176 def get_status(self):
178 Returns the list of outputs as contained on the OpenStack Heat Stack
182 return heat_utils.get_stack_status(self.__heat_cli, self.__stack.id)
184 def stack_complete(self, block=False, timeout=None,
185 poll_interval=POLL_INTERVAL):
187 Returns true when the stack status returns the value of
189 :param block: When true, thread will block until active or timeout
190 value in seconds has been exceeded (False)
191 :param timeout: The timeout value
192 :param poll_interval: The polling interval in seconds
196 timeout = self.stack_settings.stack_create_timeout
197 return self._stack_status_check(STATUS_CREATE_COMPLETE, block, timeout,
198 poll_interval, STATUS_CREATE_FAILED)
200 def stack_deleted(self, block=False, timeout=STACK_DELETE_TIMEOUT,
201 poll_interval=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(STATUS_DELETE_COMPLETE, block, timeout,
212 poll_interval, STATUS_DELETE_FAILED)
214 def get_network_creators(self):
216 Returns a list of network creator objects as configured by the heat
218 :return: list() of OpenStackNetwork objects
221 neutron = neutron_utils.neutron_client(self._os_creds)
224 stack_networks = heat_utils.get_stack_networks(
225 self.__heat_cli, neutron, self.__stack)
227 for stack_network in stack_networks:
228 net_settings = settings_utils.create_network_settings(
229 neutron, stack_network)
230 net_creator = OpenStackNetwork(self._os_creds, net_settings)
231 out.append(net_creator)
232 net_creator.initialize()
236 def get_vm_inst_creators(self, heat_keypair_option=None):
238 Returns a list of VM Instance creator objects as configured by the heat
240 :return: list() of OpenStackVmInstance objects
244 nova = nova_utils.nova_client(self._os_creds)
246 stack_servers = heat_utils.get_stack_servers(
247 self.__heat_cli, nova, self.__stack)
249 neutron = neutron_utils.neutron_client(self._os_creds)
250 glance = glance_utils.glance_client(self._os_creds)
252 for stack_server in stack_servers:
253 vm_inst_settings = settings_utils.create_vm_inst_settings(
254 nova, neutron, stack_server)
255 image_settings = settings_utils.determine_image_settings(
256 glance, stack_server, self.image_settings)
257 keypair_settings = settings_utils.determine_keypair_settings(
258 self.__heat_cli, self.__stack, stack_server,
259 keypair_settings=self.keypair_settings,
260 priv_key_key=heat_keypair_option)
261 vm_inst_creator = OpenStackVmInstance(
262 self._os_creds, vm_inst_settings, image_settings,
264 out.append(vm_inst_creator)
265 vm_inst_creator.initialize()
269 def get_volume_creators(self):
271 Returns a list of Volume creator objects as configured by the heat
273 :return: list() of OpenStackVolume objects
277 cinder = cinder_utils.cinder_client(self._os_creds)
279 volumes = heat_utils.get_stack_volumes(
280 self.__heat_cli, cinder, self.__stack)
282 for volume in volumes:
283 settings = settings_utils.create_volume_settings(volume)
284 creator = OpenStackVolume(self._os_creds, settings)
289 except Exception as e:
291 'Unexpected error initializing volume creator - %s', e)
295 def get_volume_type_creators(self):
297 Returns a list of VolumeType creator objects as configured by the heat
299 :return: list() of OpenStackVolumeType objects
303 cinder = cinder_utils.cinder_client(self._os_creds)
305 vol_types = heat_utils.get_stack_volume_types(
306 self.__heat_cli, cinder, self.__stack)
308 for volume in vol_types:
309 settings = settings_utils.create_volume_type_settings(volume)
310 creator = OpenStackVolumeType(self._os_creds, settings)
315 except Exception as e:
317 'Unexpected error initializing volume type creator - %s',
322 def get_keypair_creators(self, outputs_pk_key=None):
324 Returns a list of keypair creator objects as configured by the heat
326 :return: list() of OpenStackKeypair objects
330 nova = nova_utils.nova_client(self._os_creds)
332 keypairs = heat_utils.get_stack_keypairs(
333 self.__heat_cli, nova, self.__stack)
335 for keypair in keypairs:
336 settings = settings_utils.create_keypair_settings(
337 self.__heat_cli, self.__stack, keypair, outputs_pk_key)
338 creator = OpenStackKeypair(self._os_creds, settings)
343 except Exception as e:
345 'Unexpected error initializing volume type creator - %s',
350 def _stack_status_check(self, expected_status_code, block, timeout,
351 poll_interval, fail_status):
353 Returns true when the stack status returns the value of
355 :param expected_status_code: stack status evaluated with this string
357 :param block: When true, thread will block until active or timeout
358 value in seconds has been exceeded (False)
359 :param timeout: The timeout value
360 :param poll_interval: The polling interval in seconds
361 :param fail_status: Returns false if the fail_status code is found
364 # sleep and wait for stack status change
368 start = time.time() - timeout
370 while timeout > time.time() - start:
371 status = self._status(expected_status_code, fail_status)
374 'Stack is active with name - ' + self.stack_settings.name)
377 logger.debug('Retry querying stack status in ' + str(
378 poll_interval) + ' seconds')
379 time.sleep(poll_interval)
380 logger.debug('Stack status query timeout in ' + str(
381 timeout - (time.time() - start)))
384 'Timeout checking for stack status for ' + expected_status_code)
387 def _status(self, expected_status_code, fail_status=STATUS_CREATE_FAILED):
389 Returns True when active else False
390 :param expected_status_code: stack status evaluated with this string
394 status = self.get_status()
397 'Cannot stack status for stack with ID - ' + self.__stack.id)
400 if fail_status and status == fail_status:
401 raise StackError('Stack had an error')
402 logger.debug('Stack status is - ' + status)
403 return status == expected_status_code
407 def __init__(self, **kwargs):
410 :param name: the stack's name (required)
411 :param template: the heat template in dict() format (required if
412 template_path attribute is None)
413 :param template_path: the location of the heat template file (required
414 if template attribute is None)
415 :param env_values: dict() of strings for substitution of template
416 default values (optional)
419 self.name = kwargs.get('name')
420 self.template = kwargs.get('template')
421 self.template_path = kwargs.get('template_path')
422 self.env_values = kwargs.get('env_values')
423 if 'stack_create_timeout' in kwargs:
424 self.stack_create_timeout = kwargs['stack_create_timeout']
426 self.stack_create_timeout = STACK_COMPLETE_TIMEOUT
429 raise StackSettingsError('name is required')
431 if not self.template and not self.template_path:
432 raise StackSettingsError('A Heat template is required')
434 def __eq__(self, other):
435 return (self.name == other.name and
436 self.template == other.template and
437 self.template_path == other.template_path and
438 self.env_values == other.env_values and
439 self.stack_create_timeout == other.stack_create_timeout)
442 class StackSettingsError(Exception):
444 Exception to be thrown when an stack settings are incorrect
448 class StackCreationError(Exception):
450 Exception to be thrown when an stack cannot be created
454 class StackError(Exception):