ansible-core 2.19.0b1__py3-none-any.whl → 2.19.0b3__py3-none-any.whl

ansible/plugins/strategy/__init__.py

@@ -26,6 +26,7 @@ import sys
 import threading
 import time
 import typing as t
+import collections.abc as _c
 
 from collections import deque
 
@@ -35,13 +36,13 @@ from ansible import context
 from ansible.errors import AnsibleError, AnsibleFileNotFound, AnsibleParserError, AnsibleTemplateError
 from ansible.executor.play_iterator import IteratingStates, PlayIterator
 from ansible.executor.process.worker import WorkerProcess
-from ansible.executor.task_result import TaskResult
+from ansible.executor.task_result import _RawTaskResult, _WireTaskResult
 from ansible.executor.task_queue_manager import CallbackSend, DisplaySend, PromptSend, TaskQueueManager
-from ansible.module_utils.six import string_types
 from ansible.module_utils.common.text.converters import to_text
 from ansible.module_utils.connection import Connection, ConnectionError
 from ansible.playbook.handler import Handler
 from ansible.playbook.helpers import load_list_of_blocks
+from ansible.playbook.included_file import IncludedFile
 from ansible.playbook.task import Task
 from ansible.playbook.task_include import TaskInclude
 from ansible.plugins import loader as plugin_loader
@@ -89,7 +90,9 @@ def _get_item_vars(result, task):
     return item_vars
 
 
-def results_thread_main(strategy):
+def results_thread_main(strategy: StrategyBase) -> None:
+    value: object
+
     while True:
         try:
             result = strategy._final_q.get()
@@ -99,13 +102,10 @@ def results_thread_main(strategy):
                 dmethod = getattr(display, result.method)
                 dmethod(*result.args, **result.kwargs)
             elif isinstance(result, CallbackSend):
-                for arg in result.args:
-                    if isinstance(arg, TaskResult):
-                        strategy.normalize_task_result(arg)
-                        break
-                strategy._tqm.send_callback(result.method_name, *result.args, **result.kwargs)
-            elif isinstance(result, TaskResult):
-                strategy.normalize_task_result(result)
+                task_result = strategy._convert_wire_task_result_to_raw(result.wire_task_result)
+                strategy._tqm.send_callback(result.method_name, task_result)
+            elif isinstance(result, _WireTaskResult):
+                result = strategy._convert_wire_task_result_to_raw(result)
                 with strategy._results_lock:
                     strategy._results.append(result)
             elif isinstance(result, PromptSend):
@@ -137,7 +137,7 @@ def results_thread_main(strategy):
 def debug_closure(func):
     """Closure to wrap ``StrategyBase._process_pending_results`` and invoke the task debugger"""
     @functools.wraps(func)
