From 8a754e0858d922e955e71b253c139e071ecec432 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 28 Apr 2024 18:04:21 +0200 Subject: Adding upstream version 2.14.3. Signed-off-by: Daniel Baumann --- lib/ansible/template/vars.py | 128 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 lib/ansible/template/vars.py (limited to 'lib/ansible/template/vars.py') diff --git a/lib/ansible/template/vars.py b/lib/ansible/template/vars.py new file mode 100644 index 0000000..fd1b812 --- /dev/null +++ b/lib/ansible/template/vars.py @@ -0,0 +1,128 @@ +# (c) 2012, Michael DeHaan +# +# This file is part of Ansible +# +# Ansible is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Ansible is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Ansible. If not, see . + +# Make coding more python3-ish +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +from collections.abc import Mapping + +from jinja2.utils import missing + +from ansible.errors import AnsibleError, AnsibleUndefinedVariable +from ansible.module_utils._text import to_native + + +__all__ = ['AnsibleJ2Vars'] + + +class AnsibleJ2Vars(Mapping): + ''' + Helper class to template all variable content before jinja2 sees it. This is + done by hijacking the variable storage that jinja2 uses, and overriding __contains__ + and __getitem__ to look like a dict. Added bonus is avoiding duplicating the large + hashes that inject tends to be. + + To facilitate using builtin jinja2 things like range, globals are also handled here. + ''' + + def __init__(self, templar, globals, locals=None): + ''' + Initializes this object with a valid Templar() object, as + well as several dictionaries of variables representing + different scopes (in jinja2 terminology). + ''' + + self._templar = templar + self._globals = globals + self._locals = dict() + if isinstance(locals, dict): + for key, val in locals.items(): + if val is not missing: + if key[:2] == 'l_': + self._locals[key[2:]] = val + elif key not in ('context', 'environment', 'template'): + self._locals[key] = val + + def __contains__(self, k): + if k in self._locals: + return True + if k in self._templar.available_variables: + return True + if k in self._globals: + return True + return False + + def __iter__(self): + keys = set() + keys.update(self._templar.available_variables, self._locals, self._globals) + return iter(keys) + + def __len__(self): + keys = set() + keys.update(self._templar.available_variables, self._locals, self._globals) + return len(keys) + + def __getitem__(self, varname): + if varname in self._locals: + return self._locals[varname] + if varname in self._templar.available_variables: + variable = self._templar.available_variables[varname] + elif varname in self._globals: + return self._globals[varname] + else: + raise KeyError("undefined variable: %s" % varname) + + # HostVars is special, return it as-is, as is the special variable + # 'vars', which contains the vars structure + from ansible.vars.hostvars import HostVars + if isinstance(variable, dict) and varname == "vars" or isinstance(variable, HostVars) or hasattr(variable, '__UNSAFE__'): + return variable + else: + value = None + try: + value = self._templar.template(variable) + except AnsibleUndefinedVariable as e: + # Instead of failing here prematurely, return an Undefined + # object which fails only after its first usage allowing us to + # do lazy evaluation and passing it into filters/tests that + # operate on such objects. + return self._templar.environment.undefined( + hint=f"{variable}: {e.message}", + name=varname, + exc=AnsibleUndefinedVariable, + ) + except Exception as e: + msg = getattr(e, 'message', None) or to_native(e) + raise AnsibleError("An unhandled exception occurred while templating '%s'. " + "Error was a %s, original message: %s" % (to_native(variable), type(e), msg)) + + return value + + def add_locals(self, locals): + ''' + If locals are provided, create a copy of self containing those + locals in addition to what is already in this variable proxy. + ''' + if locals is None: + return self + + # prior to version 2.9, locals contained all of the vars and not just the current + # local vars so this was not necessary for locals to propagate down to nested includes + new_locals = self._locals | locals + + return AnsibleJ2Vars(self._templar, self._globals, locals=new_locals) -- cgit v1.2.3