yardstick/orchestrator/heat.py

   1 #############################################################################
   2 # Copyright (c) 2015-2017 Ericsson AB and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10 """Heat template and stack management"""
  11
  12 from __future__ import absolute_import
  13 from __future__ import print_function
  14 from six.moves import range
  15
  16 import collections
  17 import datetime
  18 import getpass
  19 import logging
  20
  21 import socket
  22 import time
  23
  24 import heatclient
  25 import pkg_resources
  26
  27 from oslo_utils import encodeutils
  28
  29 import yardstick.common.openstack_utils as op_utils
  30 from yardstick.common import template_format
  31
  32 log = logging.getLogger(__name__)
  33
  34
  35 HEAT_KEY_UUID_LENGTH = 8
  36
  37 PROVIDER_SRIOV = "sriov"
  38
  39
  40 def get_short_key_uuid(uuid):
  41     return str(uuid)[:HEAT_KEY_UUID_LENGTH]
  42
  43
  44 class HeatObject(object):
  45     """base class for template and stack"""
  46
  47     def __init__(self):
  48         self._heat_client = None
  49         self.uuid = None
  50
  51     @property
  52     def heat_client(self):
  53         """returns a heat client instance"""
  54
  55         if self._heat_client is None:
  56             sess = op_utils.get_session()
  57             heat_endpoint = op_utils.get_endpoint(service_type='orchestration')
  58             self._heat_client = heatclient.client.Client(
  59                 op_utils.get_heat_api_version(),
  60                 endpoint=heat_endpoint, session=sess)
  61
  62         return self._heat_client
  63
  64     def status(self):
  65         """returns stack state as a string"""
  66         heat_client = self.heat_client
  67         stack = heat_client.stacks.get(self.uuid)
  68         return stack.stack_status
  69
  70
  71 class HeatStack(HeatObject):
  72     """Represents a Heat stack (deployed template) """
  73     stacks = []
  74
  75     def __init__(self, name):
  76         super(HeatStack, self).__init__()
  77         self.uuid = None
  78         self.name = name
  79         self.outputs = None
  80         HeatStack.stacks.append(self)
  81
  82     @staticmethod
  83     def stacks_exist():
  84         """check if any stack has been deployed"""
  85         return len(HeatStack.stacks) > 0
  86
  87     def _delete(self):
  88         """deletes a stack from the target cloud using heat"""
  89         if self.uuid is None:
  90             return
  91
  92         log.info("Deleting stack '%s', uuid:%s", self.name, self.uuid)
  93         heat = self.heat_client
  94         template = heat.stacks.get(self.uuid)
  95         start_time = time.time()
  96         template.delete()
  97
  98         for status in iter(self.status, u'DELETE_COMPLETE'):
  99             log.debug("stack state %s", status)
 100             if status == u'DELETE_FAILED':
 101                 raise RuntimeError(
 102                     heat.stacks.get(self.uuid).stack_status_reason)
 103
 104             time.sleep(2)
 105
 106         end_time = time.time()
 107         log.info("Deleted stack '%s' in %d secs", self.name,
 108                  end_time - start_time)
 109         self.uuid = None
 110
 111     def delete(self, block=True, retries=3):
 112         """deletes a stack in the target cloud using heat (with retry)
 113         Sometimes delete fail with "InternalServerError" and the next attempt
 114         succeeds. So it is worthwhile to test a couple of times.
 115         """
 116         if self.uuid is None:
 117             return
 118
 119         if not block:
 120             self._delete()
 121             return
 122
 123         for _ in range(retries):
 124             try:
 125                 self._delete()
 126                 break
 127             except RuntimeError as err:
 128                 log.warning(err.args)
 129                 time.sleep(2)
 130
 131         # if still not deleted try once more and let it fail everything
 132         if self.uuid is not None:
 133             self._delete()
 134
 135         HeatStack.stacks.remove(self)
 136
 137     @staticmethod
 138     def delete_all():
 139         for stack in HeatStack.stacks[:]:
 140             stack.delete()
 141
 142     def update(self):
 143         """update a stack"""
 144         raise RuntimeError("not implemented")
 145
 146
 147 class HeatTemplate(HeatObject):
 148     """Describes a Heat template and a method to deploy template to a stack"""
 149
 150     DESCRIPTION_TEMPLATE = """\
 151 Stack built by the yardstick framework for %s on host %s %s.
 152 All referred generated resources are prefixed with the template
 153 name (i.e. %s).\
 154 """
 155
 156     def _init_template(self):
 157         timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 158         self._template = {
 159             'heat_template_version': '2013-05-23',
 160             'description': self.DESCRIPTION_TEMPLATE % (
 161                 getpass.getuser(),
 162                 socket.gethostname(),
 163                 timestamp,
 164                 self.name
 165             ),
 166             'resources': {},
 167             'outputs': {}
 168         }
 169
 170         # short hand for resources part of template
 171         self.resources = self._template['resources']
 172
 173     def __init__(self, name, template_file=None, heat_parameters=None):
 174         super(HeatTemplate, self).__init__()
 175         self.name = name
 176         self.state = "NOT_CREATED"
 177         self.keystone_client = None
 178         self.heat_parameters = {}
 179
 180         # heat_parameters is passed to heat in stack create, empty dict when
 181         # yardstick creates the template (no get_param in resources part)
 182         if heat_parameters:
 183             self.heat_parameters = heat_parameters
 184
 185         if template_file:
 186             with open(template_file) as stream:
 187                 print("Parsing external template:", template_file)
 188                 template_str = stream.read()
 189             self._template = template_format.parse(template_str)
 190             self._parameters = heat_parameters
 191         else:
 192             self._init_template()
 193
 194         # holds results of requested output after deployment
 195         self.outputs = {}
 196
 197         log.debug("template object '%s' created", name)
 198
 199     def add_flavor(self, name, vcpus=1, ram=1024, disk=1, ephemeral=0,
 200                    is_public=True, rxtx_factor=1.0, swap=0,
 201                    extra_specs=None):
 202         """add to the template a Flavor description"""
 203         if name is None:
 204             name = 'auto'
 205         log.debug("adding Nova::Flavor '%s' vcpus '%d' ram '%d' disk '%d' " +
 206                   "ephemeral '%d' is_public '%s' rxtx_factor '%d' " +
 207                   "swap '%d' extra_specs '%s' ",
 208                   name, vcpus, ram, disk, ephemeral, is_public,
 209                   rxtx_factor, swap, str(extra_specs))
 210
 211         if extra_specs:
 212             assert isinstance(extra_specs, collections.Mapping)
 213
 214         self.resources[name] = {
 215             'type': 'OS::Nova::Flavor',
 216             'properties': {'name': name,
 217                            'disk': disk,
 218                            'vcpus': vcpus,
 219                            'swap': swap,
 220                            'flavorid': name,
 221                            'rxtx_factor': rxtx_factor,
 222                            'ram': ram,
 223                            'is_public': is_public,
 224                            'ephemeral': ephemeral,
 225                            'extra_specs': extra_specs}
 226         }
 227
 228         self._template['outputs'][name] = {
 229             'description': 'Flavor %s ID' % name,
 230             'value': {'get_resource': name}
 231         }
 232
 233     def add_network(self, name, physical_network='physnet1', provider=None,
 234                     segmentation_id=None, port_security_enabled=True):
 235         """add to the template a Neutron Net"""
 236         log.debug("adding Neutron::Net '%s'", name)
 237         if provider is None:
 238             self.resources[name] = {
 239                 'type': 'OS::Neutron::Net',
 240                 'properties': {
 241                     'name': name,
 242                     'port_security_enabled': port_security_enabled,
 243                 }
 244             }
 245         else:
 246             self.resources[name] = {
 247                 'type': 'OS::Neutron::ProviderNet',
 248                 'properties': {
 249                     'name': name,
 250                     'network_type': 'vlan',
 251                     'physical_network': physical_network,
 252                     'port_security_enabled': port_security_enabled,
 253                 },
 254             }
 255             if segmentation_id:
 256                 self.resources[name]['properties']['segmentation_id'] = segmentation_id
 257
 258     def add_server_group(self, name, policies):     # pragma: no cover
 259         """add to the template a ServerGroup"""
 260         log.debug("adding Nova::ServerGroup '%s'", name)
 261         policies = policies if isinstance(policies, list) else [policies]
 262         self.resources[name] = {
 263             'type': 'OS::Nova::ServerGroup',
 264             'properties': {'name': name,
 265                            'policies': policies}
 266         }
 267
 268     def add_subnet(self, name, network, cidr, enable_dhcp='true', gateway_ip=None):
 269         """add to the template a Neutron Subnet
 270         """
 271         log.debug("adding Neutron::Subnet '%s' in network '%s', cidr '%s'",
 272                   name, network, cidr)
 273         self.resources[name] = {
 274             'type': 'OS::Neutron::Subnet',
 275             'depends_on': network,
 276             'properties': {
 277                 'name': name,
 278                 'cidr': cidr,
 279                 'network_id': {'get_resource': network},
 280                 'enable_dhcp': enable_dhcp,
 281             }
 282         }
 283         if gateway_ip is not None:
 284             self.resources[name]['properties']['gateway_ip'] = gateway_ip
 285
 286         self._template['outputs'][name] = {
 287             'description': 'subnet %s ID' % name,
 288             'value': {'get_resource': name}
 289         }
 290         self._template['outputs'][name + "-cidr"] = {
 291             'description': 'subnet %s cidr' % name,
 292             'value': {'get_attr': [name, 'cidr']}
 293         }
 294         self._template['outputs'][name + "-gateway_ip"] = {
 295             'description': 'subnet %s gateway_ip' % name,
 296             'value': {'get_attr': [name, 'gateway_ip']}
 297         }
 298
 299     def add_router(self, name, ext_gw_net, subnet_name):
 300         """add to the template a Neutron Router and interface"""
 301         log.debug("adding Neutron::Router:'%s', gw-net:'%s'", name, ext_gw_net)
 302         self.resources[name] = {
 303             'type': 'OS::Neutron::Router',
 304             'depends_on': [subnet_name],
 305             'properties': {
 306                 'name': name,
 307                 'external_gateway_info': {
 308                     'network': ext_gw_net
 309                 }
 310             }
 311         }
 312
 313     def add_router_interface(self, name, router_name, subnet_name):
 314         """add to the template a Neutron RouterInterface and interface"""
 315         log.debug("adding Neutron::RouterInterface '%s' router:'%s', "
 316                   "subnet:'%s'", name, router_name, subnet_name)
 317         self.resources[name] = {
 318             'type': 'OS::Neutron::RouterInterface',
 319             'depends_on': [router_name, subnet_name],
 320             'properties': {
 321                 'router_id': {'get_resource': router_name},
 322                 'subnet_id': {'get_resource': subnet_name}
 323             }
 324         }
 325
 326     def add_port(self, name, network_name, subnet_name, sec_group_id=None, provider=None,
 327                  allowed_address_pairs=None):
 328         """add to the template a named Neutron Port
 329         """
 330         log.debug("adding Neutron::Port '%s', network:'%s', subnet:'%s', "
 331                   "secgroup:%s", name, network_name, subnet_name, sec_group_id)
 332         self.resources[name] = {
 333             'type': 'OS::Neutron::Port',
 334             'depends_on': [subnet_name],
 335             'properties': {
 336                 'name': name,
 337                 'fixed_ips': [{'subnet': {'get_resource': subnet_name}}],
 338                 'network_id': {'get_resource': network_name},
 339                 'replacement_policy': 'AUTO',
 340             }
 341         }
 342
 343         if provider == PROVIDER_SRIOV:
 344             self.resources[name]['properties']['binding:vnic_type'] = \
 345                 'direct'
 346
 347         if sec_group_id:
 348             self.resources[name]['depends_on'].append(sec_group_id)
 349             self.resources[name]['properties']['security_groups'] = \
 350                 [sec_group_id]
 351
 352         if allowed_address_pairs:
 353             self.resources[name]['properties'][
 354                 'allowed_address_pairs'] = allowed_address_pairs
 355
 356         self._template['outputs'][name] = {
 357             'description': 'Address for interface %s' % name,
 358             'value': {'get_attr': [name, 'fixed_ips', 0, 'ip_address']}
 359         }
 360         self._template['outputs'][name + "-subnet_id"] = {
 361             'description': 'Address for interface %s' % name,
 362             'value': {'get_attr': [name, 'fixed_ips', 0, 'subnet_id']}
 363         }
 364         self._template['outputs'][name + "-mac_address"] = {
 365             'description': 'MAC Address for interface %s' % name,
 366             'value': {'get_attr': [name, 'mac_address']}
 367         }
 368         self._template['outputs'][name + "-device_id"] = {
 369             'description': 'Device ID for interface %s' % name,
 370             'value': {'get_attr': [name, 'device_id']}
 371         }
 372         self._template['outputs'][name + "-network_id"] = {
 373             'description': 'Network ID for interface %s' % name,
 374             'value': {'get_attr': [name, 'network_id']}
 375         }
 376
 377     def add_floating_ip(self, name, network_name, port_name, router_if_name,
 378                         secgroup_name=None):
 379         """add to the template a Nova FloatingIP resource
 380         see: https://bugs.launchpad.net/heat/+bug/1299259
 381         """
 382         log.debug("adding Nova::FloatingIP '%s', network '%s', port '%s', "
 383                   "rif '%s'", name, network_name, port_name, router_if_name)
 384
 385         self.resources[name] = {
 386             'type': 'OS::Nova::FloatingIP',
 387             'depends_on': [port_name, router_if_name],
 388             'properties': {
 389                 'pool': network_name
 390             }
 391         }
 392
 393         if secgroup_name:
 394             self.resources[name]["depends_on"].append(secgroup_name)
 395
 396         self._template['outputs'][name] = {
 397             'description': 'floating ip %s' % name,
 398             'value': {'get_attr': [name, 'ip']}
 399         }
 400
 401     def add_floating_ip_association(self, name, floating_ip_name, port_name):
 402         """add to the template a Nova FloatingIP Association resource
 403         """
 404         log.debug("adding Nova::FloatingIPAssociation '%s', server '%s', "
 405                   "floating_ip '%s'", name, port_name, floating_ip_name)
 406
 407         self.resources[name] = {
 408             'type': 'OS::Neutron::FloatingIPAssociation',
 409             'depends_on': [port_name],
 410             'properties': {
 411                 'floatingip_id': {'get_resource': floating_ip_name},
 412                 'port_id': {'get_resource': port_name}
 413             }
 414         }
 415
 416     def add_keypair(self, name, key_uuid):
 417         """add to the template a Nova KeyPair"""
 418         log.debug("adding Nova::KeyPair '%s'", name)
 419         self.resources[name] = {
 420             'type': 'OS::Nova::KeyPair',
 421             'properties': {
 422                 'name': name,
 423                 # resource_string returns bytes, so we must decode to unicode
 424                 'public_key': encodeutils.safe_decode(
 425                     pkg_resources.resource_string(
 426                         'yardstick.resources',
 427                         'files/yardstick_key-' +
 428                         get_short_key_uuid(key_uuid) + '.pub'),
 429                     'utf-8')
 430             }
 431         }
 432
 433     def add_servergroup(self, name, policy):
 434         """add to the template a Nova ServerGroup"""
 435         log.debug("adding Nova::ServerGroup '%s', policy '%s'", name, policy)
 436         if policy not in ["anti-affinity", "affinity"]:
 437             raise ValueError(policy)
 438
 439         self.resources[name] = {
 440             'type': 'OS::Nova::ServerGroup',
 441             'properties': {
 442                 'name': name,
 443                 'policies': [policy]
 444             }
 445         }
 446
 447         self._template['outputs'][name] = {
 448             'description': 'ID Server Group %s' % name,
 449             'value': {'get_resource': name}
 450         }
 451
 452     def add_security_group(self, name):
 453         """add to the template a Neutron SecurityGroup"""
 454         log.debug("adding Neutron::SecurityGroup '%s'", name)
 455         self.resources[name] = {
 456             'type': 'OS::Neutron::SecurityGroup',
 457             'properties': {
 458                 'name': name,
 459                 'description': "Group allowing icmp and upd/tcp on all ports",
 460                 'rules': [
 461                     {'remote_ip_prefix': '0.0.0.0/0',
 462                      'protocol': 'tcp',
 463                      'port_range_min': '1',
 464                      'port_range_max': '65535'},
 465                     {'remote_ip_prefix': '0.0.0.0/0',
 466                      'protocol': 'udp',
 467                      'port_range_min': '1',
 468                      'port_range_max': '65535'},
 469                     {'remote_ip_prefix': '0.0.0.0/0',
 470                      'protocol': 'icmp'}
 471                 ]
 472             }
 473         }
 474
 475         self._template['outputs'][name] = {
 476             'description': 'ID of Security Group',
 477             'value': {'get_resource': name}
 478         }
 479
 480     def add_server(self, name, image, flavor, flavors, ports=None,
 481                    networks=None, scheduler_hints=None, user=None,
 482                    key_name=None, user_data=None, metadata=None,
 483                    additional_properties=None):
 484         """add to the template a Nova Server"""
 485         log.debug("adding Nova::Server '%s', image '%s', flavor '%s', "
 486                   "ports %s", name, image, flavor, ports)
 487
 488         self.resources[name] = {
 489             'type': 'OS::Nova::Server',
 490             'depends_on': []
 491         }
 492
 493         server_properties = {
 494             'name': name,
 495             'image': image,
 496             'flavor': {},
 497             'networks': []  # list of dictionaries
 498         }
 499
 500         if flavor in flavors:
 501             self.resources[name]['depends_on'].append(flavor)
 502             server_properties["flavor"] = {'get_resource': flavor}
 503         else:
 504             server_properties["flavor"] = flavor
 505
 506         if user:
 507             server_properties['admin_user'] = user
 508
 509         if key_name:
 510             self.resources[name]['depends_on'].append(key_name)
 511             server_properties['key_name'] = {'get_resource': key_name}
 512
 513         if ports:
 514             self.resources[name]['depends_on'].extend(ports)
 515             for port in ports:
 516                 server_properties['networks'].append(
 517                     {'port': {'get_resource': port}}
 518                 )
 519
 520         if networks:
 521             for i, _ in enumerate(networks):
 522                 server_properties['networks'].append({'network': networks[i]})
 523
 524         if scheduler_hints:
 525             server_properties['scheduler_hints'] = scheduler_hints
 526
 527         if user_data:
 528             server_properties['user_data'] = user_data
 529
 530         if metadata:
 531             assert isinstance(metadata, collections.Mapping)
 532             server_properties['metadata'] = metadata
 533
 534         if additional_properties:
 535             assert isinstance(additional_properties, collections.Mapping)
 536             for prop in additional_properties:
 537                 server_properties[prop] = additional_properties[prop]
 538
 539         server_properties['config_drive'] = True
 540
 541         self.resources[name]['properties'] = server_properties
 542
 543         self._template['outputs'][name] = {
 544             'description': 'VM UUID',
 545             'value': {'get_resource': name}
 546         }
 547
 548     HEAT_WAIT_LOOP_INTERVAL = 2
 549     HEAT_CREATE_COMPLETE_STATUS = u'CREATE_COMPLETE'
 550
 551     def create(self, block=True, timeout=3600):
 552         """
 553         creates a template in the target cloud using heat
 554         returns a dict with the requested output values from the template
 555
 556         :param block: Wait for Heat create to finish
 557         :type block: bool
 558         :param: timeout: timeout in seconds for Heat create, default 3600s
 559         :type timeout: int
 560         """
 561         log.info("Creating stack '%s'", self.name)
 562
 563         # create stack early to support cleanup, e.g. ctrl-c while waiting
 564         stack = HeatStack(self.name)
 565
 566         heat_client = self.heat_client
 567         start_time = time.time()
 568         stack.uuid = self.uuid = heat_client.stacks.create(
 569             stack_name=self.name, template=self._template,
 570             parameters=self.heat_parameters)['stack']['id']
 571
 572         if not block:
 573             self.outputs = stack.outputs = {}
 574             end_time = time.time()
 575             log.info("Created stack '%s' in %.3e secs",
 576                      self.name, end_time - start_time)
 577             return stack
 578
 579         time_limit = start_time + timeout
 580         for status in iter(self.status, self.HEAT_CREATE_COMPLETE_STATUS):
 581             log.debug("stack state %s", status)
 582             if status == u'CREATE_FAILED':
 583                 stack_status_reason = heat_client.stacks.get(self.uuid).stack_status_reason
 584                 heat_client.stacks.delete(self.uuid)
 585                 raise RuntimeError(stack_status_reason)
 586             if time.time() > time_limit:
 587                 raise RuntimeError("Heat stack create timeout")
 588
 589             time.sleep(self.HEAT_WAIT_LOOP_INTERVAL)
 590
 591         end_time = time.time()
 592         outputs = heat_client.stacks.get(self.uuid).outputs
 593         log.info("Created stack '%s' in %.3e secs",
 594                  self.name, end_time - start_time)
 595
 596         # keep outputs as unicode
 597         self.outputs = {output["output_key"]: output["output_value"] for output
 598                         in outputs}
 599
 600         stack.outputs = self.outputs
 601         return stack