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