ansible-core 2.19.0b4__py3-none-any.whl → 2.19.0b6__py3-none-any.whl

ansible/parsing/mod_args.py

@@ -160,7 +160,7 @@ class ModuleArgsParser:
         final_args = dict()
         if additional_args:
             if isinstance(additional_args, (str, EncryptedString)):
-                # DTFIX-RELEASE: should this be is_possibly_template?
+                # DTFIX5: should this be is_possibly_template?
                 if TemplateEngine().is_template(additional_args):
                     final_args['_variable_params'] = additional_args
                 else:

ansible/parsing/plugin_docs.py

@@ -41,7 +41,7 @@ def read_docstring_from_yaml_file(filename, verbose=True, ignore_errors=True):
             file_data = yaml.load(yamlfile, Loader=AnsibleLoader)
     except Exception as ex:
         msg = f"Unable to parse yaml file {filename}"
-        # DTFIX-RELEASE: find a better pattern for this (can we use the new optional error behavior?)
+        # DTFIX-FUTURE: find a better pattern for this (can we use the new optional error behavior?)
         if not ignore_errors:
             raise AnsibleParserError(f'{msg}.') from ex
         elif verbose:
@@ -93,7 +93,7 @@ def read_docstring_from_python_file(filename, verbose=True, ignore_errors=True):
 
     except Exception as ex:
         msg = f"Unable to parse documentation in python file {filename!r}"
-        # DTFIX-RELEASE: better pattern to conditionally raise/display
+        # DTFIX-FUTURE: better pattern to conditionally raise/display
         if not ignore_errors:
             raise AnsibleParserError(f'{msg}.') from ex
         elif verbose:

ansible/parsing/utils/yaml.py

@@ -11,7 +11,7 @@ import typing as t
 import yaml
 
 from ansible.errors import AnsibleJSONParserError
-from ansible._internal._errors import _utils
+from ansible._internal._errors import _error_utils
 from ansible.parsing.vault import VaultSecret
 from ansible.parsing.yaml.loader import AnsibleLoader
 from ansible._internal._yaml._errors import AnsibleYAMLParserError
@@ -34,7 +34,7 @@ def from_yaml(
 
     data = origin.tag(data)
 
-    with _utils.RedactAnnotatedSourceContext.when(not show_content):
+    with _error_utils.RedactAnnotatedSourceContext.when(not show_content):
         try:
             # we first try to load this data as JSON.
             # Fixes issues with extra vars json strings not being parsed correctly by the yaml parser
@@ -48,6 +48,6 @@ def from_yaml(
         try:
             return yaml.load(data, Loader=AnsibleLoader)  # type: ignore[arg-type]
         except Exception as yaml_ex:
-            # DTFIX-RELEASE: how can we indicate in Origin that the data is in-memory only, to support context information -- is that useful?
+            # DTFIX-FUTURE: how can we indicate in Origin that the data is in-memory only, to support context information -- is that useful?
             #        we'd need to pass data to handle_exception so it could be used as the content instead of reading from disk
             AnsibleYAMLParserError.handle_exception(yaml_ex, origin=origin)

ansible/parsing/vault/__init__.py

@@ -17,7 +17,6 @@
 
 from __future__ import annotations
 
-import errno
 import fcntl
 import functools
 import os
@@ -149,7 +148,7 @@ def _parse_vaulttext_envelope(b_vaulttext_envelope, default_vault_id=None):
         vault_id = to_text(b_tmpheader[3].strip())
 
     b_ciphertext = b''.join(b_tmpdata[1:])
-    # DTFIX-RELEASE: possible candidate for propagate_origin
+    # DTFIX7: possible candidate for propagate_origin
     b_ciphertext = AnsibleTagHelper.tag_copy(b_vaulttext_envelope, b_ciphertext)
 
     return b_ciphertext, b_version, cipher_name, vault_id
@@ -222,7 +221,7 @@ def format_vaulttext_envelope(b_ciphertext, cipher_name, version=None, vault_id=
 
 def _unhexlify(b_data):
     try:
-        # DTFIX-RELEASE: possible candidate for propagate_origin
+        # DTFIX7: possible candidate for propagate_origin
         return AnsibleTagHelper.tag_copy(b_data, unhexlify(b_data))
     except (BinasciiError, TypeError) as ex:
         raise AnsibleVaultFormatError('Vault format unhexlify error.', obj=b_data) from ex
@@ -414,8 +413,8 @@ class FileVaultSecret(VaultSecret):
         try:
             with open(filename, "rb") as f:
                 vault_pass = f.read().strip()
-        except (OSError, IOError) as e:
-            raise AnsibleError("Could not read vault password file %s: %s" % (filename, e))
+        except OSError as ex:
+            raise AnsibleError(f"Could not read vault password file {filename!r}.") from ex
 
         b_vault_data, dummy = self.loader._decrypt_if_vault_data(vault_pass)
 
@@ -712,7 +711,7 @@ class VaultLib:
                 # secret = self.secrets[vault_secret_id]
                 display.vvvv(u'Trying secret %s for vault_id=%s' % (to_text(vault_secret), to_text(vault_secret_id)))
                 b_plaintext = this_cipher.decrypt(b_vaulttext, vault_secret)
-                # DTFIX-RELEASE: possible candidate for propagate_origin
+                # DTFIX7: possible candidate for propagate_origin
                 b_plaintext = AnsibleTagHelper.tag_copy(vaulttext, b_plaintext)
                 if b_plaintext is not None:
                     vault_id_used = vault_secret_id
@@ -1071,13 +1070,10 @@ class VaultEditor:
                 try:
                     # create file with secure permissions
                     fd = os.open(thefile, os.O_CREAT | os.O_EXCL | os.O_RDWR | os.O_TRUNC, mode)
-                except OSError as ose:
-                    # Want to catch FileExistsError, which doesn't exist in Python 2, so catch OSError
-                    # and compare the error number to get equivalent behavior in Python 2/3
-                    if ose.errno == errno.EEXIST:
-                        raise AnsibleError('Vault file got recreated while we were operating on it: %s' % to_native(ose))
-
-                    raise AnsibleError('Problem creating temporary vault file: %s' % to_native(ose))
+                except FileExistsError as ex:
+                    raise AnsibleError('Vault file got recreated while we were operating on it.') from ex
+                except OSError as ex:
+                    raise AnsibleError('Problem creating temporary vault file.') from ex
 
                 try:
                     # now write to the file and ensure ours is only data in it
@@ -1520,7 +1516,7 @@ class VaultHelper:
             tags = AnsibleTagHelper.tags(ciphertext)  # ciphertext has tags but value does not
         elif value_type is EncryptedString:
             ciphertext = value._ciphertext
-        elif value_type in _jinja_common.Marker.concrete_subclasses:  # avoid wasteful raise/except of Marker when calling get_tag below
+        elif value_type in _jinja_common.Marker._concrete_subclasses:  # avoid wasteful raise/except of Marker when calling get_tag below
             ciphertext = None
         elif vaulted_value := VaultedValue.get_tag(value):
             ciphertext = vaulted_value.ciphertext

ansible/playbook/base.py

@@ -83,6 +83,11 @@ class _ClassProperty:
 
 class FieldAttributeBase:
 
+    _post_validate_object = False
+    """
+    `False` skips FieldAttribute post-validation on intermediate objects and mixins for attributes without `always_post_validate`.
+    Leaf objects (e.g., `Task`) should set this attribute `True` to opt-in to post-validation.
+    """
     fattributes = _ClassProperty()
 
     @classmethod
@@ -566,8 +571,8 @@ class FieldAttributeBase:
             # only import_role is checked here because import_tasks never reaches this point
             return Sentinel
 
-        # FIXME: compare types, not strings
-        if not attribute.always_post_validate and self.__class__.__name__ not in ('Task', 'Handler', 'PlayContext', 'IncludeRole', 'TaskInclude'):
+        # Skip post validation unless always_post_validate is True, or the object requires post validation.
+        if not attribute.always_post_validate and not self._post_validate_object:
             # Intermediate objects like Play() won't have their fields validated by
             # default, as their values are often inherited by other objects and validated
             # later, so we don't want them to fail out early

ansible/playbook/included_file.py

@@ -144,7 +144,9 @@ class IncludedFile:
                                     parent_include_dir = parent_include._role_path
                                 else:
                                     try:
-                                        parent_include_dir = os.path.dirname(parent_include.args.get('_raw_params'))
+                                        # FUTURE: Since the parent include path has already been resolved, it should be used here.
+                                        #         Unfortunately it's not currently stored anywhere, so it must be calculated again.
+                                        parent_include_dir = os.path.dirname(templar.template(parent_include.args.get('_raw_params')))
                                     except AnsibleError as e:
                                         parent_include_dir = ''
                                         display.warning(

ansible/playbook/play_context.py

@@ -71,6 +71,8 @@ class PlayContext(Base):
     connection/authentication information.
     """
 
+    _post_validate_object = True
+
     # base
     module_compression = FieldAttribute(isa='string', default=C.DEFAULT_MODULE_COMPRESSION)
     shell = FieldAttribute(isa='string')

ansible/playbook/playbook_include.py

@@ -164,5 +164,5 @@ class PlaybookInclude(Base, Conditional, Taggable):
         if len(items) == 0:
             raise AnsibleParserError("import_playbook statements must specify the file name to import", obj=ds)
 
-        # DTFIX-RELEASE: investigate this as a possible "problematic strip"
+        # DTFIX3: investigate this as a possible "problematic strip"
         new_ds['import_playbook'] = AnsibleTagHelper.tag_copy(v, items[0].strip())

ansible/playbook/taggable.py

@@ -17,6 +17,8 @@
 
 from __future__ import annotations
 
+import typing as t
+
 from ansible.errors import AnsibleError
 from ansible.module_utils.six import string_types
 from ansible.module_utils.common.sentinel import Sentinel
@@ -25,7 +27,7 @@ from ansible.playbook.attribute import FieldAttribute
 from ansible._internal._templating._engine import TemplateEngine
 
 
-def _flatten_tags(tags: list) -> list:
+def _flatten_tags(tags: list[str | int]) -> list[str | int]:
     rv = set()
     for tag in tags:
         if isinstance(tag, list):
@@ -45,23 +47,32 @@ class Taggable:
             return ds
 
         if isinstance(ds, str):
-            # DTFIX-RELEASE: this allows each individual tag to be templated, but prevents the use of commas in templates, is that what we want?
-            # DTFIX-RELEASE: this can return empty tags (including a list of nothing but empty tags), is that correct?
-            # DTFIX-RELEASE: the original code seemed to attempt to preserve `ds` if there were no commas, but it never ran, what should it actually do?
             return [AnsibleTagHelper.tag_copy(ds, item.strip()) for item in ds.split(',')]
 
         raise AnsibleError('tags must be specified as a list', obj=ds)
 
+    def _get_all_taggable_objects(self) -> t.Iterable[Taggable]:
+        obj = self
+        while obj is not None:
+            yield obj
+
+            if (role := getattr(obj, "_role", Sentinel)) is not Sentinel:
+                yield role  # type: ignore[misc]
+
+            obj = obj._parent
+
+        yield self.get_play()
+
     def evaluate_tags(self, only_tags, skip_tags, all_vars):
-        """ this checks if the current item should be executed depending on tag options """
+        """Check if the current item should be executed depending on the specified tags.
 
+        NOTE this method is assumed to be called only on Task objects.
+        """
         if self.tags:
             templar = TemplateEngine(loader=self._loader, variables=all_vars)
-            obj = self
-            while obj is not None:
+            for obj in self._get_all_taggable_objects():
                 if (_tags := getattr(obj, "_tags", Sentinel)) is not Sentinel:
                     obj._tags = _flatten_tags(templar.template(_tags))
-                obj = obj._parent
             tags = set(self.tags)
         else:
             # this makes isdisjoint work for untagged

ansible/playbook/task.py

@@ -65,6 +65,8 @@ class Task(Base, Conditional, Taggable, CollectionSearch, Notifiable, Delegatabl
        Task.something(...)
     """
 
+    _post_validate_object = True
+
     # =================================================================================
     # ATTRIBUTES
     # load_<attribute_name> and

ansible/plugins/__init__.py

@@ -189,28 +189,3 @@ class AnsibleJinja2Plugin(AnsiblePlugin, metaclass=abc.ABCMeta):
     @property
     def j2_function(self) -> t.Callable:
         return self._function
-
-
-_TCallable = t.TypeVar('_TCallable', bound=t.Callable)
-
-
-def accept_args_markers(plugin: _TCallable) -> _TCallable:
-    """
-    A decorator to mark a Jinja plugin as capable of handling `Marker` values for its top-level arguments.
-    Non-decorated plugin invocation is skipped when a top-level argument is a `Marker`, with the first such value substituted as the plugin result.
-    This ensures that only plugins which understand `Marker` instances for top-level arguments will encounter them.
-    """
-    plugin.accept_args_markers = True
-
-    return plugin
-
-
-def accept_lazy_markers(plugin: _TCallable) -> _TCallable:
-    """
-    A decorator to mark a Jinja plugin as capable of handling `Marker` values retrieved from lazy containers.
-    Non-decorated plugins will trigger a `MarkerError` exception when attempting to retrieve a `Marker` from a lazy container.
-    This ensures that only plugins which understand lazy retrieval of `Marker` instances will encounter them.
-    """
-    plugin.accept_lazy_markers = True
-
-    return plugin

ansible/plugins/action/__init__.py

@@ -20,9 +20,8 @@ from abc import ABC, abstractmethod
 from collections.abc import Sequence
 
 from ansible import constants as C
-from ansible._internal._errors import _captured
+from ansible._internal._errors import _captured, _error_utils
 from ansible.errors import AnsibleError, AnsibleConnectionFailure, AnsibleActionSkip, AnsibleActionFail, AnsibleAuthenticationFailure
-from ansible._internal._errors import _utils
 from ansible.executor.module_common import modify_module, _BuiltModule
 from ansible.executor.interpreter_discovery import discover_interpreter, InterpreterDiscoveryRequiredError
 from ansible.module_utils._internal import _traceback
@@ -41,7 +40,6 @@ from ansible import _internal
 from ansible._internal._templating import _engine
 
 from .. import _AnsiblePluginInfoMixin
-from ...module_utils.common.messages import PluginInfo
 
 display = Display()
 
@@ -121,8 +119,7 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
 
         * Module parameters.  These are stored in self._task.args
         """
-
-        # does not default to {'changed': False, 'failed': False}, as it breaks async
+        # does not default to {'changed': False, 'failed': False}, as it used to break async
         result = {}
 
         if tmp is not None:
@@ -476,8 +473,8 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
 
         become_unprivileged = self._is_become_unprivileged()
         basefile = self._connection._shell._generate_temp_dir_name()
-        cmd = self._connection._shell.mkdtemp(basefile=basefile, system=become_unprivileged, tmpdir=tmpdir)
-        result = self._low_level_execute_command(cmd, sudoable=False)
+        cmd = self._connection._shell._mkdtemp2(basefile=basefile, system=become_unprivileged, tmpdir=tmpdir)
+        result = self._low_level_execute_command(cmd.command, in_data=cmd.input_data, sudoable=False)
 
         # error handling on this seems a little aggressive?
         if result['rc'] != 0:
@@ -908,8 +905,8 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
                 expand_path = '~%s' % (self._get_remote_user() or '')
 
         # use shell to construct appropriate command and execute
-        cmd = self._connection._shell.expand_user(expand_path)
-        data = self._low_level_execute_command(cmd, sudoable=False)
+        cmd = self._connection._shell._expand_user2(expand_path)
+        data = self._low_level_execute_command(cmd.command, in_data=cmd.input_data, sudoable=False)
 
         try:
             initial_fragment = data['stdout'].strip().splitlines()[-1]
@@ -1115,7 +1112,7 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
         if wrap_async and not self._connection.always_pipeline_modules:
             # configure, upload, and chmod the async_wrapper module
             (async_module_bits, async_module_path) = self._configure_module(module_name='ansible.legacy.async_wrapper', module_args=dict(), task_vars=task_vars)
-            (async_module_style, shebang, async_module_data) = (async_module_bits.module_style, async_module_bits.shebang, async_module_bits.b_module_data)
+            (shebang, async_module_data) = (async_module_bits.shebang, async_module_bits.b_module_data)
             async_module_remote_filename = self._connection._shell.get_remote_filename(async_module_path)
             remote_async_module_path = self._connection._shell.join_path(tmpdir, async_module_remote_filename)
             self._transfer_data(remote_async_module_path, async_module_data)
@@ -1255,7 +1252,7 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
             except AnsibleError as ansible_ex:
                 sentinel = object()
 
-                data = self.result_dict_from_exception(ansible_ex)
+                data = _error_utils.result_dict_from_exception(ansible_ex)
                 data.update(
                     _ansible_parsed=False,
                     module_stdout=res.get('stdout', ''),
@@ -1436,23 +1433,3 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
 
         # if missing it will return a file not found exception
         return self._loader.path_dwim_relative_stack(path_stack, dirname, needle)
-
-    @staticmethod
-    def result_dict_from_exception(exception: BaseException) -> dict[str, t.Any]:
-        """Return a failed task result dict from the given exception."""
-        if ansible_remoted_error := _captured.AnsibleResultCapturedError.find_first_remoted_error(exception):
-            result = ansible_remoted_error._result.copy()
-        else:
-            result = {}
-
-        error_summary = _utils._create_error_summary(exception, _traceback.TracebackEvent.ERROR)
-
-        result.update(
-            failed=True,
-            exception=error_summary,
-        )
-
-        if 'msg' not in result:
-            result.update(msg=_utils._dedupe_and_concat_message_chain([md.msg for md in error_summary.details]))
-
-        return result

ansible/plugins/action/add_host.py

@@ -77,7 +77,7 @@ class ActionModule(ActionBase):
             elif isinstance(groups, string_types):
                 group_list = groups.split(",")
             else:
-                raise AnsibleActionFail("Groups must be specified as a list.", obj=self._task)
+                raise AnsibleActionFail("Groups must be specified as a list.", obj=groups)
 
             for group_name in group_list:
                 if group_name not in new_groups:

ansible/plugins/action/assemble.py

@@ -25,8 +25,8 @@ import re
 import tempfile
 
 from ansible import constants as C
-from ansible.errors import AnsibleError, AnsibleAction, _AnsibleActionDone, AnsibleActionFail
-from ansible.module_utils.common.text.converters import to_native, to_text
+from ansible.errors import AnsibleActionFail
+from ansible.module_utils.common.text.converters import to_text
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.plugins.action import ActionBase
 from ansible.utils.hashing import checksum_s
@@ -83,7 +83,7 @@ class ActionModule(ActionBase):
 
         self._supports_check_mode = False
 
-        result = super(ActionModule, self).run(tmp, task_vars)
+        super(ActionModule, self).run(tmp, task_vars)
         del tmp  # tmp no longer has any effect
 
         if task_vars is None:
@@ -104,13 +104,9 @@ class ActionModule(ActionBase):
 
             if boolean(remote_src, strict=False):
                 # call assemble via ansible.legacy to allow library/ overrides of the module without collection search
-                result.update(self._execute_module(module_name='ansible.legacy.assemble', task_vars=task_vars))
-                raise _AnsibleActionDone()
-            else:
-                try:
-                    src = self._find_needle('files', src)
-                except AnsibleError as e:
-                    raise AnsibleActionFail(to_native(e))
+                return self._execute_module(module_name='ansible.legacy.assemble', task_vars=task_vars)
+
+            src = self._find_needle('files', src)
 
             if not os.path.isdir(src):
                 raise AnsibleActionFail(u"Source (%s) is not a directory" % src)
@@ -153,13 +149,9 @@ class ActionModule(ActionBase):
                 res = self._execute_module(module_name='ansible.legacy.copy', module_args=new_module_args, task_vars=task_vars)
                 if diff:
                     res['diff'] = diff
-                result.update(res)
+                return res
             else:
-                result.update(self._execute_module(module_name='ansible.legacy.file', module_args=new_module_args, task_vars=task_vars))
+                return self._execute_module(module_name='ansible.legacy.file', module_args=new_module_args, task_vars=task_vars)
 
-        except AnsibleAction as e:
-            result.update(e.result)
         finally:
             self._remove_tmp_path(self._connection._shell.tmpdir)
-
-        return result

ansible/plugins/action/async_status.py

@@ -28,7 +28,7 @@ class ActionModule(ActionBase):
         )
 
         # initialize response
-        results['started'] = results['finished'] = 0
+        results['started'] = results['finished'] = False
         results['stdout'] = results['stderr'] = ''
         results['stdout_lines'] = results['stderr_lines'] = []
 
@@ -43,9 +43,14 @@ class ActionModule(ActionBase):
             results['erased'] = log_path
         else:
             results['results_file'] = log_path
-            results['started'] = 1
+            results['started'] = True
 
         new_module_args['_async_dir'] = async_dir
         results = merge_hash(results, self._execute_module(module_name='ansible.legacy.async_status', task_vars=task_vars, module_args=new_module_args))
 
+        # Backwards compat shim for when started/finished were ints,
+        # mostly to work with ansible.windows.async_status
+        for convert in ('started', 'finished'):
+            results[convert] = bool(results[convert])
+
         return results

ansible/plugins/action/copy.py

@@ -27,7 +27,7 @@ import tempfile
 from ansible import constants as C
 from ansible.errors import AnsibleError, AnsibleActionFail, AnsibleFileNotFound
 from ansible.module_utils.basic import FILE_COMMON_ARGUMENTS
-from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
+from ansible.module_utils.common.text.converters import to_bytes, to_text
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.plugins.action import ActionBase
 from ansible.utils.hashing import checksum
@@ -409,6 +409,7 @@ class ActionModule(ActionBase):
             task_vars = dict()
 
         result = super(ActionModule, self).run(tmp, task_vars)
+
         del tmp  # tmp no longer has any effect
 
         # ensure user is not setting internal parameters
@@ -450,10 +451,10 @@ class ActionModule(ActionBase):
                 else:
                     content_tempfile = self._create_content_tempfile(content)
                 source = content_tempfile
-            except Exception as err:
-                result['failed'] = True
-                result['msg'] = "could not write content temp file: %s" % to_native(err)
-                return self._ensure_invocation(result)
+            except Exception as ex:
+                self._ensure_invocation(result)
+
+                raise AnsibleActionFail(message="could not write content temp file", result=result) from ex
 
         # if we have first_available_file in our vars
         # look up the files and use the first one we find as src
@@ -470,9 +471,9 @@ class ActionModule(ActionBase):
                 # find in expected paths
                 source = self._find_needle('files', source)
             except AnsibleError as ex:
-                result.update(self.result_dict_from_exception(ex))
+                self._ensure_invocation(result)
 
-                return self._ensure_invocation(result)
+                raise AnsibleActionFail(result=result) from ex
 
             if trailing_slash != source.endswith(os.path.sep):
                 if source[-1] == os.path.sep:

ansible/plugins/action/fetch.py

@@ -119,7 +119,7 @@ class ActionModule(ActionBase):
 
                     if 'not found' in slurpres.get('msg', ''):
                         result['msg'] = "the remote file does not exist, not transferring, ignored"
-                    elif slurpres.get('msg', '').startswith('source is a directory'):
+                    elif slurpres.get('msg', '').lower().startswith('source is a directory'):
                         result['msg'] = "remote file is a directory, fetch cannot work on directories"
 
                     return result
@@ -180,8 +180,8 @@ class ActionModule(ActionBase):
                     try:
                         with open(to_bytes(dest, errors='surrogate_or_strict'), 'wb') as f:
                             f.write(remote_data)
-                    except (IOError, OSError) as e:
-                        raise AnsibleActionFail("Failed to fetch the file: %s" % e)
+                    except OSError as ex:
+                        raise AnsibleActionFail("Failed to fetch the file.") from ex
                 new_checksum = secure_hash(dest)
                 # For backwards compatibility. We'll return None on FIPS enabled systems
                 try:

ansible/plugins/action/gather_facts.py

@@ -13,6 +13,7 @@ from ansible.executor.module_common import _apply_action_arg_defaults
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.plugins.action import ActionBase
 from ansible.utils.vars import merge_hash
+from ansible._internal._errors import _error_utils
 
 
 class ActionModule(ActionBase):
@@ -127,8 +128,6 @@ class ActionModule(ActionBase):
                 # TODO: use gather_timeout to cut module execution if module itself does not support gather_timeout
                 res = self._execute_module(module_name=fact_module, module_args=mod_args, task_vars=task_vars, wrap_async=False)
                 if res.get('failed', False):
-                    # DTFIX-RELEASE: this trashes the individual failure details and does not work with the new error handling; need to do something to
-                    # invoke per-item error handling- perhaps returning this as a synthetic loop result?
                     failed[fact_module] = res
                 elif res.get('skipped', False):
                     skipped[fact_module] = res
@@ -159,10 +158,8 @@ class ActionModule(ActionBase):
                 for module in jobs:
                     poll_args = {'jid': jobs[module]['ansible_job_id'], '_async_dir': os.path.dirname(jobs[module]['results_file'])}
                     res = self._execute_module(module_name='ansible.legacy.async_status', module_args=poll_args, task_vars=task_vars, wrap_async=False)
-                    if res.get('finished', 0) == 1:
+                    if res.get('finished', False):
                         if res.get('failed', False):
-                            # DTFIX-RELEASE: this trashes the individual failure details and does not work with the new error handling; need to do something to
-                            # invoke per-item error handling- perhaps returning this as a synthetic loop result?
                             failed[module] = res
                         elif res.get('skipped', False):
                             skipped[module] = res
@@ -180,16 +177,19 @@ class ActionModule(ActionBase):
             self._task.async_val = async_val
 
         if skipped:
-            result['msg'] = "The following modules were skipped: %s\n" % (', '.join(skipped.keys()))
+            result['msg'] = f"The following modules were skipped: {', '.join(skipped.keys())}."
             result['skipped_modules'] = skipped
             if len(skipped) == len(modules):
                 result['skipped'] = True
 
         if failed:
-            result['failed'] = True
-            result['msg'] = "The following modules failed to execute: %s\n" % (', '.join(failed.keys()))
             result['failed_modules'] = failed
 
+            result.update(_error_utils.result_dict_from_captured_errors(
+                msg=f"The following modules failed to execute: {', '.join(failed.keys())}.",
+                errors=[r['exception'] for r in failed.values()],
+            ))
+
         # tell executor facts were gathered
         result['ansible_facts']['_ansible_facts_gathered'] = True
 

ansible/plugins/action/package.py

@@ -16,7 +16,7 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
-from ansible.errors import AnsibleAction, AnsibleActionFail
+from ansible.errors import AnsibleActionFail
 from ansible.executor.module_common import _apply_action_arg_defaults
 from ansible.module_utils.facts.system.pkg_mgr import PKG_MGRS
 from ansible.plugins.action import ActionBase
@@ -38,7 +38,7 @@ class ActionModule(ActionBase):
         self._supports_check_mode = True
         self._supports_async = True
 
-        result = super(ActionModule, self).run(tmp, task_vars)
+        super(ActionModule, self).run(tmp, task_vars)
 
         module = self._task.args.get('use', 'auto')
 
@@ -99,11 +99,8 @@ class ActionModule(ActionBase):
                         module = 'ansible.legacy.' + module
 
                     display.vvvv("Running %s" % module)
-                    result.update(self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars, wrap_async=self._task.async_val))
+                    return self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars, wrap_async=self._task.async_val)
             else:
                 raise AnsibleActionFail('Could not detect which package manager to use. Try gathering facts or setting the "use" option.')
-
-        except AnsibleAction as e:
-            result.update(e.result)
-
-        return result
+        finally:
+            pass  # avoid de-dent all on refactor