yardstick/benchmark/contexts/heat.py

   1 ##############################################################################
   2 # Copyright (c) 2015 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 from __future__ import absolute_import
  11 from __future__ import print_function
  12
  13 import collections
  14 import logging
  15 import os
  16 import sys
  17 import uuid
  18
  19 import paramiko
  20 import pkg_resources
  21
  22 from yardstick.benchmark.contexts.base import Context
  23 from yardstick.benchmark.contexts.model import Network
  24 from yardstick.benchmark.contexts.model import PlacementGroup
  25 from yardstick.benchmark.contexts.model import Server
  26 from yardstick.benchmark.contexts.model import update_scheduler_hints
  27 from yardstick.orchestrator.heat import HeatTemplate, get_short_key_uuid
  28 from yardstick.definitions import YARDSTICK_ROOT_PATH
  29
  30 LOG = logging.getLogger(__name__)
  31
  32
  33 class HeatContext(Context):
  34     """Class that represents a context in the logical model"""
  35
  36     __context_type__ = "Heat"
  37
  38     def __init__(self):
  39         self.name = None
  40         self.stack = None
  41         self.networks = []
  42         self.servers = []
  43         self.placement_groups = []
  44         self.keypair_name = None
  45         self.secgroup_name = None
  46         self._server_map = {}
  47         self._image = None
  48         self._flavor = None
  49         self._user = None
  50         self.template_file = None
  51         self.heat_parameters = None
  52         # generate an uuid to identify yardstick_key
  53         # the first 8 digits of the uuid will be used
  54         self.key_uuid = uuid.uuid4()
  55         self.key_filename = ''.join(
  56             [YARDSTICK_ROOT_PATH, 'yardstick/resources/files/yardstick_key-',
  57              get_short_key_uuid(self.key_uuid)])
  58         super(HeatContext, self).__init__()
  59
  60     def init(self, attrs):
  61         """initializes itself from the supplied arguments"""
  62         self.name = attrs["name"]
  63
  64         if "user" in attrs:
  65             self._user = attrs["user"]
  66
  67         if "heat_template" in attrs:
  68             self.template_file = attrs["heat_template"]
  69             self.heat_parameters = attrs.get("heat_parameters", None)
  70             return
  71
  72         self.keypair_name = self.name + "-key"
  73         self.secgroup_name = self.name + "-secgroup"
  74
  75         if "image" in attrs:
  76             self._image = attrs["image"]
  77
  78         if "flavor" in attrs:
  79             self._flavor = attrs["flavor"]
  80
  81         if "placement_groups" in attrs:
  82             for name, pgattrs in attrs["placement_groups"].items():
  83                 pg = PlacementGroup(name, self, pgattrs["policy"])
  84                 self.placement_groups.append(pg)
  85
  86         for name, netattrs in attrs["networks"].items():
  87             network = Network(name, self, netattrs)
  88             self.networks.append(network)
  89
  90         for name, serverattrs in attrs["servers"].items():
  91             server = Server(name, self, serverattrs)
  92             self.servers.append(server)
  93             self._server_map[server.dn] = server
  94
  95         rsa_key = paramiko.RSAKey.generate(bits=2048, progress_func=None)
  96         rsa_key.write_private_key_file(self.key_filename)
  97         print("Writing %s ..." % self.key_filename)
  98         with open(self.key_filename + ".pub", "w") as pubkey_file:
  99             pubkey_file.write(
 100                 "%s %s\n" % (rsa_key.get_name(), rsa_key.get_base64()))
 101         del rsa_key
 102
 103     @property
 104     def image(self):
 105         """returns application's default image name"""
 106         return self._image
 107
 108     @property
 109     def flavor(self):
 110         """returns application's default flavor name"""
 111         return self._flavor
 112
 113     @property
 114     def user(self):
 115         """return login user name corresponding to image"""
 116         return self._user
 117
 118     def _add_resources_to_template(self, template):
 119         """add to the template the resources represented by this context"""
 120         template.add_keypair(self.keypair_name, self.key_uuid)
 121         template.add_security_group(self.secgroup_name)
 122
 123         for network in self.networks:
 124             template.add_network(network.stack_name)
 125             template.add_subnet(network.subnet_stack_name, network.stack_name,
 126                                 network.subnet_cidr)
 127
 128             if network.router:
 129                 template.add_router(network.router.stack_name,
 130                                     network.router.external_gateway_info,
 131                                     network.subnet_stack_name)
 132                 template.add_router_interface(network.router.stack_if_name,
 133                                               network.router.stack_name,
 134                                               network.subnet_stack_name)
 135
 136         # create a list of servers sorted by increasing no of placement groups
 137         list_of_servers = sorted(self.servers,
 138                                  key=lambda s: len(s.placement_groups))
 139
 140         #
 141         # add servers with scheduler hints derived from placement groups
 142         #
 143
 144         # create list of servers with availability policy
 145         availability_servers = []
 146         for server in list_of_servers:
 147             for pg in server.placement_groups:
 148                 if pg.policy == "availability":
 149                     availability_servers.append(server)
 150                     break
 151
 152         # add servers with availability policy
 153         added_servers = []
 154         for server in availability_servers:
 155             scheduler_hints = {}
 156             for pg in server.placement_groups:
 157                 update_scheduler_hints(scheduler_hints, added_servers, pg)
 158             # workround for openstack nova bug, check JIRA: YARDSTICK-200
 159             # for details
 160             if len(availability_servers) == 2:
 161                 if len(scheduler_hints["different_host"]) == 0:
 162                     scheduler_hints.pop("different_host", None)
 163                     server.add_to_template(template,
 164                                            self.networks,
 165                                            scheduler_hints)
 166                     added_servers.append(server.stack_name)
 167                 else:
 168                     scheduler_hints["different_host"] = \
 169                         scheduler_hints["different_host"][0]
 170                     server.add_to_template(template,
 171                                            self.networks,
 172                                            scheduler_hints)
 173                     added_servers.append(server.stack_name)
 174             else:
 175                 server.add_to_template(template,
 176                                        self.networks,
 177                                        scheduler_hints)
 178                 added_servers.append(server.stack_name)
 179
 180         # create list of servers with affinity policy
 181         affinity_servers = []
 182         for server in list_of_servers:
 183             for pg in server.placement_groups:
 184                 if pg.policy == "affinity":
 185                     affinity_servers.append(server)
 186                     break
 187
 188         # add servers with affinity policy
 189         for server in affinity_servers:
 190             if server.stack_name in added_servers:
 191                 continue
 192             scheduler_hints = {}
 193             for pg in server.placement_groups:
 194                 update_scheduler_hints(scheduler_hints, added_servers, pg)
 195             server.add_to_template(template, self.networks, scheduler_hints)
 196             added_servers.append(server.stack_name)
 197
 198         # add remaining servers with no placement group configured
 199         for server in list_of_servers:
 200             if len(server.placement_groups) == 0:
 201                 server.add_to_template(template, self.networks, {})
 202
 203     def deploy(self):
 204         """deploys template into a stack using cloud"""
 205         print("Deploying context '%s'" % self.name)
 206
 207         heat_template = HeatTemplate(self.name, self.template_file,
 208                                      self.heat_parameters)
 209
 210         if self.template_file is None:
 211             self._add_resources_to_template(heat_template)
 212
 213         try:
 214             self.stack = heat_template.create()
 215         except KeyboardInterrupt:
 216             sys.exit("\nStack create interrupted")
 217         except RuntimeError as err:
 218             sys.exit("error: failed to deploy stack: '%s'" % err.args)
 219         except Exception as err:
 220             sys.exit("error: failed to deploy stack: '%s'" % err)
 221
 222         # copy some vital stack output into server objects
 223         for server in self.servers:
 224             if server.ports:
 225                 # TODO(hafe) can only handle one internal network for now
 226                 port = next(iter(server.ports.values()))
 227                 server.private_ip = self.stack.outputs[port["stack_name"]]
 228
 229             if server.floating_ip:
 230                 server.public_ip = \
 231                     self.stack.outputs[server.floating_ip["stack_name"]]
 232
 233         print("Context '%s' deployed" % self.name)
 234
 235     def undeploy(self):
 236         """undeploys stack from cloud"""
 237         if self.stack:
 238             print("Undeploying context '%s'" % self.name)
 239             self.stack.delete()
 240             self.stack = None
 241             print("Context '%s' undeployed" % self.name)
 242
 243         if os.path.exists(self.key_filename):
 244             try:
 245                 os.remove(self.key_filename)
 246                 os.remove(self.key_filename + ".pub")
 247             except OSError:
 248                 LOG.exception("Key filename %s", self.key_filename)
 249
 250     def _get_server(self, attr_name):
 251         """lookup server info by name from context
 252         attr_name: either a name for a server created by yardstick or a dict
 253         with attribute name mapping when using external heat templates
 254         """
 255         key_filename = pkg_resources.resource_filename(
 256             'yardstick.resources',
 257             'files/yardstick_key-' + get_short_key_uuid(self.key_uuid))
 258
 259         if isinstance(attr_name, collections.Mapping):
 260             cname = attr_name["name"].split(".")[1]
 261             if cname != self.name:
 262                 return None
 263
 264             public_ip = None
 265             private_ip = None
 266             if "public_ip_attr" in attr_name:
 267                 public_ip = self.stack.outputs[attr_name["public_ip_attr"]]
 268             if "private_ip_attr" in attr_name:
 269                 private_ip = self.stack.outputs[
 270                     attr_name["private_ip_attr"]]
 271
 272             # Create a dummy server instance for holding the *_ip attributes
 273             server = Server(attr_name["name"].split(".")[0], self, {})
 274             server.public_ip = public_ip
 275             server.private_ip = private_ip
 276         else:
 277             if attr_name not in self._server_map:
 278                 return None
 279             server = self._server_map[attr_name]
 280
 281         if server is None:
 282             return None
 283
 284         result = {
 285             "user": server.context.user,
 286             "key_filename": key_filename,
 287             "private_ip": server.private_ip
 288         }
 289         # Target server may only have private_ip
 290         if server.public_ip:
 291             result["ip"] = server.public_ip
 292
 293         return result