1 ##############################################################################
2 # Copyright (c) 2015 Ericsson AB and others.
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 ##############################################################################
10 from __future__ import absolute_import
11 from __future__ import print_function
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
30 LOG = logging.getLogger(__name__)
33 class HeatContext(Context):
34 """Class that represents a context in the logical model"""
36 __context_type__ = "Heat"
43 self.placement_groups = []
44 self.keypair_name = None
45 self.secgroup_name = 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__()
60 def init(self, attrs):
61 """initializes itself from the supplied arguments"""
62 self.name = attrs["name"]
65 self._user = attrs["user"]
67 if "heat_template" in attrs:
68 self.template_file = attrs["heat_template"]
69 self.heat_parameters = attrs.get("heat_parameters", None)
72 self.keypair_name = self.name + "-key"
73 self.secgroup_name = self.name + "-secgroup"
76 self._image = attrs["image"]
79 self._flavor = attrs["flavor"]
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)
86 for name, netattrs in attrs["networks"].items():
87 network = Network(name, self, netattrs)
88 self.networks.append(network)
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
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:
100 "%s %s\n" % (rsa_key.get_name(), rsa_key.get_base64()))
105 """returns application's default image name"""
110 """returns application's default flavor name"""
115 """return login user name corresponding to image"""
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)
123 for network in self.networks:
124 template.add_network(network.stack_name)
125 template.add_subnet(network.subnet_stack_name, network.stack_name,
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)
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))
141 # add servers with scheduler hints derived from placement groups
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)
152 # add servers with availability policy
154 for server in availability_servers:
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
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,
166 added_servers.append(server.stack_name)
168 scheduler_hints["different_host"] = \
169 scheduler_hints["different_host"][0]
170 server.add_to_template(template,
173 added_servers.append(server.stack_name)
175 server.add_to_template(template,
178 added_servers.append(server.stack_name)
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)
188 # add servers with affinity policy
189 for server in affinity_servers:
190 if server.stack_name in added_servers:
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)
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, {})
204 """deploys template into a stack using cloud"""
205 print("Deploying context '%s'" % self.name)
207 heat_template = HeatTemplate(self.name, self.template_file,
208 self.heat_parameters)
210 if self.template_file is None:
211 self._add_resources_to_template(heat_template)
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)
222 # copy some vital stack output into server objects
223 for server in self.servers:
224 if len(server.ports) > 0:
225 # TODO(hafe) can only handle one internal network for now
226 port = list(server.ports.values())[0]
227 server.private_ip = self.stack.outputs[port["stack_name"]]
229 if server.floating_ip:
231 self.stack.outputs[server.floating_ip["stack_name"]]
233 print("Context '%s' deployed" % self.name)
236 """undeploys stack from cloud"""
238 print("Undeploying context '%s'" % self.name)
241 print("Context '%s' undeployed" % self.name)
243 if os.path.exists(self.key_filename):
245 os.remove(self.key_filename)
246 os.remove(self.key_filename + ".pub")
248 LOG.exception("Key filename %s", self.key_filename)
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
255 key_filename = pkg_resources.resource_filename(
256 'yardstick.resources',
257 'files/yardstick_key-' + get_short_key_uuid(self.key_uuid))
259 if isinstance(attr_name, collections.Mapping):
260 cname = attr_name["name"].split(".")[1]
261 if cname != self.name:
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"]]
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
277 if attr_name not in self._server_map:
279 server = self._server_map[attr_name]
285 "user": server.context.user,
286 "key_filename": key_filename,
287 "private_ip": server.private_ip
289 # Target server may only have private_ip
291 result["ip"] = server.public_ip