ansible-core 2.18.7rc1__py3-none-any.whl → 2.19.0__py3-none-any.whl

ansible/plugins/callback/default.py

@@ -4,7 +4,7 @@
 
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
     name: default
     type: stdout
     short_description: default Ansible screen output
@@ -16,11 +16,12 @@ DOCUMENTATION = '''
       - result_format_callback
     requirements:
       - set as stdout in configuration
-'''
+"""
 
 
 from ansible import constants as C
 from ansible import context
+from ansible.executor.task_result import CallbackTaskResult
 from ansible.playbook.task_include import TaskInclude
 from ansible.plugins.callback import CallbackBase
 from ansible.utils.color import colorize, hostcolor
@@ -29,10 +30,10 @@ from ansible.utils.fqcn import add_internal_fqcns
 
 class CallbackModule(CallbackBase):
 
-    '''
+    """
     This is the default callback interface, which simply prints messages
     to stdout when new callback events are received.
-    '''
+    """
 
     CALLBACK_VERSION = 2.0
     CALLBACK_TYPE = 'stdout'
@@ -46,40 +47,39 @@ class CallbackModule(CallbackBase):
         self._task_type_cache = {}
         super(CallbackModule, self).__init__()
 
-    def v2_runner_on_failed(self, result, ignore_errors=False):
-
+    def v2_runner_on_failed(self, result: CallbackTaskResult, ignore_errors: bool = False) -> None:
         host_label = self.host_label(result)
-        self._clean_results(result._result, result._task.action)
 
-        if self._last_task_banner != result._task._uuid:
-            self._print_task_banner(result._task)
+        if self._last_task_banner != result.task._uuid:
+            self._print_task_banner(result.task)
 
-        self._handle_exception(result._result, use_stderr=self.get_option('display_failed_stderr'))
-        self._handle_warnings(result._result)
+        self._handle_warnings_and_exception(result)
 
-        if result._task.loop and 'results' in result._result:
-            self._process_items(result)
+        # FIXME: this method should not exist, delegate "suggested keys to display" to the plugin or something... As-is, the placement of this
+        #          call obliterates `results`, which causes a task summary to be printed on loop failures, which we don't do anywhere else.
+        self._clean_results(result.result, result.task.action)
 
+        if result.task.loop and 'results' in result.result:
+            self._process_items(result)
         else:
             if self._display.verbosity < 2 and self.get_option('show_task_path_on_failure'):
-                self._print_task_path(result._task)
-            msg = "fatal: [%s]: FAILED! => %s" % (host_label, self._dump_results(result._result))
+                self._print_task_path(result.task)
+            msg = "fatal: [%s]: FAILED! => %s" % (host_label, self._dump_results(result.result))
             self._display.display(msg, color=C.COLOR_ERROR, stderr=self.get_option('display_failed_stderr'))
 
         if ignore_errors:
             self._display.display("...ignoring", color=C.COLOR_SKIP)
 
-    def v2_runner_on_ok(self, result):
-
+    def v2_runner_on_ok(self, result: CallbackTaskResult) -> None:
         host_label = self.host_label(result)
 
-        if isinstance(result._task, TaskInclude):
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+        if isinstance(result.task, TaskInclude):
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
             return
-        elif result._result.get('changed', False):
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+        elif result.result.get('changed', False):
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
 
             msg = "changed: [%s]" % (host_label,)
             color = C.COLOR_CHANGED
@@ -87,49 +87,52 @@ class CallbackModule(CallbackBase):
             if not self.get_option('display_ok_hosts'):
                 return
 
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
 
             msg = "ok: [%s]" % (host_label,)
             color = C.COLOR_OK
 
-        self._handle_warnings(result._result)
+        self._handle_warnings_and_exception(result)
 
-        if result._task.loop and 'results' in result._result:
+        if result.task.loop and 'results' in result.result:
             self._process_items(result)
         else:
-            self._clean_results(result._result, result._task.action)
+            self._clean_results(result.result, result.task.action)
 
             if self._run_is_verbose(result):
-                msg += " => %s" % (self._dump_results(result._result),)
+                msg += " => %s" % (self._dump_results(result.result),)
             self._display.display(msg, color=color)
 
-    def v2_runner_on_skipped(self, result):
-
+    def v2_runner_on_skipped(self, result: CallbackTaskResult) -> None:
         if self.get_option('display_skipped_hosts'):
 
-            self._clean_results(result._result, result._task.action)
+            self._clean_results(result.result, result.task.action)
+
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
 
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+            self._handle_warnings_and_exception(result)
 
-            if result._task.loop is not None and 'results' in result._result:
+            if result.task.loop is not None and 'results' in result.result:
                 self._process_items(result)
 
-            msg = "skipping: [%s]" % result._host.get_name()
+            msg = "skipping: [%s]" % result.host.get_name()
             if self._run_is_verbose(result):
-                msg += " => %s" % self._dump_results(result._result)
+                msg += " => %s" % self._dump_results(result.result)
             self._display.display(msg, color=C.COLOR_SKIP)
 
-    def v2_runner_on_unreachable(self, result):
-        if self._last_task_banner != result._task._uuid:
-            self._print_task_banner(result._task)
+    def v2_runner_on_unreachable(self, result: CallbackTaskResult) -> None:
+        if self._last_task_banner != result.task._uuid:
+            self._print_task_banner(result.task)
+
+        self._handle_warnings_and_exception(result)
 
         host_label = self.host_label(result)
-        msg = "fatal: [%s]: UNREACHABLE! => %s" % (host_label, self._dump_results(result._result))
+        msg = "fatal: [%s]: UNREACHABLE! => %s" % (host_label, self._dump_results(result.result))
         self._display.display(msg, color=C.COLOR_UNREACHABLE, stderr=self.get_option('display_failed_stderr'))
 
-        if result._task.ignore_unreachable:
+        if result.task.ignore_unreachable:
             self._display.display("...ignoring", color=C.COLOR_SKIP)
 
     def v2_playbook_on_no_hosts_matched(self):
@@ -171,6 +174,7 @@ class CallbackModule(CallbackBase):
         # that they can secure this if they feel that their stdout is insecure
         # (shoulder surfing, logging stdout straight to a file, etc).
         args = ''
+        # FIXME: the no_log value is not templated at this point, so any template will be considered truthy
         if not task.no_log and C.DISPLAY_ARGS_TO_STDOUT:
             args = u', '.join(u'%s=%s' % a for a in task.args.items())
             args = u' %s' % args
@@ -193,9 +197,6 @@ class CallbackModule(CallbackBase):
 
         self._last_task_banner = task._uuid
 
-    def v2_playbook_on_cleanup_task_start(self, task):
-        self._task_start(task, prefix='CLEANUP TASK')
-
     def v2_playbook_on_handler_task_start(self, task):
         self._task_start(task, prefix='RUNNING HANDLER')
 
@@ -218,30 +219,29 @@ class CallbackModule(CallbackBase):
 
         self._display.banner(msg)
 
-    def v2_on_file_diff(self, result):
-        if result._task.loop and 'results' in result._result:
-            for res in result._result['results']:
+    def v2_on_file_diff(self, result: CallbackTaskResult) -> None:
+        if result.task.loop and 'results' in result.result:
+            for res in result.result['results']:
                 if 'diff' in res and res['diff'] and res.get('changed', False):
                     diff = self._get_diff(res['diff'])
                     if diff:
-                        if self._last_task_banner != result._task._uuid:
-                            self._print_task_banner(result._task)
+                        if self._last_task_banner != result.task._uuid:
+                            self._print_task_banner(result.task)
                         self._display.display(diff)
-        elif 'diff' in result._result and result._result['diff'] and result._result.get('changed', False):
-            diff = self._get_diff(result._result['diff'])
+        elif 'diff' in result.result and result.result['diff'] and result.result.get('changed', False):
+            diff = self._get_diff(result.result['diff'])
             if diff:
-                if self._last_task_banner != result._task._uuid:
-                    self._print_task_banner(result._task)
+                if self._last_task_banner != result.task._uuid:
+                    self._print_task_banner(result.task)
                 self._display.display(diff)
 
-    def v2_runner_item_on_ok(self, result):
-
+    def v2_runner_item_on_ok(self, result: CallbackTaskResult) -> None:
         host_label = self.host_label(result)
-        if isinstance(result._task, TaskInclude):
+        if isinstance(result.task, TaskInclude):
             return
-        elif result._result.get('changed', False):
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+        elif result.result.get('changed', False):
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
 
             msg = 'changed'
             color = C.COLOR_CHANGED
@@ -249,43 +249,47 @@ class CallbackModule(CallbackBase):
             if not self.get_option('display_ok_hosts'):
                 return
 
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
 
             msg = 'ok'
             color = C.COLOR_OK
 
-        msg = "%s: [%s] => (item=%s)" % (msg, host_label, self._get_item_label(result._result))
-        self._clean_results(result._result, result._task.action)
+        self._handle_warnings_and_exception(result)
+
+        msg = "%s: [%s] => (item=%s)" % (msg, host_label, self._get_item_label(result.result))
+        self._clean_results(result.result, result.task.action)
         if self._run_is_verbose(result):
-            msg += " => %s" % self._dump_results(result._result)
+            msg += " => %s" % self._dump_results(result.result)
         self._display.display(msg, color=color)
 
-    def v2_runner_item_on_failed(self, result):
-        if self._last_task_banner != result._task._uuid:
-            self._print_task_banner(result._task)
+    def v2_runner_item_on_failed(self, result: CallbackTaskResult) -> None:
+        if self._last_task_banner != result.task._uuid:
+            self._print_task_banner(result.task)
+
+        self._handle_warnings_and_exception(result)
 
         host_label = self.host_label(result)
-        self._clean_results(result._result, result._task.action)
-        self._handle_exception(result._result, use_stderr=self.get_option('display_failed_stderr'))
 
         msg = "failed: [%s]" % (host_label,)
-        self._handle_warnings(result._result)
+        self._clean_results(result.result, result.task.action)
         self._display.display(
-            msg + " (item=%s) => %s" % (self._get_item_label(result._result), self._dump_results(result._result)),
+            msg + " (item=%s) => %s" % (self._get_item_label(result.result), self._dump_results(result.result)),
             color=C.COLOR_ERROR,
             stderr=self.get_option('display_failed_stderr')
         )
 
-    def v2_runner_item_on_skipped(self, result):
+    def v2_runner_item_on_skipped(self, result: CallbackTaskResult) -> None:
         if self.get_option('display_skipped_hosts'):
-            if self._last_task_banner != result._task._uuid:
-                self._print_task_banner(result._task)
+            if self._last_task_banner != result.task._uuid:
+                self._print_task_banner(result.task)
+
+            self._handle_warnings_and_exception(result)
 
-            self._clean_results(result._result, result._task.action)
-            msg = "skipping: [%s] => (item=%s) " % (result._host.get_name(), self._get_item_label(result._result))
+            self._clean_results(result.result, result.task.action)
+            msg = "skipping: [%s] => (item=%s) " % (result.host.get_name(), self._get_item_label(result.result))
             if self._run_is_verbose(result):
-                msg += " => %s" % self._dump_results(result._result)
+                msg += " => %s" % self._dump_results(result.result)
             self._display.display(msg, color=C.COLOR_SKIP)
 
     def v2_playbook_on_include(self, included_file):
@@ -370,37 +374,37 @@ class CallbackModule(CallbackBase):
         if context.CLIARGS['check'] and self.get_option('check_mode_markers'):
             self._display.banner("DRY RUN")
 
-    def v2_runner_retry(self, result):
-        task_name = result.task_name or result._task
+    def v2_runner_retry(self, result: CallbackTaskResult) -> None:
+        task_name = result.task_name or result.task
         host_label = self.host_label(result)
-        msg = "FAILED - RETRYING: [%s]: %s (%d retries left)." % (host_label, task_name, result._result['retries'] - result._result['attempts'])
+        msg = "FAILED - RETRYING: [%s]: %s (%d retries left)." % (host_label, task_name, result.result['retries'] - result.result['attempts'])
         if self._run_is_verbose(result, verbosity=2):
-            msg += "Result was: %s" % self._dump_results(result._result)
+            msg += "Result was: %s" % self._dump_results(result.result)
         self._display.display(msg, color=C.COLOR_DEBUG)
 
-    def v2_runner_on_async_poll(self, result):
-        host = result._host.get_name()
-        jid = result._result.get('ansible_job_id')
-        started = result._result.get('started')
-        finished = result._result.get('finished')
+    def v2_runner_on_async_poll(self, result: CallbackTaskResult) -> None:
+        host = result.host.get_name()
+        jid = result.result.get('ansible_job_id')
+        started = result.result.get('started')
+        finished = result.result.get('finished')
         self._display.display(
             'ASYNC POLL on %s: jid=%s started=%s finished=%s' % (host, jid, started, finished),
             color=C.COLOR_DEBUG
         )
 
-    def v2_runner_on_async_ok(self, result):
-        host = result._host.get_name()
-        jid = result._result.get('ansible_job_id')
+    def v2_runner_on_async_ok(self, result: CallbackTaskResult) -> None:
+        host = result.host.get_name()
+        jid = result.result.get('ansible_job_id')
         self._display.display("ASYNC OK on %s: jid=%s" % (host, jid), color=C.COLOR_DEBUG)
 
-    def v2_runner_on_async_failed(self, result):
-        host = result._host.get_name()
+    def v2_runner_on_async_failed(self, result: CallbackTaskResult) -> None:
+        host = result.host.get_name()
 
         # Attempt to get the async job ID. If the job does not finish before the
         # async timeout value, the ID may be within the unparsed 'async_result' dict.
-        jid = result._result.get('ansible_job_id')
-        if not jid and 'async_result' in result._result:
-            jid = result._result['async_result'].get('ansible_job_id')
+        jid = result.result.get('ansible_job_id')
+        if not jid and 'async_result' in result.result:
+            jid = result.result['async_result'].get('ansible_job_id')
         self._display.display("ASYNC FAILED on %s: jid=%s" % (host, jid), color=C.COLOR_DEBUG)
 
     def v2_playbook_on_notify(self, handler, host):

ansible/plugins/callback/junit.py

@@ -4,7 +4,7 @@
 
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
     name: junit
     type: aggregate
     short_description: write playbook output to a JUnit file.
@@ -80,15 +80,22 @@ DOCUMENTATION = '''
           - name: JUNIT_TEST_CASE_PREFIX
     requirements:
       - enable in configuration
