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

ansible/plugins/shell/sh.py

@@ -3,7 +3,7 @@
 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
 name: sh
 short_description: "POSIX shell (/bin/sh)"
 version_added: historical
@@ -11,7 +11,7 @@ description:
   - This shell plugin is the one you want to use on most Unix systems, it is the most compatible and widely installed shell.
 extends_documentation_fragment:
   - shell_common
-'''
+"""
 
 from ansible.plugins.shell import ShellBase
 
@@ -29,6 +29,7 @@ class ShellModule(ShellBase):
 
     # commonly used
     ECHO = 'echo'
+    CD = 'cd'
     COMMAND_SEP = ';'
 
     # How to end lines in a python script one-liner

ansible/plugins/strategy/__init__.py

@@ -30,32 +30,26 @@ import typing as t
 from collections import deque
 
 
-from jinja2.exceptions import UndefinedError
-
 from ansible import constants as C
 from ansible import context
-from ansible.errors import AnsibleError, AnsibleFileNotFound, AnsibleUndefinedVariable, AnsibleParserError
-from ansible.executor import action_write_locks
+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_queue_manager import CallbackSend, DisplaySend, PromptSend
+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.conditional import Conditional
 from ansible.playbook.handler import Handler
 from ansible.playbook.helpers import load_list_of_blocks
 from ansible.playbook.task import Task
 from ansible.playbook.task_include import TaskInclude
 from ansible.plugins import loader as plugin_loader
-from ansible.template import Templar
+from ansible._internal._templating._engine import TemplateEngine
 from ansible.utils.display import Display
 from ansible.utils.fqcn import add_internal_fqcns
-from ansible.utils.unsafe_proxy import wrap_var
 from ansible.utils.sentinel import Sentinel
 from ansible.utils.vars import combine_vars
-from ansible.utils.multiprocessing import context as multiprocessing_context
 from ansible.vars.clean import strip_internal_keys, module_response_deepcopy
 
 display = Display()
@@ -75,22 +69,8 @@ class StrategySentinel:
 
 _sentinel = StrategySentinel()
 
-
-def post_process_whens(result, task, templar, task_vars):
-    cond = None
-    if task.changed_when:
-        with templar.set_temporary_context(available_variables=task_vars):
-            cond = Conditional(loader=templar._loader)
-            cond.when = task.changed_when
-            result['changed'] = cond.evaluate_conditional(templar, templar.available_variables)
-
-    if task.failed_when:
-        with templar.set_temporary_context(available_variables=task_vars):
-            if cond is None:
-                cond = Conditional(loader=templar._loader)
-            cond.when = task.failed_when
-            failed_when_result = cond.evaluate_conditional(templar, templar.available_variables)
-            result['failed_when_result'] = result['failed'] = failed_when_result
+if t.TYPE_CHECKING:
+    from ansible.inventory.host import Host
 
 
 def _get_item_vars(result, task):
@@ -223,17 +203,17 @@ def debug_closure(func):
 
 class StrategyBase:
 
-    '''
+    """
     This is the base class for strategy plugins, which contains some common
     code useful to all strategies like running handlers, cleanup actions, etc.
-    '''
+    """
 
     # by default, strategies should support throttling but we allow individual
     # strategies to disable this and either forego supporting it or managing
     # the throttling internally (as `free` does)
     ALLOW_BASE_THROTTLING = True
 
-    def __init__(self, tqm):
+    def __init__(self, tqm: TaskQueueManager) -> None:
         self._tqm = tqm
         self._inventory = tqm.get_inventory()
         self._workers = tqm._workers
@@ -246,7 +226,7 @@ class StrategyBase:
         # the task cache is a dictionary of tuples of (host.name, task._uuid)
         # used to find the original task object of in-flight tasks and to store
         # the task args/vars and play context info used to queue the task.
-        self._queued_task_cache = {}
+        self._queued_task_cache: dict[tuple[str, str], dict[str, t.Any]] = {}
 
         # Backwards compat: self._display isn't really needed, just import the global display and use that.
         self._display = display
@@ -257,13 +237,11 @@ class StrategyBase:
 
         # this dictionary is used to keep track of hosts that have
         # outstanding tasks still in queue
-        self._blocked_hosts = dict()
+        self._blocked_hosts: dict[str, bool] = dict()
 
-        self._results = deque()
+        self._results: deque[TaskResult] = deque()
         self._results_lock = threading.Condition(threading.Lock())
 
-        self._worker_queues = dict()
-
         # create the result processing thread for reading results in the background
         self._results_thread = threading.Thread(target=results_thread_main, args=(self,))
         self._results_thread.daemon = True
