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, keystone_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_config(
 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
 287         nova = nova_utils.nova_client(self._os_creds)
 288         keystone = keystone_utils.keystone_client(self._os_creds)
 289         neutron = neutron_utils.neutron_client(self._os_creds)
 290         stack_servers = heat_utils.get_stack_servers(
 291             self.__heat_cli, nova, neutron, keystone, self.__stack,
 292             self._os_creds.project_name)
 293
 294         glance = glance_utils.glance_client(self._os_creds)
 295
 296         for stack_server in stack_servers:
 297             vm_inst_settings = settings_utils.create_vm_inst_config(
 298                 nova, keystone, neutron, stack_server,
 299                 self._os_creds.project_name)
 300             image_settings = settings_utils.determine_image_config(
 301                 glance, stack_server, self.image_settings)
 302             keypair_settings = settings_utils.determine_keypair_config(
 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_config(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_config(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_config(
 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_config(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,
 459                 fail_status=snaps.config.stack.STATUS_CREATE_FAILED):
 460         """
 461         Returns True when active else False
 462         :param expected_status_code: stack status evaluated with this string
 463         value
 464         :return: T/F
 465         """
 466         status = self.get_status()
 467         if not status:
 468             logger.warning(
 469                 'Cannot stack status for stack with ID - ' + self.__stack.id)
 470             return False
 471
 472         if fail_status and status == fail_status:
 473             resources = heat_utils.get_resources(
 474                 self.__heat_cli, self.__stack.id)
 475             logger.error('Stack %s failed', self.__stack.name)
 476             for resource in resources:
 477                 if (resource.status !=
 478                         snaps.config.stack.STATUS_CREATE_COMPLETE):
 479                     logger.error(
 480                         'Resource: [%s] status: [%s] reason: [%s]',
 481                         resource.name, resource.status, resource.status_reason)
 482                 else:
 483                     logger.debug(
 484                         'Resource: [%s] status: [%s] reason: [%s]',
 485                         resource.name, resource.status, resource.status_reason)
 486
 487             raise StackError('Stack had an error')
 488         logger.debug('Stack status is - ' + status)
 489         return status == expected_status_code
 490
 491
 492 class StackSettings(StackConfig):
 493     """
 494     Class to hold the configuration settings required for creating OpenStack
 495     stack objects
 496     deprecated
 497     """
 498
 499     def __init__(self, **kwargs):
 500         from warnings import warn
 501         warn('Use snaps.config.stack.StackConfig instead',
 502              DeprecationWarning)
 503         super(self.__class__, self).__init__(**kwargs)
 504
 505
 506 class StackCreationError(Exception):
 507     """
 508     Exception to be thrown when an stack cannot be created
 509     """
 510
 511
 512 class StackError(Exception):
 513     """
 514     General exception
 515     """