ansible-core 2.18.5rc1__py3-none-any.whl → 2.19.0b1__py3-none-any.whl

ansible/plugins/strategy/linear.py

@@ -16,7 +16,7 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
     name: linear
     short_description: Executes tasks in a linear fashion
     description:
@@ -27,29 +27,32 @@ DOCUMENTATION = '''
     notes:
      - This was the default Ansible behaviour before 'strategy plugins' were introduced in 2.0.
     author: Ansible Core Team
-'''
+"""
 
 from ansible import constants as C
-from ansible.errors import AnsibleError, AnsibleAssertionError, AnsibleParserError
-from ansible.module_utils.common.text.converters import to_text
+from ansible.errors import AnsibleError, AnsibleAssertionError, AnsibleParserError, AnsibleValueOmittedError
 from ansible.playbook.handler import Handler
 from ansible.playbook.included_file import IncludedFile
 from ansible.plugins.loader import action_loader
 from ansible.plugins.strategy import StrategyBase
-from ansible.template import Templar
+from ansible._internal._templating._engine import TemplateEngine
 from ansible.utils.display import Display
+from ansible.inventory.host import Host
+from ansible.playbook.task import Task
+from ansible.executor.play_iterator import PlayIterator
 
 display = Display()
 
 
 class StrategyModule(StrategyBase):
 
-    def _get_next_task_lockstep(self, hosts, iterator):
-        '''
+    def _get_next_task_lockstep(self, hosts: list[Host], iterator: PlayIterator) -> list[tuple[Host, Task]]:
+        """
         Returns a list of (host, task) tuples, where the task may
         be a noop task to keep the iterator in lock step across
         all hosts.
-        '''
+        """
+
         state_task_per_host = {}
         for host in hosts:
             state, task = iterator.get_next_task_for_host(host, peek=True)
@@ -84,17 +87,17 @@ class StrategyModule(StrategyBase):
                 iterator.set_state_for_host(host.name, state)
                 host_tasks.append((host, task))
 
-        if cur_task.action in C._ACTION_META and cur_task.args.get('_raw_params') == 'flush_handlers':
+        if cur_task._get_meta() == 'flush_handlers':
             iterator.all_tasks[iterator.cur_task:iterator.cur_task] = [h for b in iterator._play.handlers for h in b.block]
 
         return host_tasks
 
     def run(self, iterator, play_context):
-        '''
+        """
         The linear strategy is simple - get the next task and queue
         it for all hosts, then wait for the queue to drain before
         moving on to the next task
-        '''
+        """
 
         # iterate over each task, while there is one left to run
         result = self._tqm.RUN_OK
@@ -130,26 +133,23 @@ class StrategyModule(StrategyBase):
                     run_once = False
                     work_to_do = True
 
-                    # check to see if this task should be skipped, due to it being a member of a
-                    # role which has already run (and whether that role allows duplicate execution)
-                    if not isinstance(task, Handler) and task._role:
-                        role_obj = self._get_cached_role(task, iterator._play)
-                        if role_obj.has_run(host) and task._role._metadata.allow_duplicates is False:
-                            display.debug("'%s' skipped because role has already run" % task)
-                            continue
+                    host_name = host.get_name()
 
                     display.debug("getting variables")
                     task_vars = self._variable_manager.get_vars(play=iterator._play, host=host, task=task,
                                                                 _hosts=self._hosts_cache, _hosts_all=self._hosts_cache_all)
                     self.add_tqm_variables(task_vars, play=iterator._play)
-                    templar = Templar(loader=self._loader, variables=task_vars)
+                    templar = TemplateEngine(loader=self._loader, variables=task_vars)
                     display.debug("done getting variables")
 
                     # test to see if the task across all hosts points to an action plugin which
                     # sets BYPASS_HOST_LOOP to true, or if it has run_once enabled. If so, we
                     # will only send this task to the first host in the list.
 
-                    task_action = templar.template(task.action)
+                    try:
+                        task_action = templar.template(task.action)
+                    except AnsibleValueOmittedError:
+                        raise AnsibleParserError("Omit is not valid for the `action` keyword.", obj=task.action) from None
 
                     try:
                         action = action_loader.get(task_action, class_only=True, collection_list=task.collections)
