329 lines
12 KiB
Python
329 lines
12 KiB
Python
# Copyright 2014: Mirantis Inc.
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from oslo_config import cfg
|
|
import requests
|
|
|
|
from rally.common import logging
|
|
from rally import exceptions
|
|
from rally.plugins.openstack import scenario
|
|
from rally.task import atomic
|
|
from rally.task import utils
|
|
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
CONF = cfg.CONF
|
|
|
|
|
|
class HeatScenario(scenario.OpenStackScenario):
|
|
"""Base class for Heat scenarios with basic atomic actions."""
|
|
|
|
@atomic.action_timer("heat.list_stacks")
|
|
def _list_stacks(self):
|
|
"""Return user stack list."""
|
|
|
|
return list(self.clients("heat").stacks.list())
|
|
|
|
@atomic.action_timer("heat.create_stack")
|
|
def _create_stack(self, template, parameters=None,
|
|
files=None, environment=None):
|
|
"""Create a new stack.
|
|
|
|
:param template: template with stack description.
|
|
:param parameters: template parameters used during stack creation
|
|
:param files: additional files used in template
|
|
:param environment: stack environment definition
|
|
|
|
:returns: object of stack
|
|
"""
|
|
stack_name = self.generate_random_name()
|
|
kw = {
|
|
"stack_name": stack_name,
|
|
"disable_rollback": True,
|
|
"parameters": parameters or {},
|
|
"template": template,
|
|
"files": files or {},
|
|
"environment": environment or {}
|
|
}
|
|
|
|
# heat client returns body instead manager object, so we should
|
|
# get manager object using stack_id
|
|
stack_id = self.clients("heat").stacks.create(**kw)["stack"]["id"]
|
|
stack = self.clients("heat").stacks.get(stack_id)
|
|
|
|
self.sleep_between(CONF.benchmark.heat_stack_create_prepoll_delay)
|
|
|
|
stack = utils.wait_for(
|
|
stack,
|
|
ready_statuses=["CREATE_COMPLETE"],
|
|
failure_statuses=["CREATE_FAILED", "ERROR"],
|
|
update_resource=utils.get_from_manager(),
|
|
timeout=CONF.benchmark.heat_stack_create_timeout,
|
|
check_interval=CONF.benchmark.heat_stack_create_poll_interval)
|
|
|
|
return stack
|
|
|
|
@atomic.action_timer("heat.update_stack")
|
|
def _update_stack(self, stack, template, parameters=None,
|
|
files=None, environment=None):
|
|
"""Update an existing stack
|
|
|
|
:param stack: stack that need to be updated
|
|
:param template: Updated template
|
|
:param parameters: template parameters for stack update
|
|
:param files: additional files used in template
|
|
:param environment: stack environment definition
|
|
|
|
:returns: object of updated stack
|
|
"""
|
|
|
|
kw = {
|
|
"stack_name": stack.stack_name,
|
|
"disable_rollback": True,
|
|
"parameters": parameters or {},
|
|
"template": template,
|
|
"files": files or {},
|
|
"environment": environment or {}
|
|
}
|
|
self.clients("heat").stacks.update(stack.id, **kw)
|
|
|
|
self.sleep_between(CONF.benchmark.heat_stack_update_prepoll_delay)
|
|
|
|
stack = utils.wait_for(
|
|
stack,
|
|
ready_statuses=["UPDATE_COMPLETE"],
|
|
failure_statuses=["UPDATE_FAILED", "ERROR"],
|
|
update_resource=utils.get_from_manager(),
|
|
timeout=CONF.benchmark.heat_stack_update_timeout,
|
|
check_interval=CONF.benchmark.heat_stack_update_poll_interval)
|
|
return stack
|
|
|
|
@atomic.action_timer("heat.check_stack")
|
|
def _check_stack(self, stack):
|
|
"""Check given stack.
|
|
|
|
Check the stack and stack resources.
|
|
|
|
:param stack: stack that needs to be checked
|
|
"""
|
|
self.clients("heat").actions.check(stack.id)
|
|
utils.wait_for(
|
|
stack,
|
|
ready_statuses=["CHECK_COMPLETE"],
|
|
failure_statuses=["CHECK_FAILED", "ERROR"],
|
|
update_resource=utils.get_from_manager(["CHECK_FAILED"]),
|
|
timeout=CONF.benchmark.heat_stack_check_timeout,
|
|
check_interval=CONF.benchmark.heat_stack_check_poll_interval)
|
|
|
|
@atomic.action_timer("heat.delete_stack")
|
|
def _delete_stack(self, stack):
|
|
"""Delete given stack.
|
|
|
|
Returns when the stack is actually deleted.
|
|
|
|
:param stack: stack object
|
|
"""
|
|
stack.delete()
|
|
utils.wait_for_status(
|
|
stack,
|
|
ready_statuses=["DELETE_COMPLETE"],
|
|
failure_statuses=["DELETE_FAILED", "ERROR"],
|
|
check_deletion=True,
|
|
update_resource=utils.get_from_manager(),
|
|
timeout=CONF.benchmark.heat_stack_delete_timeout,
|
|
check_interval=CONF.benchmark.heat_stack_delete_poll_interval)
|
|
|
|
@atomic.action_timer("heat.suspend_stack")
|
|
def _suspend_stack(self, stack):
|
|
"""Suspend given stack.
|
|
|
|
:param stack: stack that needs to be suspended
|
|
"""
|
|
|
|
self.clients("heat").actions.suspend(stack.id)
|
|
utils.wait_for(
|
|
stack,
|
|
ready_statuses=["SUSPEND_COMPLETE"],
|
|
failure_statuses=["SUSPEND_FAILED", "ERROR"],
|
|
update_resource=utils.get_from_manager(),
|
|
timeout=CONF.benchmark.heat_stack_suspend_timeout,
|
|
check_interval=CONF.benchmark.heat_stack_suspend_poll_interval)
|
|
|
|
@atomic.action_timer("heat.resume_stack")
|
|
def _resume_stack(self, stack):
|
|
"""Resume given stack.
|
|
|
|
:param stack: stack that needs to be resumed
|
|
"""
|
|
|
|
self.clients("heat").actions.resume(stack.id)
|
|
utils.wait_for(
|
|
stack,
|
|
ready_statuses=["RESUME_COMPLETE"],
|
|
failure_statuses=["RESUME_FAILED", "ERROR"],
|
|
update_resource=utils.get_from_manager(),
|
|
timeout=CONF.benchmark.heat_stack_resume_timeout,
|
|
check_interval=CONF.benchmark.heat_stack_resume_poll_interval)
|
|
|
|
@atomic.action_timer("heat.snapshot_stack")
|
|
def _snapshot_stack(self, stack):
|
|
"""Creates a snapshot for given stack.
|
|
|
|
:param stack: stack that will be used as base for snapshot
|
|
:returns: snapshot created for given stack
|
|
"""
|
|
snapshot = self.clients("heat").stacks.snapshot(
|
|
stack.id)
|
|
utils.wait_for(
|
|
stack,
|
|
ready_statuses=["SNAPSHOT_COMPLETE"],
|
|
failure_statuses=["SNAPSHOT_FAILED", "ERROR"],
|
|
update_resource=utils.get_from_manager(),
|
|
timeout=CONF.benchmark.heat_stack_snapshot_timeout,
|
|
check_interval=CONF.benchmark.heat_stack_snapshot_poll_interval)
|
|
return snapshot
|
|
|
|
@atomic.action_timer("heat.restore_stack")
|
|
def _restore_stack(self, stack, snapshot_id):
|
|
"""Restores stack from given snapshot.
|
|
|
|
:param stack: stack that will be restored from snapshot
|
|
:param snapshot_id: id of given snapshot
|
|
"""
|
|
self.clients("heat").stacks.restore(stack.id, snapshot_id)
|
|
utils.wait_for(
|
|
stack,
|
|
ready_statuses=["RESTORE_COMPLETE"],
|
|
failure_statuses=["RESTORE_FAILED", "ERROR"],
|
|
update_resource=utils.get_from_manager(),
|
|
timeout=CONF.benchmark.heat_stack_restore_timeout,
|
|
check_interval=CONF.benchmark.heat_stack_restore_poll_interval
|
|
)
|
|
|
|
@atomic.action_timer("heat.show_output")
|
|
def _stack_show_output(self, stack, output_key):
|
|
"""Execute output_show for specified "output_key".
|
|
|
|
This method uses new output API call.
|
|
:param stack: stack with output_key output.
|
|
:param output_key: The name of the output.
|
|
"""
|
|
output = self.clients("heat").stacks.output_show(stack.id, output_key)
|
|
return output
|
|
|
|
@atomic.action_timer("heat.show_output_via_API")
|
|
def _stack_show_output_via_API(self, stack, output_key):
|
|
"""Execute output_show for specified "output_key".
|
|
|
|
This method uses old way for getting output value.
|
|
It gets whole stack object and then finds necessary "output_key".
|
|
:param stack: stack with output_key output.
|
|
:param output_key: The name of the output.
|
|
"""
|
|
# this code copy-pasted and adopted for rally from old client version
|
|
# https://github.com/openstack/python-heatclient/blob/0.8.0/heatclient/
|
|
# v1/shell.py#L682-L699
|
|
stack = self.clients("heat").stacks.get(stack_id=stack.id)
|
|
for output in stack.to_dict().get("outputs", []):
|
|
if output["output_key"] == output_key:
|
|
return output
|
|
|
|
@atomic.action_timer("heat.list_output")
|
|
def _stack_list_output(self, stack):
|
|
"""Execute output_list for specified "stack".
|
|
|
|
This method uses new output API call.
|
|
:param stack: stack to call output-list.
|
|
"""
|
|
output_list = self.clients("heat").stacks.output_list(stack.id)
|
|
return output_list
|
|
|
|
@atomic.action_timer("heat.list_output_via_API")
|
|
def _stack_list_output_via_API(self, stack):
|
|
"""Execute output_list for specified "stack".
|
|
|
|
This method uses old way for getting output value.
|
|
It gets whole stack object and then prints all outputs
|
|
belongs this stack.
|
|
:param stack: stack to call output-list.
|
|
"""
|
|
# this code copy-pasted and adopted for rally from old client version
|
|
# https://github.com/openstack/python-heatclient/blob/0.8.0/heatclient/
|
|
# v1/shell.py#L649-L663
|
|
stack = self.clients("heat").stacks.get(stack_id=stack.id)
|
|
output_list = stack.to_dict()["outputs"]
|
|
return output_list
|
|
|
|
def _count_instances(self, stack):
|
|
"""Count instances in a Heat stack.
|
|
|
|
:param stack: stack to count instances in.
|
|
"""
|
|
return len([
|
|
r for r in self.clients("heat").resources.list(stack.id,
|
|
nested_depth=1)
|
|
if r.resource_type == "OS::Nova::Server"])
|
|
|
|
def _scale_stack(self, stack, output_key, delta):
|
|
"""Scale a stack up or down.
|
|
|
|
Calls the webhook given in the output value identified by
|
|
'output_key', and waits for the stack size to change by
|
|
'delta'.
|
|
|
|
:param stack: stack to scale up or down
|
|
:param output_key: The name of the output to get the URL from
|
|
:param delta: The expected change in number of instances in
|
|
the stack (signed int)
|
|
"""
|
|
num_instances = self._count_instances(stack)
|
|
expected_instances = num_instances + delta
|
|
LOG.debug("Scaling stack %s from %s to %s instances with %s"
|
|
% (stack.id, num_instances, expected_instances, output_key))
|
|
with atomic.ActionTimer(self, "heat.scale_with_%s" % output_key):
|
|
self._stack_webhook(stack, output_key)
|
|
utils.wait_for(
|
|
stack,
|
|
is_ready=lambda s: (
|
|
self._count_instances(s) == expected_instances),
|
|
failure_statuses=["UPDATE_FAILED", "ERROR"],
|
|
update_resource=utils.get_from_manager(),
|
|
timeout=CONF.benchmark.heat_stack_scale_timeout,
|
|
check_interval=CONF.benchmark.heat_stack_scale_poll_interval)
|
|
|
|
def _stack_webhook(self, stack, output_key):
|
|
"""POST to the URL given in the output value identified by output_key.
|
|
|
|
This can be used to scale stacks up and down, for instance.
|
|
|
|
:param stack: stack to call a webhook on
|
|
:param output_key: The name of the output to get the URL from
|
|
:raises InvalidConfigException: if the output key is not found
|
|
"""
|
|
url = None
|
|
for output in stack.outputs:
|
|
if output["output_key"] == output_key:
|
|
url = output["output_value"]
|
|
break
|
|
else:
|
|
raise exceptions.InvalidConfigException(
|
|
"No output key %(key)s found in stack %(id)s" %
|
|
{"key": output_key, "id": stack.id})
|
|
|
|
with atomic.ActionTimer(self, "heat.%s_webhook" % output_key):
|
|
requests.post(url).raise_for_status()
|