-    def inner(self, iterator, one_pass=False, max_passes=None):
+    def inner(self, iterator: PlayIterator, one_pass: bool = False, max_passes: int | None = None) -> list[_RawTaskResult]:
         status_to_stats_map = (
             ('is_failed', 'failures'),
             ('is_unreachable', 'dark'),
@@ -148,12 +148,12 @@ def debug_closure(func):
         # We don't know the host yet, copy the previous states, for lookup after we process new results
         prev_host_states = iterator.host_states.copy()
 
-        results = func(self, iterator, one_pass=one_pass, max_passes=max_passes)
-        _processed_results = []
+        results: list[_RawTaskResult] = func(self, iterator, one_pass=one_pass, max_passes=max_passes)
+        _processed_results: list[_RawTaskResult] = []
 
         for result in results:
-            task = result._task
-            host = result._host
+            task = result.task
+            host = result.host
             _queued_task_args = self._queued_task_cache.pop((host.name, task._uuid), None)
             task_vars = _queued_task_args['task_vars']
             play_context = _queued_task_args['play_context']
@@ -239,7 +239,7 @@ class StrategyBase:
         # outstanding tasks still in queue
         self._blocked_hosts: dict[str, bool] = dict()
 
-        self._results: deque[TaskResult] = deque()
+        self._results: deque[_RawTaskResult] = deque()
         self._results_lock = threading.Condition(threading.Lock())
 
         # create the result processing thread for reading results in the background
@@ -249,7 +249,7 @@ class StrategyBase:
 
         # holds the list of active (persistent) connections to be shutdown at
         # play completion
-        self._active_connections: dict[str, str] = dict()
+        self._active_connections: dict[Host, str] = dict()
 
         # Caches for get_host calls, to avoid calling excessively
         # These values should be set at the top of the ``run`` method of each
@@ -447,39 +447,33 @@ class StrategyBase:
             for target_host in host_list:
                 _set_host_facts(target_host, always_facts)
 
-    def normalize_task_result(self, task_result):
-        """Normalize a TaskResult to reference actual Host and Task objects
-        when only given the ``Host.name``, or the ``Task._uuid``
-
-        Only the ``Host.name`` and ``Task._uuid`` are commonly sent back from
-        the ``TaskExecutor`` or ``WorkerProcess`` due to performance concerns
+    def _convert_wire_task_result_to_raw(self, wire_task_result: _WireTaskResult) -> _RawTaskResult:
+        """Return a `_RawTaskResult` created from a `_WireTaskResult`."""
+        host = self._inventory.get_host(wire_task_result.host_name)
+        queue_cache_entry = (host.name, wire_task_result.task_uuid)
 
-        Mutates the original object
-        """
-
-        if isinstance(task_result._host, string_types):
-            # If the value is a string, it is ``Host.name``
-            task_result._host = self._inventory.get_host(to_text(task_result._host))
+        try:
+            found_task = self._queued_task_cache[queue_cache_entry]['task']
+        except KeyError:
+            # This should only happen due to an implicit task created by the
+            # TaskExecutor, restrict this behavior to the explicit use case
+            # of an implicit async_status task
+            if wire_task_result.task_fields.get('action') != 'async_status':
+                raise
+
+            task = Task()
+        else:
+            task = found_task.copy(exclude_parent=True, exclude_tasks=True)
+            task._parent = found_task._parent
 
-        if isinstance(task_result._task, string_types):
-            # If the value is a string, it is ``Task._uuid``
-            queue_cache_entry = (task_result._host.name, task_result._task)
-            try:
-                found_task = self._queued_task_cache[queue_cache_entry]['task']
-            except KeyError:
-                # This should only happen due to an implicit task created by the
-                # TaskExecutor, restrict this behavior to the explicit use case
-                # of an implicit async_status task
-                if task_result._task_fields.get('action') != 'async_status':
-                    raise
-                original_task = Task()
-            else:
-                original_task = found_task.copy(exclude_parent=True, exclude_tasks=True)
-                original_task._parent = found_task._parent
-            original_task.from_attrs(task_result._task_fields)
-            task_result._task = original_task
+        task.from_attrs(wire_task_result.task_fields)
 
-        return task_result
+        return _RawTaskResult(
+            host=host,
+            task=task,
+            return_data=wire_task_result.return_data,
+            task_fields=wire_task_result.task_fields,
+        )
 
     def search_handlers_by_notification(self, notification: str, iterator: PlayIterator) -> t.Generator[Handler, None, None]:
         handlers = [h for b in reversed(iterator._play.handlers) for h in b.block]
@@ -537,7 +531,7 @@ class StrategyBase:
                 yield handler
 
     @debug_closure
-    def _process_pending_results(self, iterator: PlayIterator, one_pass: bool = False, max_passes: int | None = None) -> list[TaskResult]:
+    def _process_pending_results(self, iterator: PlayIterator, one_pass: bool = False, max_passes: int | None = None) -> list[_RawTaskResult]:
         """
         Reads results off the final queue and takes appropriate action
         based on the result (executing callbacks, updating state, etc.).
@@ -553,8 +547,8 @@ class StrategyBase:
             finally:
                 self._results_lock.release()
 
-            original_host = task_result._host
-            original_task: Task = task_result._task
+            original_host = task_result.host
+            original_task: Task = task_result.task
 
             # all host status messages contain 2 entries: (msg, task_result)
             role_ran = False
@@ -588,7 +582,7 @@ class StrategyBase:
                             original_host.name,
                             dict(
                                 ansible_failed_task=original_task.serialize(),
-                                ansible_failed_result=task_result._result,
+                                ansible_failed_result=task_result._return_data,
                             ),
                         )
                     else:
@@ -596,7 +590,7 @@ class StrategyBase:
                 else:
                     self._tqm._stats.increment('ok', original_host.name)
                     self._tqm._stats.increment('ignored', original_host.name)
-                    if 'changed' in task_result._result and task_result._result['changed']:
+                    if task_result.is_changed():
                         self._tqm._stats.increment('changed', original_host.name)
                 self._tqm.send_callback('v2_runner_on_failed', task_result, ignore_errors=ignore_errors)
             elif task_result.is_unreachable():
@@ -618,9 +612,9 @@ class StrategyBase:
                 if original_task.loop:
                     # this task had a loop, and has more than one result, so
                     # loop over all of them instead of a single result
-                    result_items = task_result._result.get('results', [])
+                    result_items = task_result._loop_results
                 else:
-                    result_items = [task_result._result]
+                    result_items = [task_result._return_data]
 
                 for result_item in result_items:
                     if '_ansible_notify' in result_item and task_result.is_changed():
@@ -665,7 +659,7 @@ class StrategyBase:
 
                     if 'add_host' in result_item or 'add_group' in result_item:
                         item_vars = _get_item_vars(result_item, original_task)
-                        found_task_vars = self._queued_task_cache.get((original_host.name, task_result._task._uuid))['task_vars']
+                        found_task_vars = self._queued_task_cache.get((original_host.name, task_result.task._uuid))['task_vars']
                         if item_vars:
                             all_task_vars = combine_vars(found_task_vars, item_vars)
                         else:
@@ -680,17 +674,17 @@ class StrategyBase:
                                 original_task._resolve_conditional(original_task.failed_when, all_task_vars))
 
                         if original_task.loop or original_task.loop_with:
-                            new_item_result = TaskResult(
-                                task_result._host,
-                                task_result._task,
+                            new_item_result = _RawTaskResult(
+                                task_result.host,
+                                task_result.task,
                                 result_item,
-                                task_result._task_fields,
+                                task_result.task_fields,
                             )
                             self._tqm.send_callback('v2_runner_item_on_ok', new_item_result)
                             if result_item.get('changed', False):
-                                task_result._result['changed'] = True
+                                task_result._return_data['changed'] = True
                             if result_item.get('failed', False):
-                                task_result._result['failed'] = True
+                                task_result._return_data['failed'] = True
 
                     if 'ansible_facts' in result_item and original_task.action not in C._ACTION_DEBUG:
                         # if delegated fact and we are delegating facts, we need to change target host for them
@@ -738,13 +732,13 @@ class StrategyBase:
                                 else:
                                     self._tqm._stats.set_custom_stats(k, data[k], myhost)
 
-                if 'diff' in task_result._result:
+                if 'diff' in task_result._return_data:
                     if self._diff or getattr(original_task, 'diff', False):
                         self._tqm.send_callback('v2_on_file_diff', task_result)
 
                 if not isinstance(original_task, TaskInclude):
                     self._tqm._stats.increment('ok', original_host.name)
-                    if 'changed' in task_result._result and task_result._result['changed']:
+                    if task_result.is_changed():
                         self._tqm._stats.increment('changed', original_host.name)
 
                 # finally, send the ok for this task
@@ -754,7 +748,7 @@ class StrategyBase:
             if original_task.register:
                 host_list = self.get_task_hosts(iterator, original_host, original_task)
 
-                clean_copy = strip_internal_keys(module_response_deepcopy(task_result._result))
+                clean_copy = strip_internal_keys(module_response_deepcopy(task_result._return_data))
                 if 'invocation' in clean_copy:
                     del clean_copy['invocation']
 
@@ -805,7 +799,7 @@ class StrategyBase:
 
         return ret_results
 
-    def _copy_included_file(self, included_file):
+    def _copy_included_file(self, included_file: IncludedFile) -> IncludedFile:
         """
         A proven safe and performant way to create a copy of an included file
         """
@@ -818,7 +812,7 @@ class StrategyBase:
 
         return ti_copy
 
-    def _load_included_file(self, included_file, iterator, is_handler=False, handle_stats_and_callbacks=True):
+    def _load_included_file(self, included_file: IncludedFile, iterator, is_handler=False, handle_stats_and_callbacks=True):
         """
         Loads an included YAML file of tasks, applying the optional set of variables.
 
@@ -828,12 +822,12 @@ class StrategyBase:
         """
         if handle_stats_and_callbacks:
             display.deprecated(
-                "Reporting play recap stats and running callbacks functionality for "
-                "``include_tasks`` in ``StrategyBase._load_included_file`` is deprecated. "
-                "See ``https://github.com/ansible/ansible/pull/79260`` for guidance on how to "
-                "move the reporting into specific strategy plugins to account for "
-                "``include_role`` tasks as well.",
-                version="2.21"
+                msg="Reporting play recap stats and running callbacks functionality for "
+                    "``include_tasks`` in ``StrategyBase._load_included_file`` is deprecated. "
+                    "See ``https://github.com/ansible/ansible/pull/79260`` for guidance on how to "
+                    "move the reporting into specific strategy plugins to account for "
+                    "``include_role`` tasks as well.",
+                version="2.21",
             )
         display.debug("loading included file: %s" % included_file._filename)
         try:
@@ -865,11 +859,11 @@ class StrategyBase:
             else:
                 reason = to_text(e)
             if handle_stats_and_callbacks:
-                for r in included_file._results:
-                    r._result['failed'] = True
+                for tr in included_file._results:
+                    tr._return_data['failed'] = True
 
                 for host in included_file._hosts:
-                    tr = TaskResult(host=host, task=included_file._task, return_data=dict(failed=True, reason=reason))
+                    tr = _RawTaskResult(host=host, task=included_file._task, return_data=dict(failed=True, reason=reason), task_fields={})
                     self._tqm._stats.increment('failures', host.name)
                     self._tqm.send_callback('v2_runner_on_failed', tr)
             raise AnsibleError(reason) from e
@@ -905,7 +899,7 @@ class StrategyBase:
     def _cond_not_supported_warn(self, task_name):
         display.warning("%s task does not support when conditional" % task_name)
 
-    def _execute_meta(self, task: Task, play_context, iterator, target_host):
+    def _execute_meta(self, task: Task, play_context, iterator, target_host: Host):
         task.resolved_action = 'ansible.builtin.meta'  # _post_validate_args is never called for meta actions, so resolved_action hasn't been set
 
         # meta tasks store their args in the _raw_params field of args,
@@ -1083,7 +1077,7 @@ class StrategyBase:
         else:
             display.vv(f"META: {header}")
 
-        res = TaskResult(target_host, task, result)
+        res = _RawTaskResult(target_host, task, result, {})
         if skipped:
             self._tqm.send_callback('v2_runner_on_skipped', res)
         return [res]
@@ -1103,14 +1097,14 @@ class StrategyBase:
                     hosts_left.append(self._inventory.get_host(host))
         return hosts_left
 
-    def update_active_connections(self, results):
+    def update_active_connections(self, results: _c.Iterable[_RawTaskResult]) -> None:
         """ updates the current active persistent connections """
         for r in results:
-            if 'args' in r._task_fields:
-                socket_path = r._task_fields['args'].get('_ansible_socket')
+            if 'args' in r.task_fields:
+                socket_path = r.task_fields['args'].get('_ansible_socket')
                 if socket_path:
-                    if r._host not in self._active_connections:
-                        self._active_connections[r._host] = socket_path
+                    if r.host not in self._active_connections:
+                        self._active_connections[r.host] = socket_path
 
 
 class NextAction(object):

ansible/plugins/strategy/free.py

@@ -252,11 +252,11 @@ class StrategyModule(StrategyBase):
                         # 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(ex)
-                            self._tqm._stats.increment('failures', r._host.name)
+                            r._return_data['failed'] = True
+                            r._return_data['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)
+                            failed_includes_hosts.add(r.host)
                         continue
                     else:
                         # since we skip incrementing the stats when the task result is

ansible/plugins/strategy/linear.py

@@ -40,6 +40,8 @@ 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
+from ansible.playbook.play_context import PlayContext
+from ansible.executor import task_result as _task_result
 
 display = Display()
 
@@ -92,7 +94,7 @@ class StrategyModule(StrategyBase):
 
         return host_tasks
 
-    def run(self, iterator, play_context):
+    def run(self, iterator, play_context: PlayContext):  # type: ignore[override]
         """
         The linear strategy is simple - get the next task and queue
         it for all hosts, then wait for the queue to drain before
@@ -100,7 +102,7 @@ class StrategyModule(StrategyBase):
         """
 
         # iterate over each task, while there is one left to run
-        result = self._tqm.RUN_OK
+        result = int(self._tqm.RUN_OK)
         work_to_do = True
 
         self._set_hosts_cache(iterator._play)
@@ -125,7 +127,7 @@ class StrategyModule(StrategyBase):
                 # flag set if task is set to any_errors_fatal
                 any_errors_fatal = False
 
-                results = []
+                results: list[_task_result._RawTaskResult] = []
                 for (host, task) in host_tasks:
                     if self._tqm._terminated:
                         break
@@ -285,11 +287,11 @@ class StrategyModule(StrategyBase):
                             # 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(ex)
-                                self._tqm._stats.increment('failures', r._host.name)
+                                r._return_data['failed'] = True
+                                r._return_data['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)
+                                failed_includes_hosts.add(r.host)
                         else:
                             # since we skip incrementing the stats when the task result is
                             # first processed, we do so now for each host in the list
@@ -320,9 +322,9 @@ class StrategyModule(StrategyBase):
                 unreachable_hosts = []
                 for res in results:
                     if res.is_failed():
-                        failed_hosts.append(res._host.name)
+                        failed_hosts.append(res.host.name)
                     elif res.is_unreachable():
-                        unreachable_hosts.append(res._host.name)
+                        unreachable_hosts.append(res.host.name)
 
                 if any_errors_fatal and (failed_hosts or unreachable_hosts):
                     for host in hosts_left:

ansible/plugins/test/core.py

@@ -49,7 +49,7 @@ def timedout(result):
     """ 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)
