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_flavor import OpenStackFlavor
  22 from snaps.openstack.create_instance import OpenStackVmInstance
  23 from snaps.openstack.create_keypairs import OpenStackKeypair
  24 from snaps.openstack.create_volume import OpenStackVolume
  25 from snaps.openstack.create_volume_type import OpenStackVolumeType
  26 from snaps.openstack.openstack_creator import OpenStackCloudObject
  27 from snaps.openstack.utils import (
  28     nova_utils, settings_utils, glance_utils, cinder_utils)
  29
  30 from snaps.openstack.create_network import OpenStackNetwork
  31 from snaps.openstack.utils import heat_utils, neutron_utils
  32
  33 __author__ = 'spisarski'
  34
  35 logger = logging.getLogger('create_stack')
  36
  37 STACK_DELETE_TIMEOUT = 1200
  38 STACK_COMPLETE_TIMEOUT = 1200
  39 POLL_INTERVAL = 3
  40 STATUS_CREATE_FAILED = 'CREATE_FAILED'
  41 STATUS_CREATE_COMPLETE = 'CREATE_COMPLETE'
  42 STATUS_DELETE_COMPLETE = 'DELETE_COMPLETE'
  43 STATUS_DELETE_FAILED = 'DELETE_FAILED'
  44
  45
  46 class OpenStackHeatStack(OpenStackCloudObject, object):
  47     """
  48     Class responsible for managing a heat stack in OpenStack
  49     """
  50
  51     def __init__(self, os_creds, stack_settings, image_settings=None,
  52                  keypair_settings=None):
  53         """
  54         Constructor
  55         :param os_creds: The OpenStack connection credentials
  56         :param stack_settings: The stack settings
  57         :param image_settings: A list of ImageSettings objects that were used
  58                                for spawning this stack
  59         :param image_settings: A list of ImageSettings objects that were used
  60                                for spawning this stack
  61         :param keypair_settings: A list of KeypairSettings objects that were
  62                                  used for spawning this stack
  63         :return:
  64         """
  65         super(self.__class__, self).__init__(os_creds)
  66
  67         self.stack_settings = stack_settings
  68
  69         if image_settings:
  70             self.image_settings = image_settings
  71         else:
  72             self.image_settings = None
  73
  74         if image_settings:
  75             self.keypair_settings = keypair_settings
  76         else:
  77             self.keypair_settings = None
  78
  79         self.__stack = None
  80         self.__heat_cli = None
  81
  82     def initialize(self):
  83         """
  84         Loads the existing heat stack
  85         :return: The Stack domain object or None
  86         """
  87         self.__heat_cli = heat_utils.heat_client(self._os_creds)
  88         self.__stack = heat_utils.get_stack(
  89             self.__heat_cli, stack_settings=self.stack_settings)
  90         if self.__stack:
  91             logger.info('Found stack with name - ' + self.stack_settings.name)
  92             return self.__stack
  93
  94     def create(self):
  95         """
  96         Creates the heat stack in OpenStack if it does not already exist and
  97         returns the domain Stack object
  98         :return: The Stack domain object or None
  99         """
 100         self.initialize()
 101
 102         if self.__stack:
 103             logger.info('Found stack with name - %s', self.stack_settings.name)
 104             return self.__stack
 105         else:
 106             self.__stack = heat_utils.create_stack(self.__heat_cli,
 107                                                    self.stack_settings)
 108             logger.info(
 109                 'Created stack with name - %s', self.stack_settings.name)
 110             if self.__stack and self.stack_complete(block=True):
 111                 logger.info('Stack is now active with name - %s',
 112                             self.stack_settings.name)
 113                 return self.__stack
 114             else:
 115                 status = heat_utils.get_stack_status_reason(self.__heat_cli,
 116                                                             self.__stack.id)
 117                 logger.error('ERROR: STACK CREATION FAILED: %s', status)
 118                 raise StackCreationError('Failure while creating stack')
 119
 120     def clean(self):
 121         """
 122         Cleanse environment of all artifacts
 123         :return: void
 124         """
 125         if self.__stack:
 126             try:
 127                 logger.info('Deleting stack - %s', self.__stack.name)
 128                 heat_utils.delete_stack(self.__heat_cli, self.__stack)
 129
 130                 try:
 131                     self.stack_deleted(block=True)
 132                 except StackError as e:
 133                     # Stack deletion seems to fail quite a bit
 134                     logger.warn('Stack did not delete properly - %s', e)
 135
 136                     # Delete VMs first
 137                     for vm_inst_creator in self.get_vm_inst_creators():
 138                         try:
 139                             vm_inst_creator.clean()
 140                             if not vm_inst_creator.vm_deleted(block=True):
 141                                 logger.warn('Unable to deleted VM - %s',
 142                                             vm_inst_creator.get_vm_inst().name)
 143                         except:
 144                             logger.warn('Unexpected error deleting VM - %s ',
 145                                         vm_inst_creator.get_vm_inst().name)
 146
 147                 logger.info('Attempting to delete again stack - %s',
 148                             self.__stack.name)
 149
 150                 # Delete Stack again
 151                 heat_utils.delete_stack(self.__heat_cli, self.__stack)
 152                 deleted = self.stack_deleted(block=True)
 153                 if not deleted:
 154                     raise StackError(
 155                         'Stack could not be deleted ' + self.__stack.name)
 156             except HTTPNotFound:
 157                 pass
 158
 159             self.__stack = None
 160
 161     def get_stack(self):
 162         """
 163         Returns the domain Stack object as it was populated when create() was
 164         called
 165         :return: the object
 166         """
 167         return self.__stack
 168
 169     def get_outputs(self):
 170         """
 171         Returns the list of outputs as contained on the OpenStack Heat Stack
 172         object
 173         :return:
 174         """
 175         return heat_utils.get_outputs(self.__heat_cli, self.__stack)
 176
 177     def get_status(self):
 178         """
 179         Returns the list of outputs as contained on the OpenStack Heat Stack
 180         object
 181         :return:
 182         """
 183         return heat_utils.get_stack_status(self.__heat_cli, self.__stack.id)
 184
 185     def stack_complete(self, block=False, timeout=None,
 186                        poll_interval=POLL_INTERVAL):
 187         """
 188         Returns true when the stack status returns the value of
 189         expected_status_code
 190         :param block: When true, thread will block until active or timeout
 191                       value in seconds has been exceeded (False)
 192         :param timeout: The timeout value
 193         :param poll_interval: The polling interval in seconds
 194         :return: T/F
 195         """
 196         if not timeout:
 197             timeout = self.stack_settings.stack_create_timeout
 198         return self._stack_status_check(STATUS_CREATE_COMPLETE, block, timeout,
 199                                         poll_interval, STATUS_CREATE_FAILED)
 200
 201     def stack_deleted(self, block=False, timeout=STACK_DELETE_TIMEOUT,
 202                       poll_interval=POLL_INTERVAL):
 203         """
 204         Returns true when the stack status returns the value of
 205         expected_status_code
 206         :param block: When true, thread will block until active or timeout
 207                       value in seconds has been exceeded (False)
 208         :param timeout: The timeout value
 209         :param poll_interval: The polling interval in seconds
 210         :return: T/F
 211         """
 212         return self._stack_status_check(STATUS_DELETE_COMPLETE, block, timeout,
 213                                         poll_interval, STATUS_DELETE_FAILED)
 214
 215     def get_network_creators(self):
 216         """
 217         Returns a list of network creator objects as configured by the heat
 218         template
 219         :return: list() of OpenStackNetwork objects
 220         """
 221
 222         neutron = neutron_utils.neutron_client(self._os_creds)
 223
 224         out = list()
 225         stack_networks = heat_utils.get_stack_networks(
 226             self.__heat_cli, neutron, self.__stack)
 227
 228         for stack_network in stack_networks:
 229             net_settings = settings_utils.create_network_settings(
 230                 neutron, stack_network)
 231             net_creator = OpenStackNetwork(self._os_creds, net_settings)
 232             out.append(net_creator)
 233             net_creator.initialize()
 234
 235         return out
 236
 237     def get_vm_inst_creators(self, heat_keypair_option=None):
 238         """
 239         Returns a list of VM Instance creator objects as configured by the heat
 240         template
 241         :return: list() of OpenStackVmInstance objects
 242         """
 243
 244         out = list()
 245         nova = nova_utils.nova_client(self._os_creds)
 246
 247         stack_servers = heat_utils.get_stack_servers(
 248             self.__heat_cli, nova, self.__stack)
 249
 250         neutron = neutron_utils.neutron_client(self._os_creds)
 251         glance = glance_utils.glance_client(self._os_creds)
 252
 253         for stack_server in stack_servers:
 254             vm_inst_settings = settings_utils.create_vm_inst_settings(
 255                 nova, neutron, stack_server)
 256             image_settings = settings_utils.determine_image_settings(
 257                 glance, stack_server, self.image_settings)
 258             keypair_settings = settings_utils.determine_keypair_settings(
 259                 self.__heat_cli, self.__stack, stack_server,
 260                 keypair_settings=self.keypair_settings,
 261                 priv_key_key=heat_keypair_option)
 262             vm_inst_creator = OpenStackVmInstance(
 263                 self._os_creds, vm_inst_settings, image_settings,
 264                 keypair_settings)
 265             out.append(vm_inst_creator)
 266             vm_inst_creator.initialize()
 267
 268         return out
 269
 270     def get_volume_creators(self):
 271         """
 272         Returns a list of Volume creator objects as configured by the heat
 273         template
 274         :return: list() of OpenStackVolume objects
 275         """
 276
 277         out = list()
 278         cinder = cinder_utils.cinder_client(self._os_creds)
 279
 280         volumes = heat_utils.get_stack_volumes(
 281             self.__heat_cli, cinder, self.__stack)
 282
 283         for volume in volumes:
 284             settings = settings_utils.create_volume_settings(volume)
 285             creator = OpenStackVolume(self._os_creds, settings)
 286             out.append(creator)
 287
 288             try:
 289                 creator.initialize()
 290             except Exception as e:
 291                 logger.error(
 292                     'Unexpected error initializing volume creator - %s', e)
 293
 294         return out
 295
 296     def get_volume_type_creators(self):
 297         """
 298         Returns a list of VolumeType creator objects as configured by the heat
 299         template
 300         :return: list() of OpenStackVolumeType objects
 301         """
 302
 303         out = list()
 304         cinder = cinder_utils.cinder_client(self._os_creds)
 305
 306         vol_types = heat_utils.get_stack_volume_types(
 307             self.__heat_cli, cinder, self.__stack)
 308
 309         for volume in vol_types:
 310             settings = settings_utils.create_volume_type_settings(volume)
 311             creator = OpenStackVolumeType(self._os_creds, settings)
 312             out.append(creator)
 313
 314             try:
 315                 creator.initialize()
 316             except Exception as e:
 317                 logger.error(
 318                     'Unexpected error initializing volume type creator - %s',
 319                     e)
 320
 321         return out
 322
 323     def get_keypair_creators(self, outputs_pk_key=None):
 324         """
 325         Returns a list of keypair creator objects as configured by the heat
 326         template
 327         :return: list() of OpenStackKeypair objects
 328         """
 329
 330         out = list()
 331         nova = nova_utils.nova_client(self._os_creds)
 332
 333         keypairs = heat_utils.get_stack_keypairs(
 334             self.__heat_cli, nova, self.__stack)
 335
 336         for keypair in keypairs:
 337             settings = settings_utils.create_keypair_settings(
 338                 self.__heat_cli, self.__stack, keypair, outputs_pk_key)
 339             creator = OpenStackKeypair(self._os_creds, settings)
 340             out.append(creator)
 341
 342             try:
 343                 creator.initialize()
 344             except Exception as e:
 345                 logger.error(
 346                     'Unexpected error initializing volume type creator - %s',
 347                     e)
 348
 349         return out
 350
 351     def get_flavor_creators(self):
 352         """
 353         Returns a list of Flavor creator objects as configured by the heat
 354         template
 355         :return: list() of OpenStackFlavor objects
 356         """
 357
 358         out = list()
 359         nova = nova_utils.nova_client(self._os_creds)
 360
 361         flavors = heat_utils.get_stack_flavors(
 362             self.__heat_cli, nova, self.__stack)
 363
 364         for flavor in flavors:
 365             settings = settings_utils.create_flavor_settings(flavor)
 366             creator = OpenStackFlavor(self._os_creds, settings)
 367             out.append(creator)
 368
 369             try:
 370                 creator.initialize()
 371             except Exception as e:
 372                 logger.error(
 373                     'Unexpected error initializing volume creator - %s', e)
 374
 375         return out
 376
 377     def _stack_status_check(self, expected_status_code, block, timeout,
 378                             poll_interval, fail_status):
 379         """
 380         Returns true when the stack status returns the value of
 381         expected_status_code
 382         :param expected_status_code: stack status evaluated with this string
 383                                      value
 384         :param block: When true, thread will block until active or timeout
 385                       value in seconds has been exceeded (False)
 386         :param timeout: The timeout value
 387         :param poll_interval: The polling interval in seconds
 388         :param fail_status: Returns false if the fail_status code is found
 389         :return: T/F
 390         """
 391         # sleep and wait for stack status change
 392         if block:
 393             start = time.time()
 394         else:
 395             start = time.time() - timeout
 396
 397         while timeout > time.time() - start:
 398             status = self._status(expected_status_code, fail_status)
 399             if status:
 400                 logger.debug(
 401                     'Stack is active with name - ' + self.stack_settings.name)
 402                 return True
 403
 404             logger.debug('Retry querying stack status in ' + str(
 405                 poll_interval) + ' seconds')
 406             time.sleep(poll_interval)
 407             logger.debug('Stack status query timeout in ' + str(
 408                 timeout - (time.time() - start)))
 409
 410         logger.error(
 411             'Timeout checking for stack status for ' + expected_status_code)
 412         return False
 413
 414     def _status(self, expected_status_code, fail_status=STATUS_CREATE_FAILED):
 415         """
 416         Returns True when active else False
 417         :param expected_status_code: stack status evaluated with this string
 418         value
 419         :return: T/F
 420         """
 421         status = self.get_status()
 422         if not status:
 423             logger.warning(
 424                 'Cannot stack status for stack with ID - ' + self.__stack.id)
 425             return False
 426
 427         if fail_status and status == fail_status:
 428             raise StackError('Stack had an error')
 429         logger.debug('Stack status is - ' + status)
 430         return status == expected_status_code
 431
 432
 433 class StackSettings:
 434     def __init__(self, **kwargs):
 435         """
 436         Constructor
 437         :param name: the stack's name (required)
 438         :param template: the heat template in dict() format (required if
 439                          template_path attribute is None)
 440         :param template_path: the location of the heat template file (required
 441                               if template attribute is None)
 442         :param env_values: dict() of strings for substitution of template
 443                            default values (optional)
 444         """
 445
 446         self.name = kwargs.get('name')
 447         self.template = kwargs.get('template')
 448         self.template_path = kwargs.get('template_path')
 449         self.env_values = kwargs.get('env_values')
 450         if 'stack_create_timeout' in kwargs:
 451             self.stack_create_timeout = kwargs['stack_create_timeout']
 452         else:
 453             self.stack_create_timeout = STACK_COMPLETE_TIMEOUT
 454
 455         if not self.name:
 456             raise StackSettingsError('name is required')
 457
 458         if not self.template and not self.template_path:
 459             raise StackSettingsError('A Heat template is required')
 460
 461     def __eq__(self, other):
 462         return (self.name == other.name and
 463                 self.template == other.template and
 464                 self.template_path == other.template_path and
 465                 self.env_values == other.env_values and
 466                 self.stack_create_timeout == other.stack_create_timeout)
 467
 468
 469 class StackSettingsError(Exception):
 470     """
 471     Exception to be thrown when an stack settings are incorrect
 472     """
 473
 474
 475 class StackCreationError(Exception):
 476     """
 477     Exception to be thrown when an stack cannot be created
 478     """
 479
 480
 481 class StackError(Exception):
 482     """
 483     General exception
 484     """