@@ -162,7 +162,7 @@ class StrategyModule(StrategyBase):
                         # for the linear strategy, we run meta tasks just once and for
                         # all hosts currently being iterated over rather than one host
                         results.extend(self._execute_meta(task, play_context, iterator, host))
-                        if task.args.get('_raw_params', None) not in ('noop', 'reset_connection', 'end_host', 'role_complete', 'flush_handlers', 'end_role'):
+                        if task._get_meta() not in ('noop', 'reset_connection', 'end_host', 'role_complete', 'flush_handlers', 'end_role'):
                             run_once = True
                         if (task.any_errors_fatal or run_once) and not task.ignore_errors:
                             any_errors_fatal = True
@@ -176,22 +176,20 @@ class StrategyModule(StrategyBase):
                                 break
 
                         run_once = action and getattr(action, 'BYPASS_HOST_LOOP', False) or templar.template(task.run_once)
-                        try:
-                            task.name = to_text(templar.template(task.name, fail_on_undefined=False), nonstring='empty')
-                        except Exception as e:
-                            display.debug(f"Failed to templalte task name ({task.name}), ignoring error and continuing: {e}")
 
                         if (task.any_errors_fatal or run_once) and not task.ignore_errors:
                             any_errors_fatal = True
 
                         if not callback_sent:
+                            task.post_validate_attribute("name", templar=templar)
+
                             if isinstance(task, Handler):
                                 self._tqm.send_callback('v2_playbook_on_handler_task_start', task)
                             else:
                                 self._tqm.send_callback('v2_playbook_on_task_start', task, is_conditional=False)
                             callback_sent = True
 
-                        self._blocked_hosts[host.get_name()] = True
+                        self._blocked_hosts[host_name] = True
                         self._queue_task(host, task, task_vars, play_context)
                         del task_vars
 
@@ -283,11 +281,12 @@ class StrategyModule(StrategyBase):
                             display.debug("done iterating over new_blocks loaded from include file")
                         except AnsibleParserError:
                             raise
-                        except AnsibleError as e:
-                            display.error(to_text(e), wrap_text=False)
+                        except AnsibleError as ex:
+                            # FIXME: send the error to the callback; don't directly write to display here
+                            display.error(ex)
                             for r in included_file._results:
                                 r._result['failed'] = True
-                                r._result['reason'] = str(e)
+                                r._result['reason'] = str(ex)
                                 self._tqm._stats.increment('failures', r._host.name)
                                 self._tqm.send_callback('v2_runner_on_failed', r)
                                 failed_includes_hosts.add(r._host)
@@ -355,10 +354,9 @@ class StrategyModule(StrategyBase):
                     return result
                 display.debug("done checking to see if all hosts have failed")
 
-            except (IOError, EOFError) as e:
-                display.debug("got IOError/EOFError in task loop: %s" % e)
-                # most likely an abort, return failed
-                return self._tqm.RUN_UNKNOWN_ERROR
+            finally:
+                # removed unnecessary exception handler, don't want to mis-attribute the entire code block by changing indentation
+                pass
 
         # run the base class run() method, which executes the cleanup function
         # and runs any outstanding handlers which have been triggered

ansible/plugins/terminal/__init__.py

@@ -26,7 +26,7 @@ from ansible.errors import AnsibleConnectionFailure
 
 
 class TerminalBase(ABC):
-    '''
+    """
     A base class for implementing cli connections
 
     .. note:: Unlike most of Ansible, nearly all strings in
@@ -36,7 +36,7 @@ class TerminalBase(ABC):
         :func:`~ansible.module_utils.common.text.converters.to_bytes` and
         :func:`~ansible.module_utils.common.text.converters.to_text` to avoid unexpected
         problems.
-    '''
+    """
 
     #: compiled bytes regular expressions as stdout
     terminal_stdout_re = []  # type: list[re.Pattern]
@@ -64,11 +64,11 @@ class TerminalBase(ABC):
         self._connection = connection
 
     def _exec_cli_command(self, cmd, check_rc=True):
-        '''
+        """
         Executes the CLI command on the remote device and returns the output
 
         :arg cmd: Byte string command to be executed