+    return result.get('timedout', False) and bool(result['timedout'].get('period', False))
 
 
 def failed(result):

ansible/release.py

@@ -17,6 +17,6 @@
 
 from __future__ import annotations
 
-__version__ = '2.19.0b1'
+__version__ = '2.19.0b3'
 __author__ = 'Ansible, Inc.'
 __codename__ = "What Is and What Should Never Be"

ansible/template/__init__.py

@@ -28,7 +28,7 @@ if _t.TYPE_CHECKING:  # pragma: nocover
 
 
 _display: _t.Final[_Display] = _Display()
-_UNSET = _t.cast(_t.Any, ...)
+_UNSET = _t.cast(_t.Any, object())
 _TTrustable = _t.TypeVar('_TTrustable', bound=str | _io.IOBase | _t.TextIO | _t.BinaryIO)
 _TRUSTABLE_TYPES = (str, _io.IOBase)
 
@@ -171,7 +171,8 @@ class Templar:
             variables=self._engine._variables if available_variables is None else available_variables,
         )
 
-        templar._overrides = self._overrides.merge(context_overrides)
+        # backward compatibility: filter out None values from overrides, even though it is a valid value for some of them
+        templar._overrides = self._overrides.merge({key: value for key, value in context_overrides.items() if value is not None})
 
         if searchpath is not None:
             templar._engine.environment.loader.searchpath = searchpath
