snaps/openstack/create_stack.py

   1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
   2 #                    and others.  All rights reserved.
   3 #
   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:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  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.
  15
  16 import logging
  17 import time
  18
  19 from heatclient.exc import HTTPNotFound
  20
  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)
  28
  29 from snaps.openstack.create_network import OpenStackNetwork
  30 from snaps.openstack.utils import heat_utils, neutron_utils
  31
  32 __author__ = 'spisarski'
  33
  34 logger = logging.getLogger('create_stack')
  35
  36 STACK_DELETE_TIMEOUT = 1200
  37 STACK_COMPLETE_TIMEOUT = 1200
  38 POLL_INTERVAL = 3
  39 STATUS_CREATE_FAILED = 'CREATE_FAILED'
  40 STATUS_CREATE_COMPLETE = 'CREATE_COMPLETE'
  41 STATUS_DELETE_COMPLETE = 'DELETE_COMPLETE'
  42 STATUS_DELETE_FAILED = 'DELETE_FAILED'
  43
  44
  45 class OpenStackHeatStack(OpenStackCloudObject, object):
  46     """
  47     Class responsible for managing a heat stack in OpenStack
  48     """
  49
  50     def __init__(self, os_creds, stack_settings, image_settings=None,
  51                  keypair_settings=None):
  52         """
  53         Constructor
  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
  62         :return:
  63         """
  64         super(self.__class__, self).__init__(os_creds)
  65
  66         self.stack_settings = stack_settings
  67
  68         if image_settings:
  69             self.image_settings = image_settings
  70         else:
  71             self.image_settings = None
  72
  73         if image_settings:
  74             self.keypair_settings = keypair_settings
  75         else:
  76             self.keypair_settings = None
  77
  78         self.__stack = None
  79         self.__heat_cli = None
  80
  81     def initialize(self):
  82         """
  83         Loads the existing heat stack
  84         :return: The Stack domain object or None
  85         """
  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)
  89         if self.__stack:
  90             logger.info('Found stack with name - ' + self.stack_settings.name)
  91             return self.__stack
  92
  93     def create(self):
  94         """
  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
  98         """
  99         self.initialize()
 100
 101         if self.__stack:
 102             logger.info('Found stack with name - %s', self.stack_settings.name)
 103             return self.__stack
 104         else:
 105             self.__stack = heat_utils.create_stack(self.__heat_cli,
 106                                                    self.stack_settings)
 107             logger.info(
 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)
 112                 return self.__stack
 113             else:
 114                 status = heat_utils.get_stack_status_reason(self.__heat_cli,
 115                                                             self.__stack.id)
 116                 logger.error('ERROR: STACK CREATION FAILED: %s', status)
 117                 raise StackCreationError('Failure while creating stack')
 118
 119     def clean(self):
 120         """
 121         Cleanse environment of all artifacts
 122         :return: void
 123         """
 124         if self.__stack:
 125             try:
 126                 logger.info('Deleting stack - %s', self.__stack.name)
 127                 heat_utils.delete_stack(self.__heat_cli, self.__stack)
 128
 129                 try:
 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)
 134
 135                     # Delete VMs first
 136                     for vm_inst_creator in self.get_vm_inst_creators():
 137                         try:
 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)
 142                         except:
 143                             logger.warn('Unexpected error deleting VM - %s ',
 144                                         vm_inst_creator.get_vm_inst().name)
 145
 146                 logger.info('Attempting to delete again stack - %s',
 147                             self.__stack.name)
 148
 149                 # Delete Stack again
 150                 heat_utils.delete_stack(self.__heat_cli, self.__stack)
 151                 deleted = self.stack_deleted(block=True)
 152                 if not deleted:
 153                     raise StackError(
 154                         'Stack could not be deleted ' + self.__stack.name)
 155             except HTTPNotFound:
 156                 pass
 157
 158             self.__stack = None
 159
 160     def get_stack(self):
 161         """
 162         Returns the domain Stack object as it was populated when create() was
 163         called
 164         :return: the object
 165         """
 166         return self.__stack
 167
 168     def get_outputs(self):
 169         """
 170         Returns the list of outputs as contained on the OpenStack Heat Stack
 171         object
 172         :return:
 173         """
 174         return heat_utils.get_outputs(self.__heat_cli, self.__stack)
 175
 176     def get_status(self):
 177         """
 178         Returns the list of outputs as contained on the OpenStack Heat Stack
 179         object
 180         :return:
 181         """
 182         return heat_utils.get_stack_status(self.__heat_cli, self.__stack.id)
 183
 184     def stack_complete(self, block=False, timeout=None,
 185                        poll_interval=POLL_INTERVAL):
 186         """
 187         Returns true when the stack status returns the value of
 188         expected_status_code
 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
 193         :return: T/F
 194         """
 195         if not timeout:
 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)
 199
 200     def stack_deleted(self, block=False, timeout=STACK_DELETE_TIMEOUT,
 201                       poll_interval=POLL_INTERVAL):
 202         """
 203         Returns true when the stack status returns the value of
 204         expected_status_code
 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
 209         :return: T/F
 210         """
 211         return self._stack_status_check(STATUS_DELETE_COMPLETE, block, timeout,
 212                                         poll_interval, STATUS_DELETE_FAILED)
 213
 214     def get_network_creators(self):
 215         """
 216         Returns a list of network creator objects as configured by the heat
 217         template
 218         :return: list() of OpenStackNetwork objects
 219         """
 220
 221         neutron = neutron_utils.neutron_client(self._os_creds)
 222
 223         out = list()
 224         stack_networks = heat_utils.get_stack_networks(
 225             self.__heat_cli, neutron, self.__stack)
 226
 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()
 233
 234         return out
 235
 236     def get_vm_inst_creators(self, heat_keypair_option=None):
 237         """
 238         Returns a list of VM Instance creator objects as configured by the heat
 239         template
 240         :return: list() of OpenStackVmInstance objects
 241         """
 242
 243         out = list()
 244         nova = nova_utils.nova_client(self._os_creds)
 245
 246         stack_servers = heat_utils.get_stack_servers(
 247             self.__heat_cli, nova, self.__stack)
 248
 249         neutron = neutron_utils.neutron_client(self._os_creds)
 250         glance = glance_utils.glance_client(self._os_creds)
 251
 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,
 263                 keypair_settings)
 264             out.append(vm_inst_creator)
 265             vm_inst_creator.initialize()
 266
 267         return out
 268
 269     def get_volume_creators(self):
 270         """
 271         Returns a list of Volume creator objects as configured by the heat
 272         template
 273         :return: list() of OpenStackVolume objects
 274         """
 275
 276         out = list()
 277         cinder = cinder_utils.cinder_client(self._os_creds)
 278
 279         volumes = heat_utils.get_stack_volumes(
 280             self.__heat_cli, cinder, self.__stack)
 281
 282         for volume in volumes:
 283             settings = settings_utils.create_volume_settings(volume)
 284             creator = OpenStackVolume(self._os_creds, settings)
 285             out.append(creator)
 286
 287             try:
 288                 creator.initialize()
 289             except Exception as e:
 290                 logger.error(
 291                     'Unexpected error initializing volume creator - %s', e)
 292
 293         return out
 294
 295     def get_volume_type_creators(self):
 296         """
 297         Returns a list of VolumeType creator objects as configured by the heat
 298         template
 299         :return: list() of OpenStackVolumeType objects
 300         """
 301
 302         out = list()
 303         cinder = cinder_utils.cinder_client(self._os_creds)
 304
 305         vol_types = heat_utils.get_stack_volume_types(
 306             self.__heat_cli, cinder, self.__stack)
 307
 308         for volume in vol_types:
 309             settings = settings_utils.create_volume_type_settings(volume)
 310             creator = OpenStackVolumeType(self._os_creds, settings)
 311             out.append(creator)
 312
 313             try:
 314                 creator.initialize()
 315             except Exception as e:
 316                 logger.error(
 317                     'Unexpected error initializing volume type creator - %s',
 318                     e)
 319
 320         return out
 321
 322     def get_keypair_creators(self, outputs_pk_key=None):
 323         """
 324         Returns a list of keypair creator objects as configured by the heat
 325         template
 326         :return: list() of OpenStackKeypair objects
 327         """
 328
 329         out = list()
 330         nova = nova_utils.nova_client(self._os_creds)
 331
 332         keypairs = heat_utils.get_stack_keypairs(
 333             self.__heat_cli, nova, self.__stack)
 334
 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)
 339             out.append(creator)
 340
 341             try:
 342                 creator.initialize()
 343             except Exception as e:
 344                 logger.error(
 345                     'Unexpected error initializing volume type creator - %s',
 346                     e)
 347
 348         return out
 349
 350     def _stack_status_check(self, expected_status_code, block, timeout,
 351                             poll_interval, fail_status):
 352         """
 353         Returns true when the stack status returns the value of
 354         expected_status_code
 355         :param expected_status_code: stack status evaluated with this string
 356                                      value
 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
 362         :return: T/F
 363         """
 364         # sleep and wait for stack status change
 365         if block:
 366             start = time.time()
 367         else:
 368             start = time.time() - timeout
 369
 370         while timeout > time.time() - start:
 371             status = self._status(expected_status_code, fail_status)
 372             if status:
 373                 logger.debug(
 374                     'Stack is active with name - ' + self.stack_settings.name)
 375                 return True
 376
 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)))
 382
 383         logger.error(
 384             'Timeout checking for stack status for ' + expected_status_code)
 385         return False
 386
 387     def _status(self, expected_status_code, fail_status=STATUS_CREATE_FAILED):
 388         """
 389         Returns True when active else False
 390         :param expected_status_code: stack status evaluated with this string
 391         value
 392         :return: T/F
 393         """
 394         status = self.get_status()
 395         if not status:
 396             logger.warning(
 397                 'Cannot stack status for stack with ID - ' + self.__stack.id)
 398             return False
 399
 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
 404
 405
 406 class StackSettings:
 407     def __init__(self, **kwargs):
 408         """
 409         Constructor
 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)
 417         """
 418
 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']
 425         else:
 426             self.stack_create_timeout = STACK_COMPLETE_TIMEOUT
 427
 428         if not self.name:
 429             raise StackSettingsError('name is required')
 430
 431         if not self.template and not self.template_path:
 432             raise StackSettingsError('A Heat template is required')
 433
 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)
 440
 441
 442 class StackSettingsError(Exception):
 443     """
 444     Exception to be thrown when an stack settings are incorrect
 445     """
 446
 447
 448 class StackCreationError(Exception):
 449     """
 450     Exception to be thrown when an stack cannot be created
 451     """
 452
 453
 454 class StackError(Exception):
 455     """
 456     General exception
 457     """