837 lines
33 KiB
Python
837 lines
33 KiB
Python
#
|
|
# 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.
|
|
|
|
import collections
|
|
import copy
|
|
import functools
|
|
import itertools
|
|
import math
|
|
|
|
from oslo_log import log as logging
|
|
|
|
from heat.common import exception
|
|
from heat.common import grouputils
|
|
from heat.common.i18n import _
|
|
from heat.common import timeutils
|
|
from heat.engine import attributes
|
|
from heat.engine import constraints
|
|
from heat.engine import function
|
|
from heat.engine import output
|
|
from heat.engine import properties
|
|
from heat.engine.resources import stack_resource
|
|
from heat.engine import rsrc_defn
|
|
from heat.engine import scheduler
|
|
from heat.engine import support
|
|
from heat.scaling import rolling_update
|
|
from heat.scaling import template as scl_template
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
class ResourceGroup(stack_resource.StackResource):
|
|
"""Creates one or more identically configured nested resources.
|
|
|
|
In addition to the `refs` attribute, this resource implements synthetic
|
|
attributes that mirror those of the resources in the group. When
|
|
getting an attribute from this resource, however, a list of attribute
|
|
values for each resource in the group is returned. To get attribute values
|
|
for a single resource in the group, synthetic attributes of the form
|
|
`resource.{resource index}.{attribute name}` can be used. The resource ID
|
|
of a particular resource in the group can be obtained via the synthetic
|
|
attribute `resource.{resource index}`. Note, that if you get attribute
|
|
without `{resource index}`, e.g. `[resource, {attribute_name}]`, you'll get
|
|
a list of this attribute's value for all resources in group.
|
|
|
|
While each resource in the group will be identically configured, this
|
|
resource does allow for some index-based customization of the properties
|
|
of the resources in the group. For example::
|
|
|
|
resources:
|
|
my_indexed_group:
|
|
type: OS::Heat::ResourceGroup
|
|
properties:
|
|
count: 3
|
|
resource_def:
|
|
type: OS::Nova::Server
|
|
properties:
|
|
# create a unique name for each server
|
|
# using its index in the group
|
|
name: my_server_%index%
|
|
image: CentOS 6.5
|
|
flavor: 4GB Performance
|
|
|
|
would result in a group of three servers having the same image and flavor,
|
|
but names of `my_server_0`, `my_server_1`, and `my_server_2`. The variable
|
|
used for substitution can be customized by using the `index_var` property.
|
|
"""
|
|
|
|
support_status = support.SupportStatus(version='2014.1')
|
|
|
|
PROPERTIES = (
|
|
COUNT, INDEX_VAR, RESOURCE_DEF, REMOVAL_POLICIES,
|
|
REMOVAL_POLICIES_MODE,
|
|
) = (
|
|
'count', 'index_var', 'resource_def', 'removal_policies',
|
|
'removal_policies_mode'
|
|
)
|
|
|
|
_RESOURCE_DEF_KEYS = (
|
|
RESOURCE_DEF_TYPE, RESOURCE_DEF_PROPERTIES, RESOURCE_DEF_METADATA,
|
|
) = (
|
|
'type', 'properties', 'metadata',
|
|
)
|
|
|
|
_REMOVAL_POLICIES_KEYS = (
|
|
REMOVAL_RSRC_LIST,
|
|
) = (
|
|
'resource_list',
|
|
)
|
|
|
|
_REMOVAL_POLICY_MODES = (
|
|
REMOVAL_POLICY_APPEND, REMOVAL_POLICY_UPDATE
|
|
) = (
|
|
'append', 'update'
|
|
)
|
|
|
|
_ROLLING_UPDATES_SCHEMA_KEYS = (
|
|
MIN_IN_SERVICE, MAX_BATCH_SIZE, PAUSE_TIME,
|
|
) = (
|
|
'min_in_service', 'max_batch_size', 'pause_time',
|
|
)
|
|
|
|
_BATCH_CREATE_SCHEMA_KEYS = (
|
|
MAX_BATCH_SIZE, PAUSE_TIME,
|
|
) = (
|
|
'max_batch_size', 'pause_time',
|
|
)
|
|
|
|
_UPDATE_POLICY_SCHEMA_KEYS = (
|
|
ROLLING_UPDATE, BATCH_CREATE,
|
|
) = (
|
|
'rolling_update', 'batch_create',
|
|
)
|
|
|
|
ATTRIBUTES = (
|
|
REFS, REFS_MAP, ATTR_ATTRIBUTES, REMOVED_RSRC_LIST
|
|
) = (
|
|
'refs', 'refs_map', 'attributes', 'removed_rsrc_list'
|
|
)
|
|
|
|
properties_schema = {
|
|
COUNT: properties.Schema(
|
|
properties.Schema.INTEGER,
|
|
_('The number of resources to create.'),
|
|
default=1,
|
|
constraints=[
|
|
constraints.Range(min=0),
|
|
],
|
|
update_allowed=True
|
|
),
|
|
INDEX_VAR: properties.Schema(
|
|
properties.Schema.STRING,
|
|
_('A variable that this resource will use to replace with the '
|
|
'current index of a given resource in the group. Can be used, '
|
|
'for example, to customize the name property of grouped '
|
|
'servers in order to differentiate them when listed with '
|
|
'nova client.'),
|
|
default="%index%",
|
|
constraints=[
|
|
constraints.Length(min=3)
|
|
],
|
|
support_status=support.SupportStatus(version='2014.2')
|
|
),
|
|
RESOURCE_DEF: properties.Schema(
|
|
properties.Schema.MAP,
|
|
_('Resource definition for the resources in the group. The value '
|
|
'of this property is the definition of a resource just as if '
|
|
'it had been declared in the template itself.'),
|
|
schema={
|
|
RESOURCE_DEF_TYPE: properties.Schema(
|
|
properties.Schema.STRING,
|
|
_('The type of the resources in the group.'),
|
|
required=True
|
|
),
|
|
RESOURCE_DEF_PROPERTIES: properties.Schema(
|
|
properties.Schema.MAP,
|
|
_('Property values for the resources in the group.')
|
|
),
|
|
RESOURCE_DEF_METADATA: properties.Schema(
|
|
properties.Schema.MAP,
|
|
_('Supplied metadata for the resources in the group.'),
|
|
support_status=support.SupportStatus(version='5.0.0')
|
|
),
|
|
|
|
},
|
|
required=True,
|
|
update_allowed=True
|
|
),
|
|
REMOVAL_POLICIES: properties.Schema(
|
|
properties.Schema.LIST,
|
|
_('Policies for removal of resources on update.'),
|
|
schema=properties.Schema(
|
|
properties.Schema.MAP,
|
|
_('Policy to be processed when doing an update which '
|
|
'requires removal of specific resources.'),
|
|
schema={
|
|
REMOVAL_RSRC_LIST: properties.Schema(
|
|
properties.Schema.LIST,
|
|
_("List of resources to be removed "
|
|
"when doing an update which requires removal of "
|
|
"specific resources. "
|
|
"The resource may be specified several ways: "
|
|
"(1) The resource name, as in the nested stack, "
|
|
"(2) The resource reference returned from "
|
|
"get_resource in a template, as available via "
|
|
"the 'refs' attribute. "
|
|
"Note this is destructive on update when specified; "
|
|
"even if the count is not being reduced, and once "
|
|
"a resource name is removed, its name is never "
|
|
"reused in subsequent updates."
|
|
),
|
|
default=[]
|
|
),
|
|
},
|
|
),
|
|
update_allowed=True,
|
|
default=[],
|
|
support_status=support.SupportStatus(version='2015.1')
|
|
),
|
|
REMOVAL_POLICIES_MODE: properties.Schema(
|
|
properties.Schema.STRING,
|
|
_('How to handle changes to removal_policies on update. '
|
|
'The default "append" mode appends to the internal list, '
|
|
'"update" replaces it on update.'),
|
|
default=REMOVAL_POLICY_APPEND,
|
|
constraints=[
|
|
constraints.AllowedValues(_REMOVAL_POLICY_MODES)
|
|
],
|
|
update_allowed=True,
|
|
support_status=support.SupportStatus(version='10.0.0')
|
|
),
|
|
}
|
|
|
|
attributes_schema = {
|
|
REFS: attributes.Schema(
|
|
_("A list of resource IDs for the resources in the group."),
|
|
type=attributes.Schema.LIST
|
|
),
|
|
REFS_MAP: attributes.Schema(
|
|
_("A map of resource names to IDs for the resources in "
|
|
"the group."),
|
|
type=attributes.Schema.MAP,
|
|
support_status=support.SupportStatus(version='7.0.0'),
|
|
),
|
|
ATTR_ATTRIBUTES: attributes.Schema(
|
|
_("A map of resource names to the specified attribute of each "
|
|
"individual resource. "
|
|
"Requires heat_template_version: 2014-10-16."),
|
|
support_status=support.SupportStatus(version='2014.2'),
|
|
type=attributes.Schema.MAP
|
|
),
|
|
REMOVED_RSRC_LIST: attributes.Schema(
|
|
_("A list of removed resource names."),
|
|
support_status=support.SupportStatus(version='7.0.0'),
|
|
type=attributes.Schema.LIST
|
|
),
|
|
}
|
|
|
|
rolling_update_schema = {
|
|
MIN_IN_SERVICE: properties.Schema(
|
|
properties.Schema.INTEGER,
|
|
_('The minimum number of resources in service while '
|
|
'rolling updates are being executed.'),
|
|
constraints=[constraints.Range(min=0)],
|
|
default=0),
|
|
MAX_BATCH_SIZE: properties.Schema(
|
|
properties.Schema.INTEGER,
|
|
_('The maximum number of resources to replace at once.'),
|
|
constraints=[constraints.Range(min=1)],
|
|
default=1),
|
|
PAUSE_TIME: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
_('The number of seconds to wait between batches of '
|
|
'updates.'),
|
|
constraints=[constraints.Range(min=0)],
|
|
default=0),
|
|
}
|
|
|
|
batch_create_schema = {
|
|
MAX_BATCH_SIZE: properties.Schema(
|
|
properties.Schema.INTEGER,
|
|
_('The maximum number of resources to create at once.'),
|
|
constraints=[constraints.Range(min=1)],
|
|
default=1
|
|
),
|
|
PAUSE_TIME: properties.Schema(
|
|
properties.Schema.NUMBER,
|
|
_('The number of seconds to wait between batches.'),
|
|
constraints=[constraints.Range(min=0)],
|
|
default=0
|
|
),
|
|
}
|
|
|
|
update_policy_schema = {
|
|
ROLLING_UPDATE: properties.Schema(
|
|
properties.Schema.MAP,
|
|
schema=rolling_update_schema,
|
|
support_status=support.SupportStatus(version='5.0.0')
|
|
),
|
|
BATCH_CREATE: properties.Schema(
|
|
properties.Schema.MAP,
|
|
schema=batch_create_schema,
|
|
support_status=support.SupportStatus(version='5.0.0')
|
|
)
|
|
}
|
|
|
|
def get_size(self):
|
|
return self.properties.get(self.COUNT)
|
|
|
|
def validate_nested_stack(self):
|
|
# Only validate the resource definition (which may be a
|
|
# nested template) if count is non-zero, to enable folks
|
|
# to disable features via a zero count if they wish
|
|
if not self.get_size():
|
|
return
|
|
|
|
first_name = next(self._resource_names())
|
|
test_tmpl = self._assemble_nested([first_name],
|
|
include_all=True)
|
|
res_def = next(iter(test_tmpl.resource_definitions(None).values()))
|
|
# make sure we can resolve the nested resource type
|
|
self.stack.env.get_class_to_instantiate(res_def.resource_type)
|
|
|
|
try:
|
|
name = "%s-%s" % (self.stack.name, self.name)
|
|
nested_stack = self._parse_nested_stack(
|
|
name,
|
|
test_tmpl,
|
|
self.child_params())
|
|
nested_stack.strict_validate = False
|
|
nested_stack.validate()
|
|
except Exception as ex:
|
|
path = "%s<%s>" % (self.name, self.template_url)
|
|
raise exception.StackValidationFailed(
|
|
ex, path=[self.stack.t.RESOURCES, path])
|
|
|
|
def _current_skiplist(self):
|
|
db_rsrc_names = self.data().get('name_blacklist')
|
|
if db_rsrc_names:
|
|
return db_rsrc_names.split(',')
|
|
else:
|
|
return []
|
|
|
|
def _get_new_skiplist_entries(self, properties, current_skiplist):
|
|
insp = grouputils.GroupInspector.from_parent_resource(self)
|
|
|
|
# Now we iterate over the removal policies, and update the skiplist
|
|
# with any additional names
|
|
for r in properties.get(self.REMOVAL_POLICIES, []):
|
|
if self.REMOVAL_RSRC_LIST in r:
|
|
# Tolerate string or int list values
|
|
for n in r[self.REMOVAL_RSRC_LIST]:
|
|
str_n = str(n)
|
|
if (str_n in current_skiplist or
|
|
self.resource_id is None or
|
|
str_n in insp.member_names(include_failed=True)):
|
|
yield str_n
|
|
elif isinstance(n, str):
|
|
try:
|
|
refids = self.get_output(self.REFS_MAP)
|
|
except (exception.NotFound,
|
|
exception.TemplateOutputError) as op_err:
|
|
LOG.debug('Falling back to resource_by_refid() '
|
|
' due to %s', op_err)
|
|
rsrc = self.nested().resource_by_refid(n)
|
|
if rsrc is not None:
|
|
yield rsrc.name
|
|
else:
|
|
if refids is not None:
|
|
for name, refid in refids.items():
|
|
if refid == n:
|
|
yield name
|
|
break
|
|
|
|
# Clear output cache from prior to stack update, so we don't get
|
|
# outdated values after stack update.
|
|
self._outputs = None
|
|
|
|
def _update_name_skiplist(self, properties):
|
|
"""Resolve the remove_policies to names for removal."""
|
|
# To avoid reusing names after removal, we store a comma-separated
|
|
# skiplist in the resource data - in cases where you want to
|
|
# overwrite the stored data, removal_policies_mode: update can be used
|
|
curr_sl = set(self._current_skiplist())
|
|
p_mode = properties.get(self.REMOVAL_POLICIES_MODE,
|
|
self.REMOVAL_POLICY_APPEND)
|
|
if p_mode == self.REMOVAL_POLICY_UPDATE:
|
|
init_sl = set()
|
|
else:
|
|
init_sl = curr_sl
|
|
updated_sl = init_sl | set(self._get_new_skiplist_entries(properties,
|
|
curr_sl))
|
|
|
|
# If the skiplist has changed, update the resource data
|
|
if updated_sl != curr_sl:
|
|
self.data_set('name_blacklist', ','.join(sorted(updated_sl)))
|
|
|
|
def _name_skiplist(self):
|
|
"""Get the list of resource names to skiplist."""
|
|
sl = set(self._current_skiplist())
|
|
if self.resource_id is None:
|
|
sl |= set(self._get_new_skiplist_entries(self.properties, sl))
|
|
return sl
|
|
|
|
def _resource_names(self, size=None):
|
|
name_skiplist = self._name_skiplist()
|
|
if size is None:
|
|
size = self.get_size()
|
|
|
|
def is_skipped(name):
|
|
return name in name_skiplist
|
|
|
|
candidates = map(str, itertools.count())
|
|
|
|
return itertools.islice(itertools.filterfalse(is_skipped,
|
|
candidates),
|
|
size)
|
|
|
|
def _count_skipped(self, existing_members):
|
|
"""Return the number of current resource names that are skipped."""
|
|
return len(self._name_skiplist() & set(existing_members))
|
|
|
|
def handle_create(self):
|
|
self._update_name_skiplist(self.properties)
|
|
if self.update_policy.get(self.BATCH_CREATE) and self.get_size():
|
|
batch_create = self.update_policy[self.BATCH_CREATE]
|
|
max_batch_size = batch_create[self.MAX_BATCH_SIZE]
|
|
pause_sec = batch_create[self.PAUSE_TIME]
|
|
checkers = self._replace(0, max_batch_size, pause_sec)
|
|
if checkers:
|
|
checkers[0].start()
|
|
return checkers
|
|
else:
|
|
names = self._resource_names()
|
|
self.create_with_template(self._assemble_nested(names),
|
|
self.child_params())
|
|
|
|
def check_create_complete(self, checkers=None):
|
|
if checkers is None:
|
|
return super(ResourceGroup, self).check_create_complete()
|
|
for checker in checkers:
|
|
if not checker.started():
|
|
checker.start()
|
|
if not checker.step():
|
|
return False
|
|
return True
|
|
|
|
def _run_to_completion(self, template, timeout_mins):
|
|
updater = self.update_with_template(template, {},
|
|
timeout_mins)
|
|
|
|
while not super(ResourceGroup,
|
|
self).check_update_complete(updater):
|
|
yield
|
|
|
|
def _run_update(self, total_capacity, max_updates, timeout_mins):
|
|
template = self._assemble_for_rolling_update(total_capacity,
|
|
max_updates)
|
|
return self._run_to_completion(template, timeout_mins)
|
|
|
|
def check_update_complete(self, checkers):
|
|
for checker in checkers:
|
|
if not checker.started():
|
|
checker.start()
|
|
if not checker.step():
|
|
return False
|
|
return True
|
|
|
|
def res_def_changed(self, prop_diff):
|
|
return self.RESOURCE_DEF in prop_diff
|
|
|
|
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
|
|
if tmpl_diff:
|
|
# parse update policy
|
|
if tmpl_diff.update_policy_changed():
|
|
up = json_snippet.update_policy(self.update_policy_schema,
|
|
self.context)
|
|
self.update_policy = up
|
|
|
|
checkers = []
|
|
self.properties = json_snippet.properties(self.properties_schema,
|
|
self.context)
|
|
self._update_name_skiplist(self.properties)
|
|
if prop_diff and self.res_def_changed(prop_diff):
|
|
updaters = self._try_rolling_update()
|
|
if updaters:
|
|
checkers.extend(updaters)
|
|
|
|
if not checkers:
|
|
resizer = scheduler.TaskRunner(
|
|
self._run_to_completion,
|
|
self._assemble_nested(self._resource_names()),
|
|
self.stack.timeout_mins)
|
|
checkers.append(resizer)
|
|
|
|
checkers[0].start()
|
|
return checkers
|
|
|
|
def _attribute_output_name(self, *attr_path):
|
|
if attr_path[0] == self.REFS:
|
|
return self.REFS
|
|
return ', '.join(str(a) for a in attr_path)
|
|
|
|
def get_attribute(self, key, *path):
|
|
if key == self.REMOVED_RSRC_LIST:
|
|
return self._current_skiplist()
|
|
if key == self.ATTR_ATTRIBUTES and not path:
|
|
raise exception.InvalidTemplateAttribute(resource=self.name,
|
|
key=key)
|
|
|
|
is_resource_ref = (key.startswith("resource.") and
|
|
not path and (len(key.split('.', 2)) == 2))
|
|
if is_resource_ref:
|
|
output_name = self.REFS_MAP
|
|
else:
|
|
output_name = self._attribute_output_name(key, *path)
|
|
|
|
if self.resource_id is not None:
|
|
try:
|
|
output = self.get_output(output_name)
|
|
except (exception.NotFound,
|
|
exception.TemplateOutputError) as op_err:
|
|
LOG.debug('Falling back to grouputils due to %s', op_err)
|
|
else:
|
|
if is_resource_ref:
|
|
try:
|
|
target = key.split('.', 2)[1]
|
|
return output[target]
|
|
except KeyError:
|
|
raise exception.NotFound(_("Member '%(mem)s' not "
|
|
"found in group resource "
|
|
"'%(grp)s'.") %
|
|
{'mem': target,
|
|
'grp': self.name})
|
|
if key == self.REFS:
|
|
return attributes.select_from_attribute(output, path)
|
|
return output
|
|
|
|
if key.startswith("resource."):
|
|
return grouputils.get_nested_attrs(self, key, False, *path)
|
|
|
|
names = self._resource_names()
|
|
if key == self.REFS:
|
|
vals = [grouputils.get_rsrc_id(self, key, False, n) for n in names]
|
|
return attributes.select_from_attribute(vals, path)
|
|
if key == self.REFS_MAP:
|
|
refs_map = {n: grouputils.get_rsrc_id(self, key, False, n)
|
|
for n in names}
|
|
return refs_map
|
|
if key == self.ATTR_ATTRIBUTES:
|
|
return dict((n, grouputils.get_rsrc_attr(
|
|
self, key, False, n, *path)) for n in names)
|
|
|
|
path = [key] + list(path)
|
|
return [grouputils.get_rsrc_attr(self, key, False, n, *path)
|
|
for n in names]
|
|
|
|
def _nested_output_defns(self, resource_names, get_attr_fn, get_res_fn):
|
|
for attr in self.referenced_attrs():
|
|
if isinstance(attr, str):
|
|
key, path = attr, []
|
|
else:
|
|
key, path = attr[0], list(attr[1:])
|
|
output_name = self._attribute_output_name(key, *path)
|
|
value = None
|
|
|
|
if key.startswith("resource."):
|
|
keycomponents = key.split('.', 2)
|
|
res_name = keycomponents[1]
|
|
attr_path = keycomponents[2:] + path
|
|
if attr_path:
|
|
if res_name in resource_names:
|
|
value = get_attr_fn([res_name] + attr_path)
|
|
else:
|
|
output_name = key = self.REFS_MAP
|
|
elif key == self.ATTR_ATTRIBUTES and path:
|
|
value = {r: get_attr_fn([r] + path) for r in resource_names}
|
|
elif key not in self.ATTRIBUTES:
|
|
value = [get_attr_fn([r, key] + path) for r in resource_names]
|
|
|
|
if key == self.REFS:
|
|
value = [get_res_fn(r) for r in resource_names]
|
|
|
|
if value is not None:
|
|
yield output.OutputDefinition(output_name, value)
|
|
|
|
value = {r: get_res_fn(r) for r in resource_names}
|
|
yield output.OutputDefinition(self.REFS_MAP, value)
|
|
|
|
def build_resource_definition(self, res_name, res_defn):
|
|
res_def = copy.deepcopy(res_defn)
|
|
|
|
props = res_def.get(self.RESOURCE_DEF_PROPERTIES)
|
|
if props:
|
|
props = self._handle_repl_val(res_name, props)
|
|
|
|
res_type = res_def[self.RESOURCE_DEF_TYPE]
|
|
meta = res_def[self.RESOURCE_DEF_METADATA]
|
|
|
|
return rsrc_defn.ResourceDefinition(res_name, res_type, props, meta)
|
|
|
|
def get_resource_def(self, include_all=False):
|
|
"""Returns the resource definition portion of the group.
|
|
|
|
:param include_all: if False, only properties for the resource
|
|
definition that are not empty will be included
|
|
:type include_all: bool
|
|
:return: resource definition for the group
|
|
:rtype: dict
|
|
"""
|
|
|
|
# At this stage, we don't mind if all of the parameters have values
|
|
# assigned. Pass in a custom resolver to the properties to not
|
|
# error when a parameter does not have a user entered value.
|
|
def ignore_param_resolve(snippet, nullable=False):
|
|
if isinstance(snippet, function.Function):
|
|
try:
|
|
result = snippet.result()
|
|
except exception.UserParameterMissing:
|
|
return None
|
|
if not (nullable or function._non_null_value(result)):
|
|
result = None
|
|
return result
|
|
|
|
if isinstance(snippet, collections.abc.Mapping):
|
|
return dict(filter(function._non_null_item,
|
|
((k, ignore_param_resolve(v, nullable=True))
|
|
for k, v in snippet.items())))
|
|
elif (not isinstance(snippet, str) and
|
|
isinstance(snippet, collections.abc.Iterable)):
|
|
return list(filter(function._non_null_value,
|
|
(ignore_param_resolve(v, nullable=True)
|
|
for v in snippet)))
|
|
|
|
return snippet
|
|
|
|
self.properties.resolve = ignore_param_resolve
|
|
|
|
res_def = self.properties[self.RESOURCE_DEF]
|
|
if not include_all:
|
|
return self._clean_props(res_def)
|
|
return res_def
|
|
|
|
def _clean_props(self, res_defn):
|
|
res_def = copy.deepcopy(res_defn)
|
|
props = res_def.get(self.RESOURCE_DEF_PROPERTIES)
|
|
if props:
|
|
clean = dict((k, v) for k, v in props.items() if v is not None)
|
|
props = clean
|
|
res_def[self.RESOURCE_DEF_PROPERTIES] = props
|
|
return res_def
|
|
|
|
def _handle_repl_val(self, res_name, val):
|
|
repl_var = self.properties[self.INDEX_VAR]
|
|
|
|
def recurse(x):
|
|
return self._handle_repl_val(res_name, x)
|
|
|
|
if isinstance(val, str):
|
|
return val.replace(repl_var, res_name)
|
|
elif isinstance(val, collections.abc.Mapping):
|
|
return {k: recurse(v) for k, v in val.items()}
|
|
elif isinstance(val, collections.abc.Sequence):
|
|
return [recurse(v) for v in val]
|
|
return val
|
|
|
|
def _add_output_defns_to_template(self, tmpl, resource_names):
|
|
att_func = 'get_attr'
|
|
get_attr = functools.partial(tmpl.functions[att_func], None, att_func)
|
|
res_func = 'get_resource'
|
|
get_res = functools.partial(tmpl.functions[res_func], None, res_func)
|
|
for odefn in self._nested_output_defns(resource_names,
|
|
get_attr, get_res):
|
|
tmpl.add_output(odefn)
|
|
|
|
def _assemble_nested(self, names, include_all=False,
|
|
template_version=('heat_template_version',
|
|
'2015-04-30')):
|
|
|
|
def_dict = self.get_resource_def(include_all)
|
|
definitions = [(k, self.build_resource_definition(k, def_dict))
|
|
for k in names]
|
|
tmpl = scl_template.make_template(definitions,
|
|
version=template_version)
|
|
self._add_output_defns_to_template(tmpl, [k for k, d in definitions])
|
|
return tmpl
|
|
|
|
def child_template_files(self, child_env):
|
|
is_rolling_update = (self.action == self.UPDATE
|
|
and self.update_policy[self.ROLLING_UPDATE])
|
|
return grouputils.get_child_template_files(self.context,
|
|
self.stack,
|
|
is_rolling_update,
|
|
self.old_template_id)
|
|
|
|
def _assemble_for_rolling_update(self, total_capacity, max_updates,
|
|
include_all=False,
|
|
template_version=('heat_template_version',
|
|
'2015-04-30')):
|
|
names = list(self._resource_names(total_capacity))
|
|
name_skiplist = self._name_skiplist()
|
|
|
|
valid_resources = [(n, d) for n, d in
|
|
grouputils.get_member_definitions(self)
|
|
if n not in name_skiplist]
|
|
|
|
targ_cap = self.get_size()
|
|
|
|
def replace_priority(res_item):
|
|
name, defn = res_item
|
|
try:
|
|
index = names.index(name)
|
|
except ValueError:
|
|
# High priority - delete immediately
|
|
return 0
|
|
else:
|
|
if index < targ_cap:
|
|
# Update higher indices first
|
|
return targ_cap - index
|
|
else:
|
|
# Low priority - don't update
|
|
return total_capacity
|
|
|
|
old_resources = sorted(valid_resources, key=replace_priority)
|
|
existing_names = set(n for n, d in valid_resources)
|
|
new_names = itertools.filterfalse(lambda n: n in existing_names,
|
|
names)
|
|
res_def = self.get_resource_def(include_all)
|
|
definitions = scl_template.member_definitions(
|
|
old_resources, res_def,
|
|
total_capacity,
|
|
max_updates,
|
|
lambda: next(new_names),
|
|
self.build_resource_definition)
|
|
tmpl = scl_template.make_template(definitions,
|
|
version=template_version)
|
|
self._add_output_defns_to_template(tmpl, names)
|
|
return tmpl
|
|
|
|
def _try_rolling_update(self):
|
|
if self.update_policy[self.ROLLING_UPDATE]:
|
|
policy = self.update_policy[self.ROLLING_UPDATE]
|
|
return self._replace(policy[self.MIN_IN_SERVICE],
|
|
policy[self.MAX_BATCH_SIZE],
|
|
policy[self.PAUSE_TIME])
|
|
|
|
def _resolve_attribute(self, name):
|
|
if name == self.REMOVED_RSRC_LIST:
|
|
return self._current_skiplist()
|
|
|
|
def _update_timeout(self, batch_cnt, pause_sec):
|
|
total_pause_time = pause_sec * max(batch_cnt - 1, 0)
|
|
if total_pause_time >= self.stack.timeout_secs():
|
|
msg = _('The current update policy will result in stack update '
|
|
'timeout.')
|
|
raise ValueError(msg)
|
|
return self.stack.timeout_secs() - total_pause_time
|
|
|
|
@staticmethod
|
|
def _get_batches(targ_cap, curr_cap, batch_size, min_in_service):
|
|
updated = 0
|
|
|
|
while rolling_update.needs_update(targ_cap, curr_cap, updated):
|
|
new_cap, total_new = rolling_update.next_batch(targ_cap,
|
|
curr_cap,
|
|
updated,
|
|
batch_size,
|
|
min_in_service)
|
|
|
|
yield new_cap, total_new
|
|
|
|
updated += total_new - max(new_cap - max(curr_cap, targ_cap), 0)
|
|
curr_cap = new_cap
|
|
|
|
def _replace(self, min_in_service, batch_size, pause_sec):
|
|
|
|
def pause_between_batch(pause_sec):
|
|
duration = timeutils.Duration(pause_sec)
|
|
while not duration.expired():
|
|
yield
|
|
|
|
# current capacity not including existing skiplisted
|
|
inspector = grouputils.GroupInspector.from_parent_resource(self)
|
|
num_skiplist = self._count_skipped(
|
|
inspector.member_names(include_failed=False))
|
|
num_resources = inspector.size(include_failed=True)
|
|
curr_cap = num_resources - num_skiplist
|
|
|
|
batches = list(self._get_batches(self.get_size(), curr_cap, batch_size,
|
|
min_in_service))
|
|
update_timeout_secs = self._update_timeout(len(batches), pause_sec)
|
|
|
|
# NOTE(gibi) update_timeout is in seconds but the _run_update
|
|
# eventually calls StackResource.update_with_template that takes
|
|
# timeout in minutes so we need to convert here.
|
|
update_timeout_mins = math.ceil(update_timeout_secs / 60)
|
|
|
|
def tasks():
|
|
for index, (curr_cap, max_upd) in enumerate(batches):
|
|
yield scheduler.TaskRunner(self._run_update,
|
|
curr_cap, max_upd,
|
|
update_timeout_mins)
|
|
|
|
if index < (len(batches) - 1) and pause_sec > 0:
|
|
yield scheduler.TaskRunner(pause_between_batch, pause_sec)
|
|
|
|
return list(tasks())
|
|
|
|
def preview(self):
|
|
# NOTE(pas-ha) just need to use include_all in _assemble_nested,
|
|
# so this method is a simplified copy of preview() from StackResource,
|
|
# and next two lines are basically a modified copy of child_template()
|
|
names = self._resource_names()
|
|
child_template = self._assemble_nested(names, include_all=True)
|
|
params = self.child_params()
|
|
name = "%s-%s" % (self.stack.name, self.name)
|
|
self._nested = self._parse_nested_stack(name, child_template, params)
|
|
|
|
return self.nested().preview_resources()
|
|
|
|
def child_template(self):
|
|
names = self._resource_names()
|
|
return self._assemble_nested(names)
|
|
|
|
def child_params(self):
|
|
return {}
|
|
|
|
def handle_adopt(self, resource_data):
|
|
names = self._resource_names()
|
|
if names:
|
|
return self.create_with_template(self._assemble_nested(names),
|
|
{},
|
|
adopt_data=resource_data)
|
|
|
|
def get_nested_parameters_stack(self):
|
|
"""Return a nested group of size 1 for validation."""
|
|
names = self._resource_names(1)
|
|
child_template = self._assemble_nested(names)
|
|
params = self.child_params()
|
|
name = "%s-%s" % (self.stack.name, self.name)
|
|
return self._parse_nested_stack(name, child_template, params)
|
|
|
|
|
|
def resource_mapping():
|
|
return {
|
|
'OS::Heat::ResourceGroup': ResourceGroup,
|
|
}
|