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