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 ##############################################################################
15 from yardstick.benchmark.contexts.base import Context
16 from yardstick.benchmark.contexts.model import Server
17 from yardstick.benchmark.contexts.model import PlacementGroup
18 from yardstick.benchmark.contexts.model import Network
19 from yardstick.benchmark.contexts.model import update_scheduler_hints
20 from yardstick.orchestrator.heat import HeatTemplate
21 from yardstick.definitions import YARDSTICK_ROOT_PATH
24 class HeatContext(Context):
25 '''Class that represents a context in the logical model'''
27 __context_type__ = "Heat"
34 self.placement_groups = []
35 self.keypair_name = None
36 self.secgroup_name = None
41 self.template_file = None
42 self.heat_parameters = None
43 self.key_filename = YARDSTICK_ROOT_PATH + \
44 'yardstick/resources/files/yardstick_key'
45 super(self.__class__, self).__init__()
47 def init(self, attrs):
48 '''initializes itself from the supplied arguments'''
49 self.name = attrs["name"]
52 self._user = attrs["user"]
54 if "heat_template" in attrs:
55 self.template_file = attrs["heat_template"]
56 self.heat_parameters = attrs.get("heat_parameters", None)
59 self.keypair_name = self.name + "-key"
60 self.secgroup_name = self.name + "-secgroup"
63 self._image = attrs["image"]
66 self._flavor = attrs["flavor"]
68 if "placement_groups" in attrs:
69 for name, pgattrs in attrs["placement_groups"].items():
70 pg = PlacementGroup(name, self, pgattrs["policy"])
71 self.placement_groups.append(pg)
73 for name, netattrs in attrs["networks"].items():
74 network = Network(name, self, netattrs)
75 self.networks.append(network)
77 for name, serverattrs in attrs["servers"].items():
78 server = Server(name, self, serverattrs)
79 self.servers.append(server)
80 self._server_map[server.dn] = server
82 print "Generating RSA host key ..."
83 rsa_key = paramiko.RSAKey.generate(bits=2048, progress_func=None)
84 print "Writing yardstick_key ..."
85 rsa_key.write_private_key_file(self.key_filename)
86 print "Writing yardstick_key.pub ..."
87 open(self.key_filename + ".pub", "w").write("%s %s\n" %
89 rsa_key.get_base64()))
95 '''returns application's default image name'''
100 '''returns application's default flavor name'''
105 '''return login user name corresponding to image'''
108 def _add_resources_to_template(self, template):
109 '''add to the template the resources represented by this context'''
110 template.add_keypair(self.keypair_name)
111 template.add_security_group(self.secgroup_name)
113 for network in self.networks:
114 template.add_network(network.stack_name)
115 template.add_subnet(network.subnet_stack_name, network.stack_name,
119 template.add_router(network.router.stack_name,
120 network.router.external_gateway_info,
121 network.subnet_stack_name)
122 template.add_router_interface(network.router.stack_if_name,
123 network.router.stack_name,
124 network.subnet_stack_name)
126 # create a list of servers sorted by increasing no of placement groups
127 list_of_servers = sorted(self.servers,
128 key=lambda s: len(s.placement_groups))
131 # add servers with scheduler hints derived from placement groups
134 # create list of servers with availability policy
135 availability_servers = []
136 for server in list_of_servers:
137 for pg in server.placement_groups:
138 if pg.policy == "availability":
139 availability_servers.append(server)
142 # add servers with availability policy
144 for server in availability_servers:
146 for pg in server.placement_groups:
147 update_scheduler_hints(scheduler_hints, added_servers, pg)
148 # workround for openstack nova bug, check JIRA: YARDSTICK-200
150 if len(availability_servers) == 2:
151 if len(scheduler_hints["different_host"]) == 0:
152 scheduler_hints.pop("different_host", None)
153 server.add_to_template(template,
156 added_servers.append(server.stack_name)
158 scheduler_hints["different_host"] = \
159 scheduler_hints["different_host"][0]
160 server.add_to_template(template,
163 added_servers.append(server.stack_name)
165 server.add_to_template(template,
168 added_servers.append(server.stack_name)
170 # create list of servers with affinity policy
171 affinity_servers = []
172 for server in list_of_servers:
173 for pg in server.placement_groups:
174 if pg.policy == "affinity":
175 affinity_servers.append(server)
178 # add servers with affinity policy
179 for server in affinity_servers:
180 if server.stack_name in added_servers:
183 for pg in server.placement_groups:
184 update_scheduler_hints(scheduler_hints, added_servers, pg)
185 server.add_to_template(template, self.networks, scheduler_hints)
186 added_servers.append(server.stack_name)
188 # add remaining servers with no placement group configured
189 for server in list_of_servers:
190 if len(server.placement_groups) == 0:
191 server.add_to_template(template, self.networks, {})
194 '''deploys template into a stack using cloud'''
195 print "Deploying context '%s'" % self.name
197 heat_template = HeatTemplate(self.name, self.template_file,
198 self.heat_parameters)
200 if self.template_file is None:
201 self._add_resources_to_template(heat_template)
204 self.stack = heat_template.create()
205 except KeyboardInterrupt:
206 sys.exit("\nStack create interrupted")
207 except RuntimeError as err:
208 sys.exit("error: failed to deploy stack: '%s'" % err.args)
209 except Exception as err:
210 sys.exit("error: failed to deploy stack: '%s'" % err)
212 # copy some vital stack output into server objects
213 for server in self.servers:
214 if len(server.ports) > 0:
215 # TODO(hafe) can only handle one internal network for now
216 port = server.ports.values()[0]
217 server.private_ip = self.stack.outputs[port["stack_name"]]
219 if server.floating_ip:
221 self.stack.outputs[server.floating_ip["stack_name"]]
223 print "Context '%s' deployed" % self.name
226 '''undeploys stack from cloud'''
228 print "Undeploying context '%s'" % self.name
231 print "Context '%s' undeployed" % self.name
233 if os.path.exists(self.key_filename):
235 os.remove(self.key_filename)
236 os.remove(self.key_filename + ".pub")
238 print ("Error: %s - %s." % (e.key_filename, e.strerror))
240 def _get_server(self, attr_name):
241 '''lookup server info by name from context
242 attr_name: either a name for a server created by yardstick or a dict
243 with attribute name mapping when using external heat templates
245 key_filename = pkg_resources.resource_filename(
246 'yardstick.resources', 'files/yardstick_key')
248 if type(attr_name) is dict:
249 cname = attr_name["name"].split(".")[1]
250 if cname != self.name:
255 if "public_ip_attr" in attr_name:
256 public_ip = self.stack.outputs[attr_name["public_ip_attr"]]
257 if "private_ip_attr" in attr_name:
258 private_ip = self.stack.outputs[
259 attr_name["private_ip_attr"]]
261 # Create a dummy server instance for holding the *_ip attributes
262 server = Server(attr_name["name"].split(".")[0], self, {})
263 server.public_ip = public_ip
264 server.private_ip = private_ip
266 if attr_name not in self._server_map:
268 server = self._server_map[attr_name]
274 "user": server.context.user,
275 "key_filename": key_filename,
276 "private_ip": server.private_ip
278 # Target server may only have private_ip
280 result["ip"] = server.public_ip