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

ansible/plugins/action/package.py

@@ -16,8 +16,8 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
-from ansible.errors import AnsibleAction, AnsibleActionFail
-from ansible.executor.module_common import get_action_args_with_defaults
+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
 from ansible.utils.display import Display
@@ -33,12 +33,12 @@ class ActionModule(ActionBase):
     BUILTIN_PKG_MGR_MODULES = {manager['name'] for manager in PKG_MGRS}
 
     def run(self, tmp=None, task_vars=None):
-        ''' handler for package operations '''
+        """ handler for package operations """
 
         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')
 
@@ -92,21 +92,15 @@ class ActionModule(ActionBase):
 
                     # get defaults for specific module
                     context = self._shared_loader_obj.module_loader.find_plugin_with_context(module, collection_list=self._task.collections)
-                    new_module_args = get_action_args_with_defaults(
-                        context.resolved_fqcn, new_module_args, self._task.module_defaults, self._templar,
-                        action_groups=self._task._parent._play._action_groups
-                    )
+                    new_module_args = _apply_action_arg_defaults(context.resolved_fqcn, self._task, new_module_args, self._templar)
 
                     if module in self.BUILTIN_PKG_MGR_MODULES:
                         # prefix with ansible.legacy to eliminate external collisions while still allowing library/ override
                         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

ansible/plugins/action/pause.py

@@ -28,12 +28,12 @@ display = Display()
 
 
 class ActionModule(ActionBase):
-    ''' pauses execution for a length or time, or until input is received '''
+    """ pauses execution for a length or time, or until input is received """
 
     BYPASS_HOST_LOOP = True
 
     def run(self, tmp=None, task_vars=None):
-        ''' run the pause action module '''
+        """ run the pause action module """
         if task_vars is None:
             task_vars = dict()
 

ansible/plugins/action/script.py

@@ -17,10 +17,12 @@
 from __future__ import annotations
 
 import os
+import pathlib
 import re
 import shlex
+import typing as _t
 
-from ansible.errors import AnsibleError, AnsibleAction, _AnsibleActionDone, AnsibleActionFail, AnsibleActionSkip
+from ansible.errors import AnsibleError, AnsibleActionFail, AnsibleActionSkip
 from ansible.executor.powershell import module_manifest as ps_manifest
 from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
 from ansible.plugins.action import ActionBase
@@ -34,8 +36,8 @@ class ActionModule(ActionBase):
     # after chopping off a potential drive letter.
     windows_absolute_path_detection = re.compile(r'^(?:[a-zA-Z]\:)?(\\|\/)')
 
-    def run(self, tmp=None, task_vars=None):
-        ''' handler for file transfer operations '''
+    def run(self, tmp: str | None = None, task_vars: dict[str, _t.Any] | None = None) -> dict[str, _t.Any]:
+        """ handler for file transfer operations """
         if task_vars is None:
             task_vars = dict()
 
@@ -48,12 +50,11 @@ class ActionModule(ActionBase):
                 'chdir': {'type': 'str'},
                 'executable': {'type': 'str'},
             },
-            required_one_of=[
-                ['_raw_params', 'cmd']
-            ]
+            required_one_of=[['_raw_params', 'cmd']],
+            mutually_exclusive=[['_raw_params', 'cmd']],
         )
 
-        result = super(ActionModule, self).run(tmp, task_vars)
+        super(ActionModule, self).run(tmp, task_vars)
         del tmp  # tmp no longer has any effect
 
         try:
@@ -88,7 +89,7 @@ class ActionModule(ActionBase):
             # Split out the script as the first item in raw_params using
             # shlex.split() in order to support paths and files with spaces in the name.
             # Any arguments passed to the script will be added back later.
-            raw_params = to_native(new_module_args.get('_raw_params', ''), errors='surrogate_or_strict')
+            raw_params = new_module_args['_raw_params'] or new_module_args['cmd']
             parts = [to_text(s, errors='surrogate_or_strict') for s in shlex.split(raw_params.strip())]
             source = parts[0]
 
@@ -105,16 +106,11 @@ class ActionModule(ActionBase):
                 # check mode is supported if 'creates' or 'removes' are provided
                 # the task has already been skipped if a change would not occur
                 if new_module_args['creates'] or new_module_args['removes']:
-                    result['changed'] = True
-                    raise _AnsibleActionDone(result=result)
+                    return dict(changed=True)
                 # If the script doesn't return changed in the result, it defaults to True,
                 # but since the script may override 'changed', just skip instead of guessing.
                 else:
-                    result['changed'] = False
-                    raise AnsibleActionSkip('Check mode is not supported for this task.', result=result)
-
-            # now we execute script, always assume changed.
-            result['changed'] = True
+                    raise AnsibleActionSkip('Check mode is not supported for this task.', result=dict(changed=False))
 
             # transfer the file to a remote tmp location
             tmp_src = self._connection._shell.join_path(self._connection._shell.tmpdir,
@@ -135,7 +131,7 @@ class ActionModule(ActionBase):
             self._fixup_perms2((self._connection._shell.tmpdir, tmp_src), execute=True)
 
             # add preparation steps to one ssh roundtrip executing the script
-            env_dict = dict()
+            env_dict: dict[str, _t.Any] = {}
             env_string = self._compute_environment_string(env_dict)
 
             if executable:
@@ -150,37 +146,30 @@ class ActionModule(ActionBase):
             # like become and environment args
             if getattr(self._connection._shell, "_IS_WINDOWS", False):
                 # FUTURE: use a more public method to get the exec payload
-                become = False
-                become_method = None
-                become_user = None
-                become_pass = None
-                become_flags = None
-                if self._connection.become:
-                    become_plugin = self._connection.become
-                    become = True
-                    become_method = become_plugin.name
-                    become_user = become_plugin.get_option('become_user', playcontext=self._play_context)
-                    become_pass = become_plugin.get_option('become_pass', playcontext=self._play_context)
-                    become_flags = become_plugin.get_option('become_flags', playcontext=self._play_context)
-
+                pc = self._task
                 exec_data = ps_manifest._create_powershell_wrapper(
-                    to_bytes(script_cmd), source, {}, env_dict, self._task.async_val,
-                    become, become_method, become_user,
-                    become_pass, become_flags, "script", task_vars, None
+                    name=f"ansible.builtin.script.{pathlib.Path(source).stem}",
+                    module_data=to_bytes(script_cmd),
+                    module_path=source,
+                    module_args={},
+                    environment=env_dict,
+                    async_timeout=self._task.async_val,
+                    become_plugin=self._connection.become,
+                    substyle="script",
+                    task_vars=task_vars,
+                    profile='legacy',  # the profile doesn't really matter since the module args dict is empty
                 )
                 # build the necessary exec wrapper command
                 # FUTURE: this still doesn't let script work on Windows with non-pipelined connections or
                 # full manual exec of KEEP_REMOTE_FILES
                 script_cmd = self._connection._shell.build_module_command(env_string='', shebang='#!powershell', cmd='')
 
-            result.update(self._low_level_execute_command(cmd=script_cmd, in_data=exec_data, sudoable=True, chdir=chdir))
+            # now we execute script, always assume changed.
+            result: dict[str, object] = dict(self._low_level_execute_command(cmd=script_cmd, in_data=exec_data, sudoable=True, chdir=chdir), changed=True)
 
             if 'rc' in result and result['rc'] != 0:
-                raise AnsibleActionFail('non-zero return code')
+                result.update(msg='non-zero return code', failed=True)
 
-        except AnsibleAction as e:
-            result.update(e.result)
+            return result
         finally:
             self._remove_tmp_path(self._connection._shell.tmpdir)
-
-        return result

ansible/plugins/action/service.py

@@ -16,9 +16,8 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
-
-from ansible.errors import AnsibleAction, AnsibleActionFail
-from ansible.executor.module_common import get_action_args_with_defaults
+from ansible.errors import AnsibleActionFail
+from ansible.executor.module_common import _apply_action_arg_defaults
 from ansible.plugins.action import ActionBase
 
 
@@ -35,22 +34,21 @@ class ActionModule(ActionBase):
     BUILTIN_SVC_MGR_MODULES = set(['openwrt_init', 'service', 'systemd', 'sysvinit'])
 
     def run(self, tmp=None, task_vars=None):
-        ''' handler for package operations '''
+        """ handler for package operations """
 
         self._supports_check_mode = True
         self._supports_async = True
 
-        result = super(ActionModule, self).run(tmp, task_vars)
+        super(ActionModule, self).run(tmp, task_vars)
         del tmp  # tmp no longer has any effect
 
         module = self._task.args.get('use', 'auto').lower()
 
         if module == 'auto':
             try:
-                if self._task.delegate_to:  # if we delegate, we should use delegated host's facts
-                    module = self._templar.template("{{hostvars['%s']['ansible_facts']['service_mgr']}}" % self._task.delegate_to)
-                else:
-                    module = self._templar.template('{{ansible_facts.service_mgr}}')
+                # if we delegate, we should use delegated host's facts
+                expr = "hostvars[delegate_to].ansible_facts.service_mgr" if self._task.delegate_to else "ansible_facts.service_mgr"
+                module = self._templar.resolve_variable_expression(expr, local_variables=dict(delegate_to=self._task.delegate_to))
             except Exception:
                 pass  # could not get it from template!
 
@@ -79,24 +77,17 @@ class ActionModule(ActionBase):
 
                 # get defaults for specific module
                 context = self._shared_loader_obj.module_loader.find_plugin_with_context(module, collection_list=self._task.collections)
-                new_module_args = get_action_args_with_defaults(
-                    context.resolved_fqcn, new_module_args, self._task.module_defaults, self._templar,
-                    action_groups=self._task._parent._play._action_groups
-                )
+                new_module_args = _apply_action_arg_defaults(context.resolved_fqcn, self._task, new_module_args, self._templar)
 
                 # collection prefix known internal modules to avoid collisions from collections search, while still allowing library/ overrides
                 if module in self.BUILTIN_SVC_MGR_MODULES:
                     module = 'ansible.legacy.' + module
 
                 self._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 service manager to use. Try gathering facts or setting the "use" option.')
 
-        except AnsibleAction as e:
-            result.update(e.result)
         finally:
             if not self._task.async_val:
                 self._remove_tmp_path(self._connection._shell.tmpdir)
-
-        return result

ansible/plugins/action/set_fact.py

@@ -18,12 +18,9 @@
 from __future__ import annotations
 
 from ansible.errors import AnsibleActionFail
-from ansible.module_utils.six import string_types
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.plugins.action import ActionBase
-from ansible.utils.vars import isidentifier
-
-import ansible.constants as C
+from ansible.utils.vars import validate_variable_name
 
 
 class ActionModule(ActionBase):
@@ -43,16 +40,10 @@ class ActionModule(ActionBase):
 
         if self._task.args:
             for (k, v) in self._task.args.items():
-                k = self._templar.template(k)
+                k = self._templar.template(k)  # a rare case where key templating is allowed; backward-compatibility for dynamic storage
 
-                if not isidentifier(k):
-                    raise AnsibleActionFail("The variable name '%s' is not valid. Variables must start with a letter or underscore character, "
-                                            "and contain only letters, numbers and underscores." % k)
+                validate_variable_name(k)
 
-                # NOTE: this should really use BOOLEANS from convert_bool, but only in the k=v case,
-                # right now it converts matching explicit YAML strings also when 'jinja2_native' is disabled.
-                if not C.DEFAULT_JINJA2_NATIVE and isinstance(v, string_types) and v.lower() in ('true', 'false', 'yes', 'no'):
-                    v = boolean(v, strict=False)
                 facts[k] = v
         else:
             raise AnsibleActionFail('No key/value pairs provided, at least one is required for this action to succeed')

ansible/plugins/action/set_stats.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.plugins.action import ActionBase
-from ansible.utils.vars import isidentifier
+from ansible.utils.vars import validate_variable_name
 
 
 class ActionModule(ActionBase):
@@ -42,7 +42,7 @@ class ActionModule(ActionBase):
             data = self._task.args.get('data', {})
 
             if not isinstance(data, dict):
-                data = self._templar.template(data, convert_bare=False, fail_on_undefined=True)
+                data = self._templar.template(data)
 
             if not isinstance(data, dict):
                 result['failed'] = True
@@ -59,14 +59,9 @@ class ActionModule(ActionBase):
                         stats[opt] = val
 
             for (k, v) in data.items():
-
                 k = self._templar.template(k)
 
-                if not isidentifier(k):
-                    result['failed'] = True
-                    result['msg'] = ("The variable name '%s' is not valid. Variables must start with a letter or underscore character, and contain only "
-                                     "letters, numbers and underscores." % k)
-                    return result
+                validate_variable_name(k)
 
                 stats['data'][k] = self._templar.template(v)
 

ansible/plugins/action/template.py

@@ -20,12 +20,13 @@ from jinja2.defaults import (
 
 from ansible import constants as C
 from ansible.config.manager import ensure_type
-from ansible.errors import AnsibleError, AnsibleFileNotFound, AnsibleAction, AnsibleActionFail
+from ansible.errors import AnsibleError, AnsibleActionFail
 from ansible.module_utils.common.text.converters import to_bytes, to_text, to_native
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.module_utils.six import string_types
 from ansible.plugins.action import ActionBase
-from ansible.template import generate_ansible_template_vars, AnsibleEnvironment
+from ansible.template import trust_as_template
+from ansible._internal._templating import _template_vars
 
 
 class ActionModule(ActionBase):
@@ -34,16 +35,16 @@ class ActionModule(ActionBase):
     DEFAULT_NEWLINE_SEQUENCE = "\n"
 
     def run(self, tmp=None, task_vars=None):
-        ''' handler for template operations '''
+        """ handler for template operations """
 
         if task_vars is None:
             task_vars = dict()
 
-        result = super(ActionModule, self).run(tmp, task_vars)
+        super(ActionModule, self).run(tmp, task_vars)
         del tmp  # tmp no longer has any effect
 
         # Options type validation
-        # stings
+        # strings
         for s_type in ('src', 'dest', 'state', 'newline_sequence', 'variable_start_string', 'variable_end_string', 'block_start_string',
                        'block_end_string', 'comment_start_string', 'comment_end_string'):
             if s_type in self._task.args:
@@ -98,63 +99,47 @@ class ActionModule(ActionBase):
             if mode == 'preserve':
                 mode = '0%03o' % stat.S_IMODE(os.stat(source).st_mode)
 
-            # Get vault decrypted tmp file
-            try:
-                tmp_source = self._loader.get_real_file(source)
-            except AnsibleFileNotFound as e:
-                raise AnsibleActionFail("could not find src=%s, %s" % (source, to_text(e)))
-            b_tmp_source = to_bytes(tmp_source, errors='surrogate_or_strict')
-
             # template the source data locally & get ready to transfer
-            try:
-                with open(b_tmp_source, 'rb') as f:
-                    try:
-                        template_data = to_text(f.read(), errors='surrogate_or_strict')
-                    except UnicodeError:
-                        raise AnsibleActionFail("Template source files must be utf-8 encoded")
-
-                # set jinja2 internal search path for includes
-                searchpath = task_vars.get('ansible_search_path', [])
-                searchpath.extend([self._loader._basedir, os.path.dirname(source)])
-
-                # We want to search into the 'templates' subdir of each search path in
-                # addition to our original search paths.
-                newsearchpath = []
-                for p in searchpath:
-                    newsearchpath.append(os.path.join(p, 'templates'))
-                    newsearchpath.append(p)
-                searchpath = newsearchpath
-
-                # add ansible 'template' vars
-                temp_vars = task_vars.copy()
-                # NOTE in the case of ANSIBLE_DEBUG=1 task_vars is VarsWithSources(MutableMapping)
-                # so | operator cannot be used as it can be used only on dicts
-                # https://peps.python.org/pep-0584/#what-about-mapping-and-mutablemapping
-                temp_vars.update(generate_ansible_template_vars(self._task.args.get('src', None), source, dest))
-
-                # force templar to use AnsibleEnvironment to prevent issues with native types
-                # https://github.com/ansible/ansible/issues/46169
-                templar = self._templar.copy_with_new_env(environment_class=AnsibleEnvironment,
-                                                          searchpath=searchpath,
-                                                          newline_sequence=newline_sequence,
-                                                          available_variables=temp_vars)
-                overrides = dict(
-                    block_start_string=block_start_string,
-                    block_end_string=block_end_string,
-                    variable_start_string=variable_start_string,
-                    variable_end_string=variable_end_string,
-                    comment_start_string=comment_start_string,
-                    comment_end_string=comment_end_string,
-                    trim_blocks=trim_blocks,
-                    lstrip_blocks=lstrip_blocks
-                )
-                resultant = templar.do_template(template_data, preserve_trailing_newlines=True, escape_backslashes=False, overrides=overrides)
-            except AnsibleAction:
-                raise
-            except Exception as e:
-                raise AnsibleActionFail("%s: %s" % (type(e).__name__, to_text(e)))
-            finally:
-                self._loader.cleanup_tmp_file(b_tmp_source)
+            template_data = trust_as_template(self._loader.get_text_file_contents(source))
+
+            # set jinja2 internal search path for includes
+            searchpath = task_vars.get('ansible_search_path', [])
+            searchpath.extend([self._loader._basedir, os.path.dirname(source)])
+
+            # We want to search into the 'templates' subdir of each search path in
+            # addition to our original search paths.
+            newsearchpath = []
+            for p in searchpath:
+                newsearchpath.append(os.path.join(p, 'templates'))
+                newsearchpath.append(p)
+            searchpath = newsearchpath
+
+            # add ansible 'template' vars
+            temp_vars = task_vars.copy()
+            temp_vars.update(_template_vars.generate_ansible_template_vars(
+                path=self._task.args.get('src', None),
+                fullpath=source,
+                dest_path=dest,
+                include_ansible_managed='ansible_managed' not in temp_vars,  # do not clobber ansible_managed when set by the user
+            ))
+
+            overrides = dict(
+                block_start_string=block_start_string,
+                block_end_string=block_end_string,
+                variable_start_string=variable_start_string,
+                variable_end_string=variable_end_string,
+                comment_start_string=comment_start_string,
+                comment_end_string=comment_end_string,
+                trim_blocks=trim_blocks,
+                lstrip_blocks=lstrip_blocks,
+                newline_sequence=newline_sequence,
+            )
+
+            data_templar = self._templar.copy_with_new_env(searchpath=searchpath, available_variables=temp_vars)
+            resultant = data_templar.template(template_data, escape_backslashes=False, overrides=overrides)
+
+            if resultant is None:
+                resultant = ''
 
             new_task = self._task.copy()
             # mode is either the mode from task.args or the mode of the source file if the task.args
@@ -188,13 +173,8 @@ class ActionModule(ActionBase):
                                                                         loader=self._loader,
                                                                         templar=self._templar,
                                                                         shared_loader_obj=self._shared_loader_obj)
-                result.update(copy_action.run(task_vars=task_vars))
+                return copy_action.run(task_vars=task_vars)
             finally:
                 shutil.rmtree(to_bytes(local_tempdir, errors='surrogate_or_strict'))
-
-        except AnsibleAction as e:
-            result.update(e.result)
         finally:
             self._remove_tmp_path(self._connection._shell.tmpdir)
-
-        return result

ansible/plugins/action/unarchive.py

@@ -19,8 +19,7 @@ from __future__ import annotations
 
 import os
 
-from ansible.errors import AnsibleError, AnsibleAction, AnsibleActionFail, AnsibleActionSkip
-from ansible.module_utils.common.text.converters import to_text
+from ansible.errors import AnsibleActionFail, AnsibleActionSkip
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.plugins.action import ActionBase
 
@@ -30,11 +29,11 @@ class ActionModule(ActionBase):
     TRANSFERS_FILES = True
 
     def run(self, tmp=None, task_vars=None):
-        ''' handler for unarchive operations '''
+        """ handler for unarchive operations """
         if task_vars is None:
             task_vars = dict()
 
-        result = super(ActionModule, self).run(tmp, task_vars)
+        super(ActionModule, self).run(tmp, task_vars)
         del tmp  # tmp no longer has any effect
 
         source = self._task.args.get('src', None)
@@ -68,15 +67,9 @@ class ActionModule(ActionBase):
             source = os.path.expanduser(source)
 
             if not remote_src:
-                try:
-                    source = self._loader.get_real_file(self._find_needle('files', source), decrypt=decrypt)
-                except AnsibleError as e:
-                    raise AnsibleActionFail(to_text(e))
+                source = self._loader.get_real_file(self._find_needle('files', source), decrypt=decrypt)
 
-            try:
-                remote_stat = self._execute_remote_stat(dest, all_vars=task_vars, follow=True)
-            except AnsibleError as e:
-                raise AnsibleActionFail(to_text(e))
+            remote_stat = self._execute_remote_stat(dest, all_vars=task_vars, follow=True)
 
             if not remote_stat['exists'] or not remote_stat['isdir']:
                 raise AnsibleActionFail("dest '%s' must be an existing dir" % dest)
@@ -102,9 +95,6 @@ class ActionModule(ActionBase):
 
             # execute the unarchive module now, with the updated args (using ansible.legacy prefix to eliminate collections
             # collisions with local override
-            result.update(self._execute_module(module_name='ansible.legacy.unarchive', module_args=new_module_args, task_vars=task_vars))
-        except AnsibleAction as e:
-            result.update(e.result)
+            return self._execute_module(module_name='ansible.legacy.unarchive', module_args=new_module_args, task_vars=task_vars)
         finally:
             self._remove_tmp_path(self._connection._shell.tmpdir)
-        return result

ansible/plugins/action/uri.py

@@ -5,11 +5,10 @@
 
 from __future__ import annotations
 
+import collections.abc as _c
 import os
 
-from ansible.errors import AnsibleError, AnsibleAction, _AnsibleActionDone, AnsibleActionFail
-from ansible.module_utils.common.text.converters import to_native
-from ansible.module_utils.common.collections import Mapping, MutableMapping
+from ansible.errors import AnsibleActionFail
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.plugins.action import ActionBase
 
@@ -25,7 +24,7 @@ class ActionModule(ActionBase):
         if task_vars is None:
             task_vars = dict()
 
-        result = super(ActionModule, self).run(tmp, task_vars)
+        super(ActionModule, self).run(tmp, task_vars)
         del tmp  # tmp no longer has any effect
 
         body_format = self._task.args.get('body_format', 'raw')
@@ -38,38 +37,31 @@ class ActionModule(ActionBase):
                 # everything is remote, so we just execute the module
                 # without changing any of the module arguments
                 # call with ansible.legacy prefix to prevent collections collisions while allowing local override
-                raise _AnsibleActionDone(result=self._execute_module(module_name='ansible.legacy.uri',
-                                                                     task_vars=task_vars, wrap_async=self._task.async_val))
+                return self._execute_module(module_name='ansible.legacy.uri', task_vars=task_vars, wrap_async=self._task.async_val)
 
             kwargs = {}
 
             if src:
-                try:
-                    src = self._find_needle('files', src)
-                except AnsibleError as e:
-                    raise AnsibleActionFail(to_native(e))
+                src = self._find_needle('files', src)
 
                 tmp_src = self._connection._shell.join_path(self._connection._shell.tmpdir, os.path.basename(src))
                 kwargs['src'] = tmp_src
                 self._transfer_file(src, tmp_src)
                 self._fixup_perms2((self._connection._shell.tmpdir, tmp_src))
             elif body_format == 'form-multipart':
-                if not isinstance(body, Mapping):
+                if not isinstance(body, _c.Mapping):
                     raise AnsibleActionFail(
                         'body must be mapping, cannot be type %s' % body.__class__.__name__
                     )
                 for field, value in body.items():
-                    if not isinstance(value, MutableMapping):
+                    if not isinstance(value, _c.MutableMapping):
                         continue
                     content = value.get('content')
                     filename = value.get('filename')
                     if not filename or content:
                         continue
 
-                    try:
-                        filename = self._find_needle('files', filename)
-                    except AnsibleError as e:
-                        raise AnsibleActionFail(to_native(e))
+                    filename = self._find_needle('files', filename)
 
                     tmp_src = self._connection._shell.join_path(
                         self._connection._shell.tmpdir,
@@ -83,10 +75,7 @@ class ActionModule(ActionBase):
             new_module_args = self._task.args | kwargs
 
             # call with ansible.legacy prefix to prevent collections collisions while allowing local override
-            result.update(self._execute_module('ansible.legacy.uri', module_args=new_module_args, task_vars=task_vars, wrap_async=self._task.async_val))
-        except AnsibleAction as e:
-            result.update(e.result)
+            return self._execute_module('ansible.legacy.uri', module_args=new_module_args, task_vars=task_vars, wrap_async=self._task.async_val)
         finally:
             if not self._task.async_val:
                 self._remove_tmp_path(self._connection._shell.tmpdir)
-        return result