def result(self):
for_each = function.resolve(self._for_each)
keys = list(six.iterkeys(for_each))
lists = [for_each[key] for key in keys]
template = function.resolve(self._template)
return [self._do_replacement(keys, items, template)
for items in itertools.product(*lists)]
def result(self):
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Join/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Join/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Join/ result "))
strings = function.resolve(self._strings)
if strings is None:
strings = []
if (isinstance(strings, six.string_types) or
not isinstance(strings, collections.Sequence)):
raise TypeError(_('"%s" must operate on a list') % self.fn_name)
delim = function.resolve(self._delim)
if not isinstance(delim, six.string_types):
raise TypeError(_('"%s" delimiter must be a string') %
self.fn_name)
def ensure_string(s):
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Join/ ensure_string "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Join/ ensure_string "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Join/ ensure_string "))
if s is None:
return ''
if not isinstance(s, six.string_types):
raise TypeError(
_('Items to join must be strings %s') % (repr(s)[:200]))
return s
return delim.join(ensure_string(s) for s in strings)
def result(self):
template = function.resolve(self._string)
mapping = function.resolve(self._mapping)
if not isinstance(template, six.string_types):
raise TypeError(_('"%s" template must be a string') % self.fn_name)
if not isinstance(mapping, collections.Mapping):
raise TypeError(_('"%s" params must be a map') % self.fn_name)
def replace(strings, keys):
if not keys:
return strings
placeholder = keys[0]
if not isinstance(placeholder, six.string_types):
raise TypeError(_('"%s" param placeholders must be strings') %
self.fn_name)
remaining_keys = keys[1:]
value = self._validate_replacement(mapping[placeholder])
return [value.join(replace(s.split(placeholder),
remaining_keys)) for s in strings]
return replace([template], sorted(sorted(mapping),
key=len, reverse=True))[0]
def result(self):
template = function.resolve(self._string)
mapping = function.resolve(self._mapping)
if not isinstance(template, six.string_types):
raise TypeError(_('"%s" template must be a string') % self.fn_name)
if not isinstance(mapping, collections.Mapping):
raise TypeError(_('"%s" params must be a map') % self.fn_name)
def replace(string, change):
placeholder, value = change
if not isinstance(placeholder, six.string_types):
raise TypeError(_('"%s" param placeholders must be strings') %
self.fn_name)
if value is None:
value = ''
if not isinstance(value,
(six.string_types, six.integer_types,
float, bool)):
raise TypeError(_('"%s" params must be strings or numbers') %
self.fn_name)
return string.replace(placeholder, six.text_type(value))
return six.moves.reduce(replace, six.iteritems(mapping), template)
def check_with_update(self, with_policy=False, with_diff=False):
current = copy.deepcopy(template)
self.current_stack = utils.parse_stack(current)
self.current_grp = self.current_stack['group1']
current_grp_json = function.resolve(
self.current_grp.t)
prop_diff, tmpl_diff = None, None
updated = tmpl_with_updt_policy() if (
with_policy) else copy.deepcopy(template)
if with_diff:
res_def = updated['resources']['group1'][
'properties']['resource_def']
res_def['properties']['Foo'] = 'baz'
prop_diff = dict(
{'count': 2,
'resource_def': {'properties': {'Foo': 'baz'},
'type': 'OverwrittenFnGetRefIdType'}})
updated_stack = utils.parse_stack(updated)
updated_grp = updated_stack['group1']
updated_grp_json = function.resolve(updated_grp.t)
tmpl_diff = updated_grp.update_template_diff(
updated_grp_json, current_grp_json)
updated_policy = updated_grp_json[
'UpdatePolicy']if 'UpdatePolicy' in updated_grp_json else None
update_snippet = rsrc_defn.ResourceDefinition(
self.current_grp.name,
self.current_grp.type(),
properties=updated_grp_json['Properties'],
update_policy=updated_policy)
self.current_grp._replace = mock.Mock(return_value=[])
self.current_grp._assemble_nested_for_size = mock.Mock()
self.patchobject(scheduler.TaskRunner, 'start')
self.current_grp.handle_update(update_snippet, tmpl_diff, prop_diff)
def check_with_update(self, with_policy=False, with_diff=False):
current = copy.deepcopy(template)
self.current_stack = utils.parse_stack(current)
self.current_grp = self.current_stack["group1"]
current_grp_json = function.resolve(self.current_grp.t)
prop_diff, tmpl_diff = None, None
updated = tmpl_with_updt_policy() if (with_policy) else copy.deepcopy(template)
if with_diff:
res_def = updated["resources"]["group1"]["properties"]["resource_def"]
res_def["properties"]["Foo"] = "baz"
prop_diff = dict(
{"count": 2, "resource_def": {"properties": {"Foo": "baz"}, "type": "OverwrittenFnGetRefIdType"}}
)
updated_stack = utils.parse_stack(updated)
updated_grp = updated_stack["group1"]
updated_grp_json = function.resolve(updated_grp.t)
tmpl_diff = updated_grp.update_template_diff(updated_grp_json, current_grp_json)
updated_policy = updated_grp_json["UpdatePolicy"] if "UpdatePolicy" in updated_grp_json else None
update_snippet = rsrc_defn.ResourceDefinition(
self.current_grp.name,
self.current_grp.type(),
properties=updated_grp_json["Properties"],
update_policy=updated_policy,
)
self.current_grp._replace = mock.Mock(return_value=[])
self.current_grp._assemble_nested = mock.Mock()
self.patchobject(scheduler.TaskRunner, "start")
self.current_grp.handle_update(update_snippet, tmpl_diff, prop_diff)
def result(self):
strings = function.resolve(self._joinlist)
if strings is None:
strings = []
if (isinstance(strings, six.string_types) or
not isinstance(strings, collections.Sequence)):
raise TypeError(_('"%s" must operate on a list') % self.fn_name)
delim = function.resolve(self._delim)
if not isinstance(delim, six.string_types):
raise TypeError(_('"%s" delimiter must be a string') %
self.fn_name)
def ensure_string(s):
msg = _('Items to join must be string, map or list not %s'
) % (repr(s)[:200])
if s is None:
return ''
elif isinstance(s, six.string_types):
return s
elif isinstance(s, (collections.Mapping, collections.Sequence)):
try:
return jsonutils.dumps(s, default=None)
except TypeError:
msg = _('Items to join must be string, map or list. '
'%s failed json serialization'
) % (repr(s)[:200])
else:
msg = _('Items to join must be string, map or list not %s'
) % (repr(s)[:200])
raise TypeError(msg)
return delim.join(ensure_string(s) for s in strings)
def result(self):
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Replace/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Replace/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Replace/ result "))
template = function.resolve(self._string)
mapping = function.resolve(self._mapping)
if not isinstance(template, six.string_types):
raise TypeError(_('"%s" template must be a string') % self.fn_name)
if not isinstance(mapping, collections.Mapping):
raise TypeError(_('"%s" params must be a map') % self.fn_name)
def replace(string, change):
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Replace/ replace "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Replace/ replace "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Replace/ replace "))
placeholder, value = change
if not isinstance(placeholder, six.string_types):
raise TypeError(_('"%s" param placeholders must be strings') %
self.fn_name)
if value is None:
value = ''
if not isinstance(value,
(six.string_types, six.integer_types,
float, bool)):
raise TypeError(_('"%s" params must be strings or numbers') %
self.fn_name)
return string.replace(placeholder, unicode(value))
return reduce(replace, six.iteritems(mapping), template)
def validate_update_policy_diff(self, current, updated):
# load current stack
current_stack = utils.parse_stack(current)
current_grp = current_stack['group1']
current_grp_json = function.resolve(
current_grp.t)
updated_stack = utils.parse_stack(updated)
updated_grp = updated_stack['group1']
updated_grp_json = function.resolve(
updated_grp.t)
# identify the template difference
tmpl_diff = updated_grp.update_template_diff(
updated_grp_json, current_grp_json)
updated_policy = (updated_grp_json['UpdatePolicy']
if 'UpdatePolicy' in updated_grp_json else None)
expected = {u'UpdatePolicy': updated_policy}
self.assertEqual(expected, tmpl_diff)
# test application of the new update policy in handle_update
update_snippet = rsrc_defn.ResourceDefinition(
current_grp.name,
current_grp.type(),
properties=updated_grp_json['Properties'],
update_policy=updated_policy)
current_grp._try_rolling_update = mock.Mock()
current_grp._assemble_nested_for_size = mock.Mock()
self.patchobject(scheduler.TaskRunner, 'start')
current_grp.handle_update(update_snippet, tmpl_diff, None)
if updated_policy is None:
self.assertEqual({}, current_grp.update_policy.data)
else:
self.assertEqual(updated_policy, current_grp.update_policy.data)
def result(self):
template = function.resolve(self._string)
mapping = function.resolve(self._mapping)
if not isinstance(template, basestring):
raise TypeError(_('"%s" template must be a string') % self.fn_name)
if not isinstance(mapping, collections.Mapping):
raise TypeError(_('"%s" params must be a map') % self.fn_name)
def replace(string, change):
placeholder, value = change
if not isinstance(placeholder, basestring):
raise TypeError(_('"%s" param placeholders must be strings') %
self.fn_name)
if value is None:
value = ''
if not isinstance(value, (basestring, int, long, float, bool)):
raise TypeError(_('"%s" params must be strings or numbers') %
self.fn_name)
return string.replace(placeholder, unicode(value))
return reduce(replace, mapping.iteritems(), template)
def result(self):
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class FindInMap/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class FindInMap/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class FindInMap/ result "))
mapping = self.stack.t.maps[function.resolve(self._mapname)]
key = function.resolve(self._mapkey)
value = function.resolve(self._mapvalue)
return mapping[key][value]
def result(self):
path_components = function.resolve(self._path_components)
attribute = function.resolve(self._attribute)
r = self._resource()
if r.status in (r.IN_PROGRESS, r.COMPLETE) and r.action in (r.CREATE, r.ADOPT, r.SUSPEND, r.RESUME, r.UPDATE):
return r.FnGetAtt(attribute, *path_components)
else:
return None
def result(self):
path_components = function.resolve(self._path_components)
attribute = function.resolve(self._attribute)
resource = self._resource()
if self._result_ready(resource):
return resource.FnGetAtt(attribute, *path_components)
else:
return None
def _resource(self):
resource_name = function.resolve(self._resource_name)
try:
return self.stack[resource_name]
except KeyError:
raise exception.InvalidTemplateAttribute(
resource=resource_name,
key=function.resolve(self._attribute))
def result(self):
attr = function.resolve(self.args)
if attr == self.METADATA:
return self.stack.parent_resource.metadata_get()
elif attr == self.UPDATE_POLICY:
up = self.stack.parent_resource.t._update_policy or {}
return function.resolve(up)
elif attr == self.DELETION_POLICY:
return self.stack.parent_resource.t.deletion_policy()
def dep_attrs(self, resource_name):
if self._resource().name == resource_name:
path = function.resolve(self._path_components)
attr = [function.resolve(self._attribute)]
if path:
attrs = [tuple(attr + path)]
else:
attrs = attr
else:
attrs = []
return itertools.chain(function.dep_attrs(self.args, resource_name), attrs)
def result(self):
for_each = function.resolve(self._for_each)
if not all(self._valid_list(l) for l in for_each.values()):
raise TypeError(_('The values of the "for_each" argument to '
'"%s" must be lists') % self.fn_name)
template = function.resolve(self._template)
keys, lists = six.moves.zip(*for_each.items())
return [self._do_replacement(keys, replacements, template)
for replacements in itertools.product(*lists)]
def result(self):
data = function.resolve(self._data)
if not isinstance(data, collections.Mapping):
raise TypeError(_('The "data" argument to "%s" must contain '
'a map.') % self.fn_name)
ctxt = {'data': data}
self.context['$'] = ctxt
if not isinstance(self._expression, six.string_types):
self._expression = function.resolve(self._expression)
self.validate_expression(self._expression)
return self.parser(self._expression).evaluate(context=self.context)
def result(self):
attr = function.resolve(self.args)
if attr == self.METADATA:
return self.stack.parent_resource.metadata
elif attr == self.UPDATE_POLICY:
up = self.stack.parent_resource.t.get('UpdatePolicy', {})
return function.resolve(up)
elif attr == self.DELETION_POLICY:
dp = self.stack.parent_resource.t.get('DeletionPolicy', 'Delete')
return function.resolve(dp)
def result(self):
sequence = function.resolve(self._sequence)
if not sequence:
return sequence
if not isinstance(sequence, list):
raise TypeError(_('"%s" only works with lists') % self.fn_name)
values = function.resolve(self._values)
if not values:
return sequence
if not isinstance(values, list):
raise TypeError(
_('"%(fn)s" filters a list of values') % self.fn_name)
return [i for i in sequence if i not in values]
def result(self):
attr_name = function.resolve(self._attribute)
resource = self._resource()
if self._result_ready(resource):
attribute = resource.FnGetAtt(attr_name)
else:
attribute = None
if attribute is None:
return None
path_components = function.resolve(self._path_components)
return attributes.select_from_attribute(attribute, path_components)
def result(self):
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Select/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Select/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class Select/ result "))
index = function.resolve(self._lookup)
try:
index = int(index)
except (ValueError, TypeError):
pass
strings = function.resolve(self._strings)
if strings == '':
# an empty string is a common response from other
# functions when result is not currently available.
# Handle by returning an empty string
return ''
if isinstance(strings, six.string_types):
# might be serialized json.
try:
strings = jsonutils.loads(strings)
except ValueError as json_ex:
fmt_data = {'fn_name': self.fn_name,
'err': json_ex}
raise ValueError(_('"%(fn_name)s": %(err)s') % fmt_data)
if isinstance(strings, collections.Mapping):
if not isinstance(index, six.string_types):
raise TypeError(_('Index to "%s" must be a string') %
self.fn_name)
return strings.get(index, '')
if (isinstance(strings, collections.Sequence) and
not isinstance(strings, six.string_types)):
if not isinstance(index, six.integer_types):
raise TypeError(_('Index to "%s" must be an integer') %
self.fn_name)
try:
return strings[index]
except IndexError:
return ''
if strings is None:
return ''
raise TypeError(_('Arguments to %s not fully resolved') %
self.fn_name)
def result(self):
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class ResourceFacade/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class ResourceFacade/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class ResourceFacade/ result "))
attr = function.resolve(self.args)
if attr == self.METADATA:
return self.stack.parent_resource.metadata_get()
elif attr == self.UPDATE_POLICY:
up = self.stack.parent_resource.t.get('UpdatePolicy', {})
return function.resolve(up)
elif attr == self.DELETION_POLICY:
dp = self.stack.parent_resource.t.deletion_policy()
return function.resolve(dp)
def result(self):
for_each = function.resolve(self._for_each)
keys, lists = six.moves.zip(*for_each.items())
# use empty list for references(None) else validation will fail
values = [[] if value is None else value for value in lists]
if not all(self._valid_arg(l) for l in values):
raise TypeError(_('The values of the "for_each" argument to '
'"%s" must be lists') % self.fn_name)
template = function.resolve(self._template)
return [self._do_replacement(keys, replacements, template)
for replacements in itertools.product(*values)]
def rsrc_defn_item(name, snippet):
data = self.parse(stack, snippet)
depends = data.get(RES_DEPENDS_ON)
if isinstance(depends, six.string_types):
depends = [depends]
deletion_policy = function.resolve(data.get(RES_DELETION_POLICY))
if deletion_policy is not None:
if deletion_policy not in self.deletion_policies:
msg = _('Invalid deletion policy "%s"') % deletion_policy
raise exception.StackValidationFailed(message=msg)
else:
deletion_policy = self.deletion_policies[deletion_policy]
kwargs = {
'resource_type': data.get(RES_TYPE),
'properties': data.get(RES_PROPERTIES),
'metadata': data.get(RES_METADATA),
'depends': depends,
'deletion_policy': deletion_policy,
'update_policy': data.get(RES_UPDATE_POLICY),
'description': data.get(RES_DESCRIPTION) or ''
}
defn = rsrc_defn.ResourceDefinition(name, **kwargs)
return name, defn
def test_param_refs(self):
"""Test if parameter references work."""
tmpl = parser.Template(self.props_template)
env = environment.Environment(self.params)
stack = parser.Stack(utils.dummy_context(), 'test', tmpl, env)
self.assertEqual(self.expected,
function.resolve(tmpl.parse(stack, self.snippet)))
def rsrc_defn_from_snippet(cls, name, data):
depends = data.get(cls.RES_DEPENDS_ON)
if isinstance(depends, six.string_types):
depends = [depends]
deletion_policy = function.resolve(
data.get(cls.RES_DELETION_POLICY))
if deletion_policy is not None:
if deletion_policy not in cls.deletion_policies:
msg = _('Invalid deletion policy "%s"') % deletion_policy
raise exception.StackValidationFailed(message=msg)
else:
deletion_policy = cls.deletion_policies[deletion_policy]
kwargs = {
'resource_type': data.get(cls.RES_TYPE),
'properties': data.get(cls.RES_PROPERTIES),
'metadata': data.get(cls.RES_METADATA),
'depends': depends,
'deletion_policy': deletion_policy,
'update_policy': data.get(cls.RES_UPDATE_POLICY),
'description': None
}
for key in cls.extra_rsrc_defn:
kwargs[key] = data.get(key)
return rsrc_defn.ResourceDefinition(name, **kwargs)
def test_resolve_func(self):
func = TestFunction(None, "foo", ["bar", "baz"])
result = function.resolve(func)
self.assertEqual("wibble", result)
self.assertTrue(isinstance(result, str))
def result(self):
attribute = super(GetAttThenSelect, self).result()
if attribute is None:
return None
path_components = function.resolve(self._path_components)
return attributes.select_from_attribute(attribute, path_components)
def test_resolve_func(self):
func = TestFunction(None, 'foo', ['bar', 'baz'])
result = function.resolve(func)
self.assertEqual('wibble', result)
self.assertTrue(isinstance(result, str))
def _update_stored_properties(self):
self._stored_properties_data = function.resolve(self.properties.data)
def get_value(self):
"""Resolve the value of the output."""
if self._resolved_value is None:
self._resolved_value = function.resolve(self._value)
return self._resolved_value
def result(self):
statement = self._parse(function.resolve(self._expression))
data = function.resolve(self._data)
return statement.evaluate({'data': data}, self._yaql_context)
def result(self):
cd = function.resolve(self.condition)
return not self._get_condition(cd)
def result(self):
return any(
self._get_condition(cd) for cd in function.resolve(self.args))
def result(self):
resolved = function.resolve(self.args)
if not isinstance(resolved, six.string_types):
raise TypeError(_('"%s" argument must be a string') % self.fn_name)
return resolved
def result(self):
mapping = self.stack.t.maps[function.resolve(self._mapname)]
key = function.resolve(self._mapkey)
value = function.resolve(self._mapvalue)
return mapping[key][value]
def resolve(self, snippet):
return function.resolve(self.stack.t.parse(self.stack, snippet))
def update(self, after, before=None, prev_resource=None):
'''
update the resource. Subclasses should provide a handle_update() method
to customise update, the base-class handle_update will fail by default.
'''
action = self.UPDATE
(cur_class_def, cur_ver) = self.implementation_signature()
prev_ver = cur_ver
if prev_resource is not None:
(prev_class_def,
prev_ver) = prev_resource.implementation_signature()
if prev_class_def != cur_class_def:
raise UpdateReplace(self.name)
if before is None:
before = self.parsed_template()
if prev_ver == cur_ver and before == after:
return
if (self.action, self.status) in ((self.CREATE, self.IN_PROGRESS),
(self.UPDATE, self.IN_PROGRESS),
(self.ADOPT, self.IN_PROGRESS)):
exc = Exception(_('Resource update already requested'))
raise exception.ResourceFailure(exc, self, action)
LOG.info(_('updating %s') % str(self))
try:
self.updated_time = datetime.utcnow()
self.state_set(action, self.IN_PROGRESS)
before_properties = Properties(self.properties_schema,
before.get('Properties',
{}), function.resolve,
self.name, self.context)
after_properties = Properties(self.properties_schema,
after.get('Properties',
{}), function.resolve,
self.name, self.context)
after_properties.validate()
tmpl_diff = self.update_template_diff(function.resolve(after),
before)
prop_diff = self.update_template_diff_properties(
after_properties, before_properties)
if callable(getattr(self, 'handle_update', None)):
handle_data = self.handle_update(after, tmpl_diff, prop_diff)
yield
if callable(getattr(self, 'check_update_complete', None)):
while not self.check_update_complete(handle_data):
yield
except UpdateReplace:
with excutils.save_and_reraise_exception():
LOG.debug("Resource %s update requires replacement" %
self.name)
except Exception as ex:
LOG.exception(
_('update %(resource)s : %(err)s') % {
'resource': str(self),
'err': ex
})
failure = exception.ResourceFailure(ex, self, action)
self.state_set(action, self.FAILED, six.text_type(failure))
raise failure
else:
self.t = after
self.reparse()
self.state_set(action, self.COMPLETE)
def resolve(snippet, template, stack=None):
return function.resolve(template.parse(stack, snippet))
def result(self):
args = function.resolve(self.args)
self.validate_usage(args)
return self.digest(*args)
def deletion_policy(self):
"""Return the deletion policy for the resource.
The policy will be one of those listed in DELETION_POLICIES.
"""
return function.resolve(self._deletion_policy) or self.DELETE
def result(self):
resolved_v1 = function.resolve(self.value1)
resolved_v2 = function.resolve(self.value2)
return resolved_v1 == resolved_v2
def metadata(self):
"""Return the resource metadata."""
return function.resolve(self._metadata) or {}
def _resource(self):
resource_name = function.resolve(self.args)
return self.stack[resource_name]
def external_id(self):
"""Return the external resource id."""
return function.resolve(self._external_id)
def _res_name(self):
return function.resolve(self._resource_name)
def condition(self):
"""Return the name of the conditional inclusion rule, if any.
Returns None if the resource is included unconditionally.
"""
return function.resolve(self._condition)
def _rsrc_defn_args(self, stack, name, data):
if self.RES_TYPE not in data:
args = {'name': name, 'type_key': self.RES_TYPE}
msg = _('Resource %(name)s is missing "%(type_key)s"') % args
raise KeyError(msg)
parse = functools.partial(self.parse, stack)
def no_parse(field, path):
return field
yield ('resource_type',
self._parse_resource_field(self.RES_TYPE, str, 'string', name,
data, parse))
yield ('properties',
self._parse_resource_field(
self.RES_PROPERTIES,
(collections.abc.Mapping, function.Function), 'object',
name, data, parse))
yield ('metadata',
self._parse_resource_field(
self.RES_METADATA,
(collections.abc.Mapping, function.Function), 'object',
name, data, parse))
depends = self._parse_resource_field(self.RES_DEPENDS_ON,
collections.abc.Sequence,
'list or string', name, data,
no_parse)
if isinstance(depends, str):
depends = [depends]
elif depends:
for dep in depends:
if not isinstance(dep, str):
msg = _('Resource %(name)s %(key)s '
'must be a list of strings') % {
'name': name,
'key': self.RES_DEPENDS_ON
}
raise exception.StackValidationFailed(message=msg)
yield 'depends', depends
del_policy = self._parse_resource_field(self.RES_DELETION_POLICY,
(str, function.Function),
'string', name, data, parse)
deletion_policy = function.resolve(del_policy)
if deletion_policy is not None:
if deletion_policy not in self.deletion_policies:
msg = _('Invalid deletion policy "%s"') % deletion_policy
raise exception.StackValidationFailed(message=msg)
else:
deletion_policy = self.deletion_policies[deletion_policy]
yield 'deletion_policy', deletion_policy
yield ('update_policy',
self._parse_resource_field(
self.RES_UPDATE_POLICY,
(collections.abc.Mapping, function.Function), 'object',
name, data, parse))
yield ('description',
self._parse_resource_field(self.RES_DESCRIPTION, str, 'string',
name, data, no_parse))
def result(self):
statement = self._parse(function.resolve(self._expression))
data = function.resolve(self._data)
context = self._context.create_child_context()
return statement.evaluate({'data': data}, context)
def test_resolve_func_with_null(self):
func = NullFunction(None, 'foo', ['bar', 'baz'])
self.assertIsNone(function.resolve(func))
self.assertIs(Ellipsis, function.resolve(func, nullable=True))
def serialize_template(t):
return json.dumps(function.resolve(t), sort_keys=True)
def resolve_runtime_data(self, snippet):
return function.resolve(snippet)
def resolve_runtime_data(self, snippet):
"""DEPRECATED. Use heat.engine.function.resolve() instead."""
warnings.warn(
'Stack.resolve_runtime_data() is deprecated. '
'Use heat.engine.function.resolve() instead', DeprecationWarning)
return function.resolve(snippet)
def _resolve(self, condition_name):
resolved = function.resolve(self._conditions[condition_name])
self._check_condition_type(condition_name, resolved)
return resolved
def join(raw):
tmpl = template.Template(mapping_template)
return function.resolve(tmpl.parse(None, raw))