@@ -271,13 +249,13 @@ class StrategyBase:
 
         # holds the list of active (persistent) connections to be shutdown at
         # play completion
-        self._active_connections = dict()
+        self._active_connections: dict[str, 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
         # strategy plugin. Use ``_set_hosts_cache`` to set these values
-        self._hosts_cache = []
-        self._hosts_cache_all = []
+        self._hosts_cache: list[str] = []
+        self._hosts_cache_all: list[str] = []
 
         self.debugger_active = C.ENABLE_TASK_DEBUGGER
 
@@ -289,7 +267,7 @@ class StrategyBase:
         if not refresh and all((self._hosts_cache, self._hosts_cache_all)):
             return
 
-        if not play.finalized and Templar(None).is_template(play.hosts):
+        if not play.finalized and TemplateEngine().is_template(play.hosts):
             _pattern = 'all'
         else:
             _pattern = play.hosts or 'all'
@@ -341,40 +319,25 @@ class StrategyBase:
         return [host for host in self._hosts_cache if host in self._tqm._failed_hosts]
 
     def add_tqm_variables(self, vars, play):
-        '''
+        """
         Base class method to add extra variables/information to the list of task
         vars sent through the executor engine regarding the task queue manager state.
-        '''
+        """
         vars['ansible_current_hosts'] = self.get_hosts_remaining(play)
         vars['ansible_failed_hosts'] = self.get_failed_hosts(play)
 
     def _queue_task(self, host, task, task_vars, play_context):
-        ''' handles queueing the task up to be sent to a worker '''
+        """ handles queueing the task up to be sent to a worker """
 
         display.debug("entering _queue_task() for %s/%s" % (host.name, task.action))
 
-        # Add a write lock for tasks.
-        # Maybe this should be added somewhere further up the call stack but
-        # this is the earliest in the code where we have task (1) extracted
-        # into its own variable and (2) there's only a single code path
-        # leading to the module being run.  This is called by two
-        # functions: linear.py::run(), and
-        # free.py::run() so we'd have to add to both to do it there.
-        # The next common higher level is __init__.py::run() and that has
-        # tasks inside of play_iterator so we'd have to extract them to do it
-        # there.
-
-        if task.action not in action_write_locks.action_write_locks:
-            display.debug('Creating lock for %s' % task.action)
-            action_write_locks.action_write_locks[task.action] = multiprocessing_context.Lock()
-
         # create a templar and template things we need later for the queuing process
-        templar = Templar(loader=self._loader, variables=task_vars)
+        templar = TemplateEngine(loader=self._loader, variables=task_vars)
 
         try:
             throttle = int(templar.template(task.throttle))
-        except Exception as e:
-            raise AnsibleError("Failed to convert the throttle value to an integer.", obj=task._ds, orig_exc=e)
+        except Exception as ex:
+            raise AnsibleError("Failed to convert the throttle value to an integer.", obj=task.throttle) from ex
 
         # and then queue the new task
         try:
@@ -400,6 +363,8 @@ class StrategyBase:
 
                 worker_prc = self._workers[self._cur_worker]
                 if worker_prc is None or not worker_prc.is_alive():
+                    if worker_prc:
+                        worker_prc.close()
                     self._queued_task_cache[(host.name, task._uuid)] = {
                         'host': host,
                         'task': task,
@@ -409,7 +374,16 @@ class StrategyBase:
 
                     # Pass WorkerProcess its strategy worker number so it can send an identifier along with intra-task requests
                     worker_prc = WorkerProcess(
-                        self._final_q, task_vars, host, task, play_context, self._loader, self._variable_manager, plugin_loader, self._cur_worker,
+                        final_q=self._final_q,
+                        task_vars=task_vars,
+                        host=host,
+                        task=task,
+                        play_context=play_context,
+                        loader=self._loader,
+                        variable_manager=self._variable_manager,
+                        shared_loader_obj=plugin_loader.get_plugin_loader_namespace(),
+                        worker_id=self._cur_worker,
+                        cliargs=context.CLIARGS,
                     )
                     self._workers[self._cur_worker] = worker_prc
                     self._tqm.send_callback('v2_runner_on_start', host, task)
@@ -508,34 +482,38 @@ class StrategyBase:
         return task_result
 
     def search_handlers_by_notification(self, notification: str, iterator: PlayIterator) -> t.Generator[Handler, None, None]:
-        templar = Templar(None)
         handlers = [h for b in reversed(iterator._play.handlers) for h in b.block]
         # iterate in reversed order since last handler loaded with the same name wins
         for handler in handlers:
             if not handler.name:
                 continue
+
             if not handler.cached_name:
-                if templar.is_template(handler.name):
-                    templar.available_variables = self._variable_manager.get_vars(
+                def variables_factory() -> dict[str, t.Any]:
+                    return self._variable_manager.get_vars(
                         play=iterator._play,
                         task=handler,
                         _hosts=self._hosts_cache,
                         _hosts_all=self._hosts_cache_all
                     )
-                    try:
-                        handler.name = templar.template(handler.name)
-                    except (UndefinedError, AnsibleUndefinedVariable) as e:
-                        # We skip this handler due to the fact that it may be using
-                        # a variable in the name that was conditionally included via
-                        # set_fact or some other method, and we don't want to error
-                        # out unnecessarily
-                        if not handler.listen:
-                            display.warning(
-                                "Handler '%s' is unusable because it has no listen topics and "
-                                "the name could not be templated (host-specific variables are "
-                                "not supported in handler names). The error: %s" % (handler.name, to_text(e))
-                            )
-                        continue
+
+                templar = TemplateEngine(variables_factory=variables_factory)
+
+                try:
+                    handler.name = templar.template(handler.name)
+                except AnsibleTemplateError as e:
+                    # We skip this handler due to the fact that it may be using
+                    # a variable in the name that was conditionally included via
+                    # set_fact or some other method, and we don't want to error
+                    # out unnecessarily
+                    if not handler.listen:
+                        display.warning(
+                            "Handler '%s' is unusable because it has no listen topics and "
+                            "the name could not be templated (host-specific variables are "
+                            "not supported in handler names). The error: %s" % (handler.name, to_text(e))
+                        )
+                    continue
+
                 handler.cached_name = True
 
             # first we check with the full result of get_name(), which may
@@ -559,11 +537,11 @@ class StrategyBase:
                 yield handler
 
     @debug_closure
-    def _process_pending_results(self, iterator, one_pass=False, max_passes=None):
-        '''
+    def _process_pending_results(self, iterator: PlayIterator, one_pass: bool = False, max_passes: int | None = None) -> list[TaskResult]:
+        """
         Reads results off the final queue and takes appropriate action
         based on the result (executing callbacks, updating state, etc.).
-        '''
+        """
         ret_results = []
         cur_pass = 0
         while True:
@@ -576,7 +554,7 @@ class StrategyBase:
                 self._results_lock.release()
 
             original_host = task_result._host
-            original_task = task_result._task
+            original_task: Task = task_result._task
 
             # all host status messages contain 2 entries: (msg, task_result)
             role_ran = False
@@ -609,7 +587,7 @@ class StrategyBase:
                         self._variable_manager.set_nonpersistent_facts(
                             original_host.name,
                             dict(
-                                ansible_failed_task=wrap_var(original_task.serialize()),
+                                ansible_failed_task=original_task.serialize(),
                                 ansible_failed_result=task_result._result,
                             ),
                         )
@@ -651,7 +629,7 @@ class StrategyBase:
                         # otherwise depending on the setting either error or warn
                         host_state = iterator.get_state_for_host(original_host.name)
                         for notification in result_item['_ansible_notify']:
-                            handler = Sentinel
+                            handler: type[Sentinel] | Handler = Sentinel
                             for handler in self.search_handlers_by_notification(notification, iterator):
                                 if host_state.run_state == IteratingStates.HANDLERS:
                                     # we're currently iterating handlers, so we need to expand this now
@@ -692,8 +670,15 @@ class StrategyBase:
                             all_task_vars = combine_vars(found_task_vars, item_vars)
                         else:
                             all_task_vars = found_task_vars
-                        all_task_vars[original_task.register] = wrap_var(result_item)
-                        post_process_whens(result_item, original_task, Templar(self._loader), all_task_vars)
+                        all_task_vars[original_task.register] = result_item
+
+                        if original_task.changed_when:
+                            result_item['changed'] = original_task._resolve_conditional(original_task.changed_when, all_task_vars)
+
+                        if original_task.failed_when:
+                            result_item['failed_when_result'] = result_item['failed'] = (
+                                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,
@@ -798,10 +783,10 @@ class StrategyBase:
         return ret_results
 
     def _wait_on_pending_results(self, iterator):
-        '''
+        """
         Wait for the shared counter to drop to zero, using a short sleep
         between checks to ensure we don't spin lock
-        '''
+        """
 
         ret_results = []
 
@@ -821,9 +806,9 @@ class StrategyBase:
         return ret_results
 
     def _copy_included_file(self, included_file):
-        '''
+        """
         A proven safe and performant way to create a copy of an included file
-        '''
+        """
         ti_copy = included_file._task.copy(exclude_parent=True)
         ti_copy._parent = included_file._task._parent
 
@@ -834,13 +819,13 @@ class StrategyBase:
         return ti_copy
 
     def _load_included_file(self, included_file, iterator, is_handler=False, handle_stats_and_callbacks=True):
-        '''
+        """
         Loads an included YAML file of tasks, applying the optional set of variables.
 
         Raises AnsibleError exception in case of a failure during including a file,
         in such case the caller is responsible for marking the host(s) as failed
         using PlayIterator.mark_host_failed().
-        '''
+        """
         if handle_stats_and_callbacks:
             display.deprecated(
                 "Reporting play recap stats and running callbacks functionality for "
@@ -852,7 +837,7 @@ class StrategyBase:
             )
         display.debug("loading included file: %s" % included_file._filename)
         try:
-            data = self._loader.load_from_file(included_file._filename)
+            data = self._loader.load_from_file(included_file._filename, trusted_as_template=True)
             if data is None:
                 return []
             elif not isinstance(data, list):
@@ -920,19 +905,19 @@ 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, play_context, iterator, target_host):
+    def _execute_meta(self, task: Task, play_context, iterator, target_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,
         # since they do not use k=v pairs, so get that
-        meta_action = task.args.get('_raw_params')
+        meta_action = task._get_meta()
 
-        def _evaluate_conditional(h):
+        def _evaluate_conditional(conditional_host: Host) -> bool:
             if not task.when:
                 return True
-            all_vars = self._variable_manager.get_vars(play=iterator._play, host=h, task=task,
-                                                       _hosts=self._hosts_cache, _hosts_all=self._hosts_cache_all)
-            templar = Templar(loader=self._loader, variables=all_vars)
-            return task.evaluate_conditional(templar, all_vars)
+
+            return task._resolve_conditional(task.when, self._variable_manager.get_vars(
+                play=iterator._play, host=conditional_host, task=task, _hosts=self._hosts_cache, _hosts_all=self._hosts_cache_all))
 
         skipped = False
         msg = meta_action
@@ -1032,7 +1017,7 @@ class StrategyBase:
             if _evaluate_conditional(target_host):
                 while True:
                     state, task = iterator.get_next_task_for_host(target_host, peek=True)
-                    if task.action in C._ACTION_META and task.args.get("_raw_params") == "role_complete":
+                    if task._get_meta() == "role_complete":
                         break
                     iterator.set_state_for_host(target_host.name, state)
                     display.debug("'%s' skipped because role has been ended via 'end_role'" % task)
@@ -1043,7 +1028,7 @@ class StrategyBase:
         elif meta_action == 'reset_connection':
             all_vars = self._variable_manager.get_vars(play=iterator._play, host=target_host, task=task,
                                                        _hosts=self._hosts_cache, _hosts_all=self._hosts_cache_all)
-            templar = Templar(loader=self._loader, variables=all_vars)
+            templar = TemplateEngine(loader=self._loader, variables=all_vars)
 
             # apply the given task's information to the connection info,
             # which may override some fields already set by the play or
@@ -1085,15 +1070,17 @@ class StrategyBase:
         else:
             raise AnsibleError("invalid meta action requested: %s" % meta_action, obj=task._ds)
 
-        result = {'msg': msg}
+        result: dict[str, object] = {'msg': msg}
         if skipped:
             result['skipped'] = True
             result['skip_reason'] = skip_reason
         else:
             result['changed'] = False
 
-        if not task.implicit:
-            header = skip_reason if skipped else msg
+        header = skip_reason if skipped else msg
+        if task.implicit:
+            display.debug(f"META: {header}")
+        else:
             display.vv(f"META: {header}")
 
         res = TaskResult(target_host, task, result)
@@ -1102,16 +1089,10 @@ class StrategyBase:
         return [res]
 
     def _get_cached_role(self, task, play):
-        role_path = task._role.get_role_path()
-        role_cache = play.role_cache[role_path]
-        try:
-            idx = role_cache.index(task._role)
-            return role_cache[idx]
-        except ValueError:
-            raise AnsibleError(f'Cannot locate {task._role.get_name()} in role cache')
+        return play._get_cached_role(task._role)
 
     def get_hosts_left(self, iterator):
-        ''' returns list of available hosts for this iterator by filtering out unreachables '''
+        """ returns list of available hosts for this iterator by filtering out unreachables """
 
         hosts_left = []
         for host in self._hosts_cache:
@@ -1123,7 +1104,7 @@ class StrategyBase:
         return hosts_left
 
     def update_active_connections(self, results):
-        ''' updates the current active persistent connections '''
+        """ 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')
@@ -1195,7 +1176,7 @@ class Debugger(cmd.Cmd):
 
     def do_update_task(self, args):
         """Recreate the task from ``task._ds``, and template with updated ``task_vars``"""
-        templar = Templar(None, variables=self.scope['task_vars'])
+        templar = TemplateEngine(variables=self.scope['task_vars'])
         task = self.scope['task']
         task = task.load_data(task._ds)
         task.post_validate(templar)

ansible/plugins/strategy/debug.py

@@ -14,14 +14,14 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
     name: debug
     short_description: Executes tasks in interactive debug session.
     description:
         - Task execution is 'linear' but controlled by an interactive debug session.
     version_added: "2.1"
     author: Kishin Yagami (!UNKNOWN)
-'''
+"""
 
 from ansible.plugins.strategy.linear import StrategyModule as LinearStrategyModule
 

ansible/plugins/strategy/free.py

@@ -16,7 +16,7 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
     name: free
     short_description: Executes tasks without waiting for all hosts
     description:
@@ -27,7 +27,7 @@ DOCUMENTATION = '''
           won't hold up the rest of the hosts and tasks.
     version_added: "2.0"
     author: Ansible Core Team
-'''
+"""
 
 import time
 
@@ -37,8 +37,7 @@ 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.module_utils.common.text.converters import to_text
+from ansible._internal._templating._engine import TemplateEngine
 from ansible.utils.display import Display
 
 display = Display()
@@ -54,7 +53,7 @@ class StrategyModule(StrategyBase):
         self._host_pinned = False
 
     def run(self, iterator, play_context):
-        '''
+        """
         The "free" strategy is a bit more complex, in that it allows tasks to
         be sent to hosts as quickly as they can be processed. This means that
         some hosts may finish very quickly if run tasks result in little or no
@@ -65,7 +64,7 @@ class StrategyModule(StrategyBase):
         and starting the search from there as opposed to the top of the hosts
         list again, which would end up favoring hosts near the beginning of the
         list.
-        '''
+        """
 
         # the last host to be given a task
         last_host = 0
@@ -124,13 +123,13 @@ class StrategyModule(StrategyBase):
                                                                     _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", host=host_name)
 
                         try:
                             throttle = int(templar.template(task.throttle))
-                        except Exception as e:
-                            raise AnsibleError("Failed to convert the throttle value to an integer.", obj=task._ds, orig_exc=e)
+                        except Exception as ex:
+                            raise AnsibleError("Failed to convert the throttle value to an integer.", obj=task.throttle) from ex
 
                         if throttle > 0:
                             same_tasks = 0
@@ -155,13 +154,7 @@ class StrategyModule(StrategyBase):
                             # corresponding action plugin
                             action = None
 
-                        try:
-                            task.name = to_text(templar.template(task.name, fail_on_undefined=False), nonstring='empty')
-                            display.debug("done templating", host=host_name)
-                        except Exception:
-                            # just ignore any errors during task name templating,
-                            # we don't care if it just shows the raw name
-                            display.debug("templating failed for some reason", host=host_name)
+                        task.post_validate_attribute("name", templar=templar)
 
                         run_once = templar.template(task.run_once) or action and getattr(action, 'BYPASS_HOST_LOOP', False)
                         if run_once:
@@ -172,15 +165,6 @@ class StrategyModule(StrategyBase):
                                 display.warning("Using run_once with the free strategy is not currently supported. This task will still be "
                                                 "executed for every host in the inventory list.")
 
-                        # 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, host=host_name)
-                                del self._blocked_hosts[host_name]
-                                continue
-
                         if task.action in C._ACTION_META:
                             if self._host_pinned:
                                 meta_task_dummy_results_count += 1
@@ -264,11 +248,12 @@ class StrategyModule(StrategyBase):
                         iterator.handlers = [h for b in iterator._play.handlers for h in b.block]
                     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)

ansible/plugins/strategy/host_pinned.py

@@ -16,7 +16,7 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
     name: host_pinned
     short_description: Executes tasks on each host without interruption
     description:
@@ -28,7 +28,7 @@ DOCUMENTATION = '''
           Other than that, it behaves just like the "free" strategy.
     version_added: "2.7"
     author: Ansible Core Team
-'''
+"""
 
 from ansible.plugins.strategy.free import StrategyModule as FreeStrategyModule
 from ansible.utils.display import Display