-'''
+"""
 
+import decimal
 import os
 import time
 import re
+import typing as t
 
-from ansible import constants as C
+from ansible import constants
 from ansible.module_utils.common.text.converters import to_bytes, to_text
+from ansible.module_utils._internal import _event_utils
+from ansible._internal import _event_formatting
+from ansible.playbook.task import Task
 from ansible.plugins.callback import CallbackBase
+from ansible.executor.task_result import CallbackTaskResult
+from ansible.playbook.included_file import IncludedFile
 from ansible.utils._junit_xml import (
     TestCase,
     TestError,
@@ -126,7 +133,7 @@ class CallbackModule(CallbackBase):
                                      Default: True
         JUNIT_HIDE_TASK_ARGUMENTS (optional): Hide the arguments for a task
                                      Default: False
-        JUNIT_TEST_CASE_PREFIX (optional): Consider a task only as test case if it has this value as prefix. Additionally failing tasks are recorded as failed
+        JUNIT_TEST_CASE_PREFIX (optional): Consider a task only as test case if it has this value as prefix. Additionally, failing tasks are recorded as failed
                                      test cases.
                                      Default: <empty>
     """
@@ -136,7 +143,7 @@ class CallbackModule(CallbackBase):
     CALLBACK_NAME = 'junit'
     CALLBACK_NEEDS_ENABLED = True
 
-    def __init__(self):
+    def __init__(self) -> None:
         super(CallbackModule, self).__init__()
 
         self._output_dir = os.getenv('JUNIT_OUTPUT_DIR', os.path.expanduser('~/.ansible.log'))
@@ -150,20 +157,18 @@ class CallbackModule(CallbackBase):
         self._replace_out_of_tree_path = os.getenv('JUNIT_REPLACE_OUT_OF_TREE_PATH', None)
         self._playbook_path = None
         self._playbook_name = None
-        self._play_name = None
-        self._task_data = None
+        self._play_name: str | None = None
+        self._task_data: dict[str, TaskData] = {}
 
         self.disabled = False
 
-        self._task_data = {}
-
         if self._replace_out_of_tree_path is not None:
             self._replace_out_of_tree_path = to_text(self._replace_out_of_tree_path)
 
         if not os.path.exists(self._output_dir):
             os.makedirs(self._output_dir)
 
-    def _start_task(self, task):
+    def _start_task(self, task: Task) -> None:
         """ record the start of a task for one or more hosts """
 
         uuid = task._uuid
@@ -183,23 +188,23 @@ class CallbackModule(CallbackBase):
 
         self._task_data[uuid] = TaskData(uuid, name, path, play, action)
 
-    def _finish_task(self, status, result):
+    def _finish_task(self, status: str, result: IncludedFile | CallbackTaskResult) -> None:
         """ record the results of a task for a single host """
 
-        task_uuid = result._task._uuid
+        if isinstance(result, CallbackTaskResult):
+            task_uuid = result.task._uuid
+            host_uuid = result.host._uuid
+            host_name = result.host.name
 
-        if hasattr(result, '_host'):
-            host_uuid = result._host._uuid
-            host_name = result._host.name
+            if self._fail_on_change == 'true' and status == 'ok' and result.result.get('changed', False):
+                status = 'failed'
         else:
+            task_uuid = result._task._uuid
             host_uuid = 'include'
             host_name = 'include'
 
         task_data = self._task_data[task_uuid]
 
-        if self._fail_on_change == 'true' and status == 'ok' and result._result.get('changed', False):
-            status = 'failed'
-
         # ignore failure if expected and toggle result if asked for
         if status == 'failed' and 'EXPECTED FAILURE' in task_data.name:
             status = 'ok'
@@ -212,11 +217,11 @@ class CallbackModule(CallbackBase):
         if task_data.name.startswith(self._test_case_prefix) or status == 'failed':
             task_data.add_host(HostData(host_uuid, host_name, status, result))
 
-    def _build_test_case(self, task_data, host_data):
+    def _build_test_case(self, task_data: TaskData, host_data: HostData) -> TestCase:
         """ build a TestCase from the given TaskData and HostData """
 
         name = '[%s] %s: %s' % (host_data.name, task_data.play, task_data.name)
-        duration = host_data.finish - task_data.start
+        duration = decimal.Decimal(host_data.finish - task_data.start)
 
         if self._task_relative_path and task_data.path:
             junit_classname = to_text(os.path.relpath(to_bytes(task_data.path), to_bytes(self._task_relative_path)))
@@ -232,7 +237,8 @@ class CallbackModule(CallbackBase):
         if host_data.status == 'included':
             return TestCase(name=name, classname=junit_classname, time=duration, system_out=str(host_data.result))
 
-        res = host_data.result._result
+        task_result = t.cast(CallbackTaskResult, host_data.result)
+        res = task_result.result
         rc = res.get('rc', 0)
         dump = self._dump_results(res, indent=0)
         dump = self._cleanse_string(dump)
@@ -243,9 +249,9 @@ class CallbackModule(CallbackBase):
         test_case = TestCase(name=name, classname=junit_classname, time=duration)
 
         if host_data.status == 'failed':
-            if 'exception' in res:
-                message = res['exception'].strip().split('\n')[-1]
-                output = res['exception']
+            if error_summary := task_result.exception:
+                message = _event_utils.format_event_brief_message(error_summary.event)
+                output = _event_formatting.format_event_traceback(error_summary.event)
                 test_case.errors.append(TestError(message=message, output=output))
             elif 'msg' in res:
                 message = res['msg']
@@ -261,7 +267,8 @@ class CallbackModule(CallbackBase):
 
         return test_case
 
-    def _cleanse_string(self, value):
+    @staticmethod
+    def _cleanse_string(value):
         """ convert surrogate escapes to the unicode replacement character to avoid XML encoding errors """
         return to_text(to_bytes(value, errors='surrogateescape'), errors='replace')
 
@@ -271,7 +278,7 @@ class CallbackModule(CallbackBase):
         test_cases = []
 
         for task_uuid, task_data in self._task_data.items():
-            if task_data.action in C._ACTION_SETUP and self._include_setup_tasks_in_report == 'false':
+            if task_data.action in constants._ACTION_SETUP and self._include_setup_tasks_in_report == 'false':
                 continue
 
             for host_uuid, host_data in task_data.host_data.items():
@@ -293,31 +300,25 @@ class CallbackModule(CallbackBase):
     def v2_playbook_on_play_start(self, play):
         self._play_name = play.get_name()
 
-    def v2_runner_on_no_hosts(self, task):
-        self._start_task(task)
-
-    def v2_playbook_on_task_start(self, task, is_conditional):
-        self._start_task(task)
-
-    def v2_playbook_on_cleanup_task_start(self, task):
+    def v2_playbook_on_task_start(self, task: Task, is_conditional: bool) -> None:
         self._start_task(task)
 
-    def v2_playbook_on_handler_task_start(self, task):
+    def v2_playbook_on_handler_task_start(self, task: Task) -> None:
         self._start_task(task)
 
-    def v2_runner_on_failed(self, result, ignore_errors=False):
+    def v2_runner_on_failed(self, result: CallbackTaskResult, ignore_errors=False) -> None:
         if ignore_errors and self._fail_on_ignore != 'true':
             self._finish_task('ok', result)
         else:
             self._finish_task('failed', result)
 
-    def v2_runner_on_ok(self, result):
+    def v2_runner_on_ok(self, result: CallbackTaskResult) -> None:
         self._finish_task('ok', result)
 
-    def v2_runner_on_skipped(self, result):
+    def v2_runner_on_skipped(self, result: CallbackTaskResult) -> None:
         self._finish_task('skipped', result)
 
-    def v2_playbook_on_include(self, included_file):
+    def v2_playbook_on_include(self, included_file: IncludedFile) -> None:
         self._finish_task('included', included_file)
 
     def v2_playbook_on_stats(self, stats):
@@ -329,21 +330,21 @@ class TaskData:
     Data about an individual task.
     """
 
-    def __init__(self, uuid, name, path, play, action):
+    def __init__(self, uuid: str, name: str, path: str, play: str, action: str) -> None:
         self.uuid = uuid
         self.name = name
         self.path = path
         self.play = play
         self.start = None
-        self.host_data = {}
+        self.host_data: dict[str, HostData] = {}
         self.start = time.time()
         self.action = action
 
-    def add_host(self, host):
+    def add_host(self, host: HostData) -> None:
         if host.uuid in self.host_data:
             if host.status == 'included':
                 # concatenate task include output from multiple items
-                host.result = '%s\n%s' % (self.host_data[host.uuid].result, host.result)
+                host.result = f'{self.host_data[host.uuid].result}\n{host.result}'
             else:
                 raise Exception('%s: %s: %s: duplicate host callback: %s' % (self.path, self.play, self.name, host.name))
 
@@ -355,7 +356,7 @@ class HostData:
     Data about an individual host.
     """
 
-    def __init__(self, uuid, name, status, result):
+    def __init__(self, uuid: str, name: str, status: str, result: IncludedFile | CallbackTaskResult | str) -> None:
         self.uuid = uuid
         self.name = name
         self.status = status