-        '''
+        """
         return self._connection.exec_command(cmd)
 
     def _get_prompt(self):

ansible/plugins/test/__init__.py

@@ -3,10 +3,15 @@
 
 from __future__ import annotations
 
+import typing as t
+
 from ansible.plugins import AnsibleJinja2Plugin
 
 
 class AnsibleJinja2Test(AnsibleJinja2Plugin):
+    @property
+    def plugin_type(self) -> str:
+        return "test"
 
-    def _no_options(self, *args, **kwargs):
-        raise NotImplementedError("Jinaj2 test plugins do not support option functions, they use direct arguments instead.")
+    def _no_options(self, *args, **kwargs) -> t.NoReturn:
+        raise NotImplementedError("Jinja2 test plugins do not support option functions, they use direct arguments instead.")

ansible/plugins/test/core.py

@@ -17,17 +17,22 @@
 
 from __future__ import annotations
 
+import functools
 import re
 import operator as py_operator
 
 from collections.abc import MutableMapping, MutableSequence
 
+from jinja2.tests import test_defined, test_undefined
+
 from ansible.module_utils.compat.version import LooseVersion, StrictVersion
 
 from ansible import errors
 from ansible.module_utils.common.text.converters import to_native, to_text, to_bytes
+from ansible._internal._templating._jinja_common import Marker, UndefinedMarker
 from ansible.module_utils.parsing.convert_bool import boolean
-from ansible.parsing.vault import is_encrypted_file
+from ansible.plugins import accept_args_markers
+from ansible.parsing.vault import is_encrypted_file, VaultHelper, VaultLib
 from ansible.utils.display import Display
 from ansible.utils.version import SemanticVersion
 
@@ -41,38 +46,38 @@ display = Display()
 
 
 def timedout(result):
-    ''' Test if task result yields a time out'''
+    """ Test if task result yields a time out"""
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'timedout' test expects a dictionary")
     return result.get('timedout', False) and result['timedout'].get('period', False)
 
 
 def failed(result):
-    ''' Test if task result yields failed '''
+    """ Test if task result yields failed """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'failed' test expects a dictionary")
     return result.get('failed', False)
 
 
 def success(result):
-    ''' Test if task result yields success '''
+    """ Test if task result yields success """
     return not failed(result)
 
 
 def unreachable(result):
-    ''' Test if task result yields unreachable '''
+    """ Test if task result yields unreachable """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'unreachable' test expects a dictionary")
     return result.get('unreachable', False)
 
 
 def reachable(result):
-    ''' Test if task result yields reachable '''
+    """ Test if task result yields reachable """
     return not unreachable(result)
 
 
 def changed(result):
-    ''' Test if task result yields changed '''
+    """ Test if task result yields changed """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'changed' test expects a dictionary")
     if 'changed' not in result:
@@ -92,14 +97,14 @@ def changed(result):
 
 
 def skipped(result):
-    ''' Test if task result yields skipped '''
+    """ Test if task result yields skipped """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'skipped' test expects a dictionary")
     return result.get('skipped', False)
 
 
 def started(result):
-    ''' Test if async task has started '''
+    """ Test if async task has started """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'started' test expects a dictionary")
     if 'started' in result:
@@ -113,7 +118,7 @@ def started(result):
 
 
 def finished(result):
-    ''' Test if async task has finished '''
+    """ Test if async task has finished """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'finished' test expects a dictionary")
     if 'finished' in result:
@@ -127,12 +132,10 @@ def finished(result):
 
 
 def regex(value='', pattern='', ignorecase=False, multiline=False, match_type='search'):
-    ''' Expose `re` as a boolean filter using the `search` method by default.
+    """ Expose `re` as a boolean filter using the `search` method by default.
         This is likely only useful for `search` and `match` which already
         have their own filters.
-    '''
-    # In addition to ensuring the correct type, to_text here will ensure
-    # _fail_with_undefined_error happens if the value is Undefined
+    """
     value = to_text(value, errors='surrogate_or_strict')
     flags = 0
     if ignorecase:
