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         if self.__stack:
 162             return heat_utils.get_stack_by_id(self.__heat_cli, self.__stack.id)
 163
 164     def get_outputs(self):
 165         """
 166         Returns the list of outputs as contained on the OpenStack Heat Stack
 167         object
 168         :return:
 169         """
 170         return heat_utils.get_outputs(self.__heat_cli, self.__stack)
 171
 172     def get_status(self):
 173         """
 174         Returns the list of outputs as contained on the OpenStack Heat Stack
 175         object
 176         :return:
 177         """
 178         stack = self.get_stack()
 179         if stack:
 180             return stack.status
 181
 182     def stack_complete(self, block=False, timeout=None,
 183                        poll_interval=snaps.config.stack.POLL_INTERVAL):
 184         """
 185         Returns true when the stack status returns the value of
 186         expected_status_code
 187         :param block: When true, thread will block until active or timeout
 188                       value in seconds has been exceeded (False)
 189         :param timeout: The timeout value
 190         :param poll_interval: The polling interval in seconds
 191         :return: T/F
 192         """
 193         if not timeout:
 194             timeout = self.stack_settings.stack_create_timeout
 195         return self._stack_status_check(
 196             snaps.config.stack.STATUS_CREATE_COMPLETE, block, timeout,
 197             poll_interval, snaps.config.stack.STATUS_CREATE_FAILED)
 198
 199     def stack_deleted(self, block=False,
 200                       timeout=snaps.config.stack.STACK_DELETE_TIMEOUT,
 201                       poll_interval=snaps.config.stack.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(
 212             snaps.config.stack.STATUS_DELETE_COMPLETE, block, timeout,
 213             poll_interval, snaps.config.stack.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_config(
 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_config(
 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_config(
 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
 290         nova = nova_utils.nova_client(self._os_creds)
 291         keystone = keystone_utils.keystone_client(self._os_creds)
 292         neutron = neutron_utils.neutron_client(self._os_creds)
 293         stack_servers = heat_utils.get_stack_servers(
 294             self.__heat_cli, nova, neutron, keystone, self.__stack,
 295             self._os_creds.project_name)
 296
 297         glance = glance_utils.glance_client(self._os_creds)
 298
 299         for stack_server in stack_servers:
 300             vm_inst_settings = settings_utils.create_vm_inst_config(
 301                 nova, keystone, neutron, stack_server,
 302                 self._os_creds.project_name)
 303             image_settings = settings_utils.determine_image_config(
 304                 glance, stack_server, self.image_settings)
 305             keypair_settings = settings_utils.determine_keypair_config(
 306                 self.__heat_cli, self.__stack, stack_server,
 307                 keypair_settings=self.keypair_settings,
 308                 priv_key_key=heat_keypair_option)
 309             vm_inst_creator = OpenStackVmInstance(
 310                 self._os_creds, vm_inst_settings, image_settings,
 311                 keypair_settings)
 312             out.append(vm_inst_creator)
 313             vm_inst_creator.initialize()
 314
 315         return out
 316
 317     def get_volume_creators(self):
 318         """
 319         Returns a list of Volume creator objects as configured by the heat
 320         template
 321         :return: list() of OpenStackVolume objects
 322         """
 323
 324         out = list()
 325         cinder = cinder_utils.cinder_client(self._os_creds)
 326
 327         volumes = heat_utils.get_stack_volumes(
 328             self.__heat_cli, cinder, self.__stack)
 329
 330         for volume in volumes:
 331             settings = settings_utils.create_volume_config(volume)
 332             creator = OpenStackVolume(self._os_creds, settings)
 333             out.append(creator)
 334
 335             try:
 336                 creator.initialize()
 337             except Exception as e:
 338                 logger.error(
 339                     'Unexpected error initializing volume creator - %s', e)
 340
 341         return out
 342
 343     def get_volume_type_creators(self):
 344         """
 345         Returns a list of VolumeType creator objects as configured by the heat
 346         template
 347         :return: list() of OpenStackVolumeType objects
 348         """
 349
 350         out = list()
 351         cinder = cinder_utils.cinder_client(self._os_creds)
 352
 353         vol_types = heat_utils.get_stack_volume_types(
 354             self.__heat_cli, cinder, self.__stack)
 355
 356         for volume in vol_types:
 357             settings = settings_utils.create_volume_type_config(volume)
 358             creator = OpenStackVolumeType(self._os_creds, settings)
 359             out.append(creator)
 360
 361             try:
 362                 creator.initialize()
 363             except Exception as e:
 364                 logger.error(
 365                     'Unexpected error initializing volume type creator - %s',
 366                     e)
 367
 368         return out
 369
 370     def get_keypair_creators(self, outputs_pk_key=None):
 371         """
 372         Returns a list of keypair creator objects as configured by the heat
 373         template
 374         :return: list() of OpenStackKeypair objects
 375         """
 376
 377         out = list()
 378         nova = nova_utils.nova_client(self._os_creds)
 379
 380         keypairs = heat_utils.get_stack_keypairs(
 381             self.__heat_cli, nova, self.__stack)
 382
 383         for keypair in keypairs:
 384             settings = settings_utils.create_keypair_config(
 385                 self.__heat_cli, self.__stack, keypair, outputs_pk_key)
 386             creator = OpenStackKeypair(self._os_creds, settings)
 387             out.append(creator)
 388
 389             try:
 390                 creator.initialize()
 391             except Exception as e:
 392                 logger.error(
 393                     'Unexpected error initializing volume type creator - %s',
 394                     e)
 395
 396         return out
 397
 398     def get_flavor_creators(self):
 399         """
 400         Returns a list of Flavor creator objects as configured by the heat
 401         template
 402         :return: list() of OpenStackFlavor objects
 403         """
 404
 405         out = list()
 406         nova = nova_utils.nova_client(self._os_creds)
 407
 408         flavors = heat_utils.get_stack_flavors(
 409             self.__heat_cli, nova, self.__stack)
 410
 411         for flavor in flavors:
 412             settings = settings_utils.create_flavor_config(flavor)
 413             creator = OpenStackFlavor(self._os_creds, settings)
 414             out.append(creator)
 415
 416             try:
 417                 creator.initialize()
 418             except Exception as e:
 419                 logger.error(
 420                     'Unexpected error initializing volume creator - %s', e)
 421
 422         return out
 423
 424     def _stack_status_check(self, expected_status_code, block, timeout,
 425                             poll_interval, fail_status):
 426         """
 427         Returns true when the stack status returns the value of
 428         expected_status_code
 429         :param expected_status_code: stack status evaluated with this string
 430                                      value
 431         :param block: When true, thread will block until active or timeout
 432                       value in seconds has been exceeded (False)
 433         :param timeout: The timeout value
 434         :param poll_interval: The polling interval in seconds
 435         :param fail_status: Returns false if the fail_status code is found
 436         :return: T/F
 437         """
 438         # sleep and wait for stack status change
 439         if block:
 440             start = time.time()
 441         else:
 442             start = time.time() - timeout
 443
 444         while timeout > time.time() - start:
 445             status = self._status(expected_status_code, fail_status)
 446             if status:
 447                 logger.debug(
 448                     'Stack is active with name - ' + self.stack_settings.name)
 449                 return True
 450
 451             logger.debug('Retry querying stack status in ' + str(
 452                 poll_interval) + ' seconds')
 453             time.sleep(poll_interval)
 454             logger.debug('Stack status query timeout in ' + str(
 455                 timeout - (time.time() - start)))
 456
 457         logger.error(
 458             'Timeout checking for stack status for ' + expected_status_code)
 459         return False
 460
 461     def _status(self, expected_status_code,
 462                 fail_status=snaps.config.stack.STATUS_CREATE_FAILED):
 463         """
 464         Returns True when active else False
 465         :param expected_status_code: stack status evaluated with this string
 466         value
 467         :return: T/F
 468         """
 469         status = self.get_status()
 470         if not status:
 471             logger.warning(
 472                 'Cannot stack status for stack with ID - ' + self.__stack.id)
 473             return False
 474
 475         if fail_status and status == fail_status:
 476             resources = heat_utils.get_resources(
 477                 self.__heat_cli, self.__stack.id)
 478             logger.error('Stack %s failed', self.__stack.name)
 479             for resource in resources:
 480                 if (resource.status !=
 481                         snaps.config.stack.STATUS_CREATE_COMPLETE):
 482                     logger.error(
 483                         'Resource: [%s] status: [%s] reason: [%s]',
 484                         resource.name, resource.status, resource.status_reason)
 485                 else:
 486                     logger.debug(
 487                         'Resource: [%s] status: [%s] reason: [%s]',
 488                         resource.name, resource.status, resource.status_reason)
 489
 490             raise StackError('Stack had an error')
 491         logger.debug('Stack status is - ' + status)
 492         return status == expected_status_code
 493
 494
 495 class StackSettings(StackConfig):
 496     """
 497     Class to hold the configuration settings required for creating OpenStack
 498     stack objects
 499     deprecated
 500     """
 501
 502     def __init__(self, **kwargs):
 503         from warnings import warn
 504         warn('Use snaps.config.stack.StackConfig instead',
 505              DeprecationWarning)
 506         super(self.__class__, self).__init__(**kwargs)
 507
 508
 509 class StackCreationError(Exception):
 510     """
 511     Exception to be thrown when an stack cannot be created
 512     """
 513
 514
 515 class StackError(Exception):
 516     """
 517     General exception
 518     """