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_security_group import OpenStackSecurityGroup
  25 from snaps.openstack.create_router import OpenStackRouter
  26 from snaps.openstack.create_volume import OpenStackVolume
  27 from snaps.openstack.create_volume_type import OpenStackVolumeType
  28 from snaps.openstack.openstack_creator import OpenStackCloudObject
  29 from snaps.openstack.utils import (
  30     nova_utils, settings_utils, glance_utils, cinder_utils)
  31
  32 from snaps.openstack.create_network import OpenStackNetwork
  33 from snaps.openstack.utils import heat_utils, neutron_utils
  34
  35 __author__ = 'spisarski'
  36
  37 logger = logging.getLogger('create_stack')
  38
  39 STACK_DELETE_TIMEOUT = 1200
  40 STACK_COMPLETE_TIMEOUT = 1200
  41 POLL_INTERVAL = 3
  42 STATUS_CREATE_FAILED = 'CREATE_FAILED'
  43 STATUS_CREATE_COMPLETE = 'CREATE_COMPLETE'
  44 STATUS_DELETE_COMPLETE = 'DELETE_COMPLETE'
  45 STATUS_DELETE_FAILED = 'DELETE_FAILED'
  46
  47
  48 class OpenStackHeatStack(OpenStackCloudObject, object):
  49     """
  50     Class responsible for managing a heat stack in OpenStack
  51     """
  52
  53     def __init__(self, os_creds, stack_settings, image_settings=None,
  54                  keypair_settings=None):
  55         """
  56         Constructor
  57         :param os_creds: The OpenStack connection credentials
  58         :param stack_settings: The stack settings
  59         :param image_settings: A list of ImageConfig 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_security_group_creators(self):
 238         """
 239         Returns a list of security group creator objects as configured by the
 240         heat template
 241         :return: list() of OpenStackNetwork objects
 242         """
 243
 244         neutron = neutron_utils.neutron_client(self._os_creds)
 245
 246         out = list()
 247         stack_security_groups = heat_utils.get_stack_security_groups(
 248             self.__heat_cli, neutron, self.__stack)
 249
 250         for stack_security_group in stack_security_groups:
 251             settings = settings_utils.create_security_group_settings(
 252                 neutron, stack_security_group)
 253             creator = OpenStackSecurityGroup(self._os_creds, settings)
 254             out.append(creator)
 255             creator.initialize()
 256
 257         return out
 258
 259     def get_router_creators(self):
 260         """
 261         Returns a list of router creator objects as configured by the heat
 262         template
 263         :return: list() of OpenStackRouter objects
 264         """
 265
 266         neutron = neutron_utils.neutron_client(self._os_creds)
 267
 268         out = list()
 269         stack_routers = heat_utils.get_stack_routers(
 270             self.__heat_cli, neutron, self.__stack)
 271
 272         for routers in stack_routers:
 273             settings = settings_utils.create_router_settings(
 274                 neutron, routers)
 275             creator = OpenStackRouter(self._os_creds, settings)
 276             out.append(creator)
 277             creator.initialize()
 278
 279         return out
 280
 281     def get_vm_inst_creators(self, heat_keypair_option=None):
 282         """
 283         Returns a list of VM Instance creator objects as configured by the heat
 284         template
 285         :return: list() of OpenStackVmInstance objects
 286         """
 287
 288         out = list()
 289         nova = nova_utils.nova_client(self._os_creds)
 290
 291         stack_servers = heat_utils.get_stack_servers(
 292             self.__heat_cli, nova, self.__stack)
 293
 294         neutron = neutron_utils.neutron_client(self._os_creds)
 295         glance = glance_utils.glance_client(self._os_creds)
 296
 297         for stack_server in stack_servers:
 298             vm_inst_settings = settings_utils.create_vm_inst_settings(
 299                 nova, neutron, stack_server)
 300             image_settings = settings_utils.determine_image_config(
 301                 glance, stack_server, self.image_settings)
 302             keypair_settings = settings_utils.determine_keypair_settings(
 303                 self.__heat_cli, self.__stack, stack_server,
 304                 keypair_settings=self.keypair_settings,
 305                 priv_key_key=heat_keypair_option)
 306             vm_inst_creator = OpenStackVmInstance(
 307                 self._os_creds, vm_inst_settings, image_settings,
 308                 keypair_settings)
 309             out.append(vm_inst_creator)
 310             vm_inst_creator.initialize()
 311
 312         return out
 313
 314     def get_volume_creators(self):
 315         """
 316         Returns a list of Volume creator objects as configured by the heat
 317         template
 318         :return: list() of OpenStackVolume objects
 319         """
 320
 321         out = list()
 322         cinder = cinder_utils.cinder_client(self._os_creds)
 323
 324         volumes = heat_utils.get_stack_volumes(
 325             self.__heat_cli, cinder, self.__stack)
 326
 327         for volume in volumes:
 328             settings = settings_utils.create_volume_settings(volume)
 329             creator = OpenStackVolume(self._os_creds, settings)
 330             out.append(creator)
 331
 332             try:
 333                 creator.initialize()
 334             except Exception as e:
 335                 logger.error(
 336                     'Unexpected error initializing volume creator - %s', e)
 337
 338         return out
 339
 340     def get_volume_type_creators(self):
 341         """
 342         Returns a list of VolumeType creator objects as configured by the heat
 343         template
 344         :return: list() of OpenStackVolumeType objects
 345         """
 346
 347         out = list()
 348         cinder = cinder_utils.cinder_client(self._os_creds)
 349
 350         vol_types = heat_utils.get_stack_volume_types(
 351             self.__heat_cli, cinder, self.__stack)
 352
 353         for volume in vol_types:
 354             settings = settings_utils.create_volume_type_settings(volume)
 355             creator = OpenStackVolumeType(self._os_creds, settings)
 356             out.append(creator)
 357
 358             try:
 359                 creator.initialize()
 360             except Exception as e:
 361                 logger.error(
 362                     'Unexpected error initializing volume type creator - %s',
 363                     e)
 364
 365         return out
 366
 367     def get_keypair_creators(self, outputs_pk_key=None):
 368         """
 369         Returns a list of keypair creator objects as configured by the heat
 370         template
 371         :return: list() of OpenStackKeypair objects
 372         """
 373
 374         out = list()
 375         nova = nova_utils.nova_client(self._os_creds)
 376
 377         keypairs = heat_utils.get_stack_keypairs(
 378             self.__heat_cli, nova, self.__stack)
 379
 380         for keypair in keypairs:
 381             settings = settings_utils.create_keypair_settings(
 382                 self.__heat_cli, self.__stack, keypair, outputs_pk_key)
 383             creator = OpenStackKeypair(self._os_creds, settings)
 384             out.append(creator)
 385
 386             try:
 387                 creator.initialize()
 388             except Exception as e:
 389                 logger.error(
 390                     'Unexpected error initializing volume type creator - %s',
 391                     e)
 392
 393         return out
 394
 395     def get_flavor_creators(self):
 396         """
 397         Returns a list of Flavor creator objects as configured by the heat
 398         template
 399         :return: list() of OpenStackFlavor objects
 400         """
 401
 402         out = list()
 403         nova = nova_utils.nova_client(self._os_creds)
 404
 405         flavors = heat_utils.get_stack_flavors(
 406             self.__heat_cli, nova, self.__stack)
 407
 408         for flavor in flavors:
 409             settings = settings_utils.create_flavor_settings(flavor)
 410             creator = OpenStackFlavor(self._os_creds, settings)
 411             out.append(creator)
 412
 413             try:
 414                 creator.initialize()
 415             except Exception as e:
 416                 logger.error(
 417                     'Unexpected error initializing volume creator - %s', e)
 418
 419         return out
 420
 421     def _stack_status_check(self, expected_status_code, block, timeout,
 422                             poll_interval, fail_status):
 423         """
 424         Returns true when the stack status returns the value of
 425         expected_status_code
 426         :param expected_status_code: stack status evaluated with this string
 427                                      value
 428         :param block: When true, thread will block until active or timeout
 429                       value in seconds has been exceeded (False)
 430         :param timeout: The timeout value
 431         :param poll_interval: The polling interval in seconds
 432         :param fail_status: Returns false if the fail_status code is found
 433         :return: T/F
 434         """
 435         # sleep and wait for stack status change
 436         if block:
 437             start = time.time()
 438         else:
 439             start = time.time() - timeout
 440
 441         while timeout > time.time() - start:
 442             status = self._status(expected_status_code, fail_status)
 443             if status:
 444                 logger.debug(
 445                     'Stack is active with name - ' + self.stack_settings.name)
 446                 return True
 447
 448             logger.debug('Retry querying stack status in ' + str(
 449                 poll_interval) + ' seconds')
 450             time.sleep(poll_interval)
 451             logger.debug('Stack status query timeout in ' + str(
 452                 timeout - (time.time() - start)))
 453
 454         logger.error(
 455             'Timeout checking for stack status for ' + expected_status_code)
 456         return False
 457
 458     def _status(self, expected_status_code, fail_status=STATUS_CREATE_FAILED):
 459         """
 460         Returns True when active else False
 461         :param expected_status_code: stack status evaluated with this string
 462         value
 463         :return: T/F
 464         """
 465         status = self.get_status()
 466         if not status:
 467             logger.warning(
 468                 'Cannot stack status for stack with ID - ' + self.__stack.id)
 469             return False
 470
 471         if fail_status and status == fail_status:
 472             resources = heat_utils.get_resources(self.__heat_cli, self.__stack)
 473             logger.error('Stack %s failed', self.__stack.name)
 474             for resource in resources:
 475                 if resource.status != STATUS_CREATE_COMPLETE:
 476                     logger.error(
 477                         'Resource: [%s] status: [%s] reason: [%s]',
 478                         resource.name, resource.status, resource.status_reason)
 479                 else:
 480                     logger.debug(
 481                         'Resource: [%s] status: [%s] reason: [%s]',
 482                         resource.name, resource.status, resource.status_reason)
 483
 484             raise StackError('Stack had an error')
 485         logger.debug('Stack status is - ' + status)
 486         return status == expected_status_code
 487
 488
 489 class StackSettings:
 490     def __init__(self, **kwargs):
 491         """
 492         Constructor
 493         :param name: the stack's name (required)
 494         :param template: the heat template in dict() format (required if
 495                          template_path attribute is None)
 496         :param template_path: the location of the heat template file (required
 497                               if template attribute is None)
 498         :param env_values: dict() of strings for substitution of template
 499                            default values (optional)
 500         """
 501
 502         self.name = kwargs.get('name')
 503         self.template = kwargs.get('template')
 504         self.template_path = kwargs.get('template_path')
 505         self.env_values = kwargs.get('env_values')
 506         if 'stack_create_timeout' in kwargs:
 507             self.stack_create_timeout = kwargs['stack_create_timeout']
 508         else:
 509             self.stack_create_timeout = STACK_COMPLETE_TIMEOUT
 510
 511         if not self.name:
 512             raise StackSettingsError('name is required')
 513
 514         if not self.template and not self.template_path:
 515             raise StackSettingsError('A Heat template is required')
 516
 517     def __eq__(self, other):
 518         return (self.name == other.name and
 519                 self.template == other.template and
 520                 self.template_path == other.template_path and
 521                 self.env_values == other.env_values and
 522                 self.stack_create_timeout == other.stack_create_timeout)
 523
 524
 525 class StackSettingsError(Exception):
 526     """
 527     Exception to be thrown when an stack settings are incorrect
 528     """
 529
 530
 531 class StackCreationError(Exception):
 532     """
 533     Exception to be thrown when an stack cannot be created
 534     """
 535
 536
 537 class StackError(Exception):
 538     """
 539     General exception
 540     """