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))