@@ -198,7 +199,7 @@ class Templar:
             available_variables=self._engine,
         )
 
-        kwargs = dict(
+        target_args = dict(
             searchpath=searchpath,
             available_variables=available_variables,
         )
@@ -207,13 +208,14 @@ class Templar:
         previous_overrides = self._overrides
 
         try:
-            for key, value in kwargs.items():
+            for key, value in target_args.items():
                 if value is not None:
                     target = targets[key]
                     original[key] = getattr(target, key)
                     setattr(target, key, value)
 
-            self._overrides = self._overrides.merge(context_overrides)
+            # backward compatibility: filter out None values from overrides, even though it is a valid value for some of them
+            self._overrides = self._overrides.merge({key: value for key, value in context_overrides.items() if value is not None})
 
             yield
         finally:
@@ -386,7 +388,7 @@ def generate_ansible_template_vars(path: str, fullpath: str | None = None, dest_
         value=ansible_managed,
         msg="The `ansible_managed` variable is deprecated.",
         help_text="Define and use a custom variable instead.",
-        removal_version='2.23',
+        version='2.23',
     )
 
     temp_vars = dict(

ansible/utils/collection_loader/_collection_meta.py

@@ -24,11 +24,13 @@ def _meta_yml_to_dict(yaml_string_data: bytes | str, content_id):
     import yaml
 
     try:
-        from yaml import CSafeLoader as SafeLoader
+        from yaml import CBaseLoader as BaseLoader
     except (ImportError, AttributeError):
-        from yaml import SafeLoader  # type: ignore[assignment]
+        from yaml import BaseLoader  # type: ignore[assignment]
 
-    routing_dict = yaml.load(yaml_string_data, Loader=SafeLoader)
+    # Using BaseLoader ensures that all scalars are strings.
+    # Doing so avoids parsing unquoted versions as floats, dates as datetime.date, etc.
+    routing_dict = yaml.load(yaml_string_data, Loader=BaseLoader)
     if not routing_dict:
         routing_dict = {}
     if not isinstance(routing_dict, Mapping):