@@ -143,12 +146,19 @@ def regex(value='', pattern='', ignorecase=False, multiline=False, match_type='s
     return bool(getattr(_re, match_type, 'search')(value))
 
 
-def vault_encrypted(value):
+@accept_args_markers
+def vault_encrypted(value: object) -> bool:
     """Evaluate whether a variable is a single vault encrypted value
 
     .. versionadded:: 2.10
     """
-    return getattr(value, '__ENCRYPTED__', False) and value.is_encrypted()
+    if ciphertext := VaultHelper.get_ciphertext(value, with_tags=False):
+        return VaultLib.is_encrypted(ciphertext)
+
+    if isinstance(value, Marker):
+        value.trip()
+
+    return False
 
 
 def vaulted_file(value):
@@ -164,17 +174,17 @@ def vaulted_file(value):
 
 
 def match(value, pattern='', ignorecase=False, multiline=False):
-    ''' Perform a `re.match` returning a boolean '''
+    """ Perform a `re.match` returning a boolean """
     return regex(value, pattern, ignorecase, multiline, 'match')
 
 
 def search(value, pattern='', ignorecase=False, multiline=False):
-    ''' Perform a `re.search` returning a boolean '''
+    """ Perform a `re.search` returning a boolean """
     return regex(value, pattern, ignorecase, multiline, 'search')
 
 
 def version_compare(value, version, operator='eq', strict=None, version_type=None):
-    ''' Perform a version comparison on a value '''
+    """ Perform a version comparison on a value """
     op_map = {
         '==': 'eq', '=': 'eq', 'eq': 'eq',
         '<': 'lt', 'lt': 'lt',
@@ -257,8 +267,28 @@ def falsy(value, convert_bool=False):
     return not truthy(value, convert_bool=convert_bool)
 
 
+@accept_args_markers
+@functools.wraps(test_defined)
+def wrapped_test_defined(value: object) -> Marker | bool:
+    """Wrapper around Jinja's `defined` test to avoid mutating the externally-owned function with our marker attribute."""
+    if isinstance(value, Marker) and not isinstance(value, UndefinedMarker):
+        return value
+
+    return test_defined(value)
+
+
+@accept_args_markers
+@functools.wraps(test_undefined)
+def wrapped_test_undefined(value: object) -> Marker | bool:
+    """Wrapper around Jinja's `undefined` test to avoid mutating the externally-owned function with our marker attribute."""
+    if isinstance(value, Marker) and not isinstance(value, UndefinedMarker):
+        return value
+
+    return test_undefined(value)
+
+
 class TestModule(object):
-    ''' Ansible core jinja2 tests '''
+    """ Ansible core jinja2 tests """
 
     def tests(self):
         return {
@@ -304,4 +334,8 @@ class TestModule(object):
             # vault
             'vault_encrypted': vault_encrypted,
             'vaulted_file': vaulted_file,
+
+            # overrides that require special arg handling
+            'defined': wrapped_test_defined,
+            'undefined': wrapped_test_undefined,
         }

ansible/plugins/test/files.py

@@ -21,7 +21,7 @@ from os.path import isdir, isfile, isabs, exists, lexists, islink, samefile, ism
 
 
 class TestModule(object):
-    ''' Ansible file jinja2 tests '''
+    """ Ansible file jinja2 tests """
 
     def tests(self):
         return {

ansible/plugins/test/mathstuff.py

@@ -36,15 +36,15 @@ def isnotanumber(x):
 
 
 def contains(seq, value):
-    '''Opposite of the ``in`` test, allowing use as a test in filters like ``selectattr``
+    """Opposite of the ``in`` test, allowing use as a test in filters like ``selectattr``
 
     .. versionadded:: 2.8
-    '''
+    """
     return value in seq
 
 
 class TestModule:
-    ''' Ansible math jinja2 tests '''
+    """ Ansible math jinja2 tests """
 
     def tests(self):
         return {

ansible/plugins/test/uri.py

@@ -6,7 +6,7 @@ from urllib.parse import urlparse
 
 
 def is_uri(value, schemes=None):
-    ''' Will verify that the string passed is a valid 'URI', if given a list of valid schemes it will match those '''
+    """ Will verify that the string passed is a valid 'URI', if given a list of valid schemes it will match those """
     try:
         x = urlparse(value)
         isit = all([x.scheme is not None, x.path is not None, not schemes or x.scheme in schemes])
@@ -16,7 +16,7 @@ def is_uri(value, schemes=None):
 
 
 def is_url(value, schemes=None):
-    ''' Will verify that the string passed is a valid 'URL' '''
+    """ Will verify that the string passed is a valid 'URL' """
 
     isit = is_uri(value, schemes)
     if isit:
@@ -33,7 +33,7 @@ def is_urn(value):
 
 
 class TestModule(object):
-    ''' Ansible URI jinja2 test '''
+    """ Ansible URI jinja2 test """
 
     def tests(self):
         return {

ansible/plugins/vars/host_group_vars.py

@@ -17,7 +17,7 @@
 #############################################
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
     name: host_group_vars
     version_added: "2.4"
     short_description: In charge of loading group_vars and host_vars
@@ -50,7 +50,7 @@ DOCUMENTATION = '''
         elements: string
     extends_documentation_fragment:
       - vars_plugin_staging
-'''
+"""
 
 import os
 from ansible.errors import AnsibleParserError
@@ -63,7 +63,6 @@ from ansible.utils.vars import combine_vars
 CANONICAL_PATHS = {}  # type: dict[str, str]
 FOUND = {}  # type: dict[str, list[str]]
 NAK = set()  # type: set[str]
-PATH_CACHE = {}  # type: dict[tuple[str, str], str]
 
 
 class VarsModule(BaseVarsPlugin):
@@ -73,13 +72,13 @@ class VarsModule(BaseVarsPlugin):
 
     def load_found_files(self, loader, data, found_files):
         for found in found_files:
-            new_data = loader.load_from_file(found, cache='all', unsafe=True)
+            new_data = loader.load_from_file(found, cache='all', unsafe=True, trusted_as_template=True)
             if new_data:  # ignore empty files
                 data = combine_vars(data, new_data)
         return data
 
     def get_vars(self, loader, path, entities, cache=True):
-        ''' parses the inventory file '''
+        """ parses the inventory file """
 
         if not isinstance(entities, list):
             entities = [entities]
@@ -119,21 +118,15 @@ class VarsModule(BaseVarsPlugin):
                     else:
                         raise AnsibleParserError("Supplied entity must be Host or Group, got %s instead" % (type(entity)))
 
-                    if cache:
-                        try:
-                            opath = PATH_CACHE[(realpath_basedir, subdir)]
-                        except KeyError:
-                            opath = PATH_CACHE[(realpath_basedir, subdir)] = os.path.join(realpath_basedir, subdir)
+                    opath = os.path.join(realpath_basedir, subdir)
+                    key = '%s.%s' % (entity_name, opath)
 
+                    if cache:
                         if opath in NAK:
                             continue
-                        key = '%s.%s' % (entity_name, opath)
                         if key in FOUND:
                             data = self.load_found_files(loader, data, FOUND[key])
                             continue
-                    else:
-                        opath = PATH_CACHE[(realpath_basedir, subdir)] = os.path.join(realpath_basedir, subdir)
-
                     if os.path.isdir(opath):
                         self._display.debug("\tprocessing dir %s" % opath)
                         FOUND[key] = found_files = loader.find_vars_files(opath, entity_name)

ansible/release.py

@@ -17,6 +17,6 @@
 
 from __future__ import annotations
 
-__version__ = '2.18.5rc1'
+__version__ = '2.19.0b1'
 __author__ = 'Ansible, Inc.'
-__codename__ = "Fool in the Rain"
+__codename__ = "What Is and What Should Never Be"