ansible-core 2.19.0b5__py3-none-any.whl → 2.19.0b7__py3-none-any.whl

ansible/playbook/playbook_include.py

@@ -19,12 +19,7 @@ from __future__ import annotations
 
 import os
 
-import ansible.constants as C
-from ansible.errors import AnsibleParserError, AnsibleAssertionError
 from ansible.module_utils.common.text.converters import to_bytes
-from ansible.module_utils._internal._datatag import AnsibleTagHelper
-from ansible.module_utils.six import string_types
-from ansible.parsing.splitter import split_args
 from ansible.playbook.attribute import NonInheritableFieldAttribute
 from ansible.playbook.base import Base
 from ansible.playbook.conditional import Conditional
@@ -32,16 +27,29 @@ from ansible.playbook.taggable import Taggable
 from ansible.utils.collection_loader import AnsibleCollectionConfig
 from ansible.utils.collection_loader._collection_finder import _get_collection_name_from_path, _get_collection_playbook_path
 from ansible._internal._templating._engine import TemplateEngine
-from ansible.utils.display import Display
-
-display = Display()
+from ansible.errors import AnsibleError
+from ansible import constants as C
 
 
 class PlaybookInclude(Base, Conditional, Taggable):
 
-    import_playbook = NonInheritableFieldAttribute(isa='string')
+    import_playbook = NonInheritableFieldAttribute(isa='string', required=True)
     vars_val = NonInheritableFieldAttribute(isa='dict', default=dict, alias='vars')
 
+    _post_validate_object = True  # manually post_validate to get free arg validation/coercion
+
+    def preprocess_data(self, ds):
+        keys = {action for action in C._ACTION_IMPORT_PLAYBOOK if action in ds}
+
+        if len(keys) != 1:
+            raise AnsibleError(f'Found conflicting import_playbook actions: {", ".join(sorted(keys))}')
+
+        key = next(iter(keys))
+
+        ds['import_playbook'] = ds.pop(key)
+
+        return ds
+
     @staticmethod
     def load(data, basedir, variable_manager=None, loader=None):
         return PlaybookInclude().load_data(ds=data, basedir=basedir, variable_manager=variable_manager, loader=loader)
@@ -62,18 +70,22 @@ class PlaybookInclude(Base, Conditional, Taggable):
         new_obj = super(PlaybookInclude, self).load_data(ds, variable_manager, loader)
 
         all_vars = self.vars.copy()
+
         if variable_manager:
             all_vars |= variable_manager.get_vars()
 
         templar = TemplateEngine(loader=loader, variables=all_vars)
 
+        new_obj.post_validate(templar)
+
         # then we use the object to load a Playbook
         pb = Playbook(loader=loader)
 
-        file_name = templar.template(new_obj.import_playbook)
+        file_name = new_obj.import_playbook
 
         # check for FQCN
         resource = _get_collection_playbook_path(file_name)
+
         if resource is not None:
             playbook = resource[1]
             playbook_collection = resource[2]
@@ -92,6 +104,7 @@ class PlaybookInclude(Base, Conditional, Taggable):
         else:
             # it is NOT a collection playbook, setup adjacent paths
             AnsibleCollectionConfig.playbook_paths.append(os.path.dirname(os.path.abspath(to_bytes(playbook, errors='surrogate_or_strict'))))
+            # broken, see: https://github.com/ansible/ansible/issues/85357
 
         pb._load_playbook_data(file_name=playbook, variable_manager=variable_manager, vars=self.vars.copy())
 
@@ -120,49 +133,3 @@ class PlaybookInclude(Base, Conditional, Taggable):
                     task_block._when = new_obj.when[:] + task_block.when[:]
 
         return pb
-
-    def preprocess_data(self, ds):
-        """
-        Reorganizes the data for a PlaybookInclude datastructure to line
-        up with what we expect the proper attributes to be
-        """
-
-        if not isinstance(ds, dict):
-            raise AnsibleAssertionError('ds (%s) should be a dict but was a %s' % (ds, type(ds)))
-
-        # the new, cleaned datastructure, which will have legacy items reduced to a standard structure suitable for the
-        # attributes of the task class; copy any tagged data to preserve things like origin
-        new_ds = AnsibleTagHelper.tag_copy(ds, {})
-
-        for (k, v) in ds.items():
-            if k in C._ACTION_IMPORT_PLAYBOOK:
-                self._preprocess_import(ds, new_ds, k, v)
-            else:
-                # some basic error checking, to make sure vars are properly
-                # formatted and do not conflict with k=v parameters
-                if k == 'vars':
-                    if 'vars' in new_ds:
-                        raise AnsibleParserError("import_playbook parameters cannot be mixed with 'vars' entries for import statements", obj=ds)
-                    elif not isinstance(v, dict):
-                        raise AnsibleParserError("vars for import_playbook statements must be specified as a dictionary", obj=ds)
-                new_ds[k] = v
-
-        return super(PlaybookInclude, self).preprocess_data(new_ds)
-
-    def _preprocess_import(self, ds, new_ds, k, v):
-        """
-        Splits the playbook import line up into filename and parameters
-        """
-        if v is None:
-            raise AnsibleParserError("playbook import parameter is missing", obj=ds)
-        elif not isinstance(v, string_types):
-            raise AnsibleParserError("playbook import parameter must be a string indicating a file path, got %s instead" % type(v), obj=ds)
-
-        # The import_playbook line must include at least one item, which is the filename
-        # to import. Anything after that should be regarded as a parameter to the import
-        items = split_args(v)
-        if len(items) == 0:
-            raise AnsibleParserError("import_playbook statements must specify the file name to import", obj=ds)
-
-        # DTFIX3: investigate this as a possible "problematic strip"
-        new_ds['import_playbook'] = AnsibleTagHelper.tag_copy(v, items[0].strip())

ansible/playbook/role/__init__.py

@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import os
+import typing as _t
 
 from collections.abc import Container, Mapping, Set, Sequence
 from types import MappingProxyType
@@ -39,6 +40,16 @@ from ansible.utils.collection_loader import AnsibleCollectionConfig
 from ansible.utils.path import is_subpath
 from ansible.utils.vars import combine_vars
 
+# NOTE: This import is only needed for the type-checking in __init__. While there's an alternative
+#       available by using forward references this seems not to work well with commonly used IDEs.
+#       Therefore the TYPE_CHECKING hack seems to be a more universal approach, even if not being very elegant.
+#       References:
+#       * https://stackoverflow.com/q/39740632/199513
+#       * https://peps.python.org/pep-0484/#forward-references
+if _t.TYPE_CHECKING:
+    from ansible.playbook.block import Block
+    from ansible.playbook.play import Play
+
 __all__ = ['Role', 'hash_params']
 
 # TODO: this should be a utility function, but can't be a member of
@@ -97,13 +108,19 @@ def hash_params(params):
 
 class Role(Base, Conditional, Taggable, CollectionSearch, Delegatable):
 
-    def __init__(self, play=None, from_files=None, from_include=False, validate=True, public=None, static=True):
-        self._role_name = None
-        self._role_path = None
-        self._role_collection = None
-        self._role_params = dict()
+    def __init__(self,
+                 play: Play = None,
+                 from_files: dict[str, list[str]] = None,
+                 from_include: bool = False,
+                 validate: bool = True,
+                 public: bool = None,
+                 static: bool = True) -> None:
+        self._role_name: str = None
+        self._role_path: str = None
+        self._role_collection: str = None
+        self._role_params: dict[str, dict[str, str]] = dict()
         self._loader = None
-        self.static = static
+        self.static: bool = static
 
         # includes (static=false) default to private, while imports (static=true) default to public
         # but both can be overridden by global config if set
@@ -116,26 +133,26 @@ class Role(Base, Conditional, Taggable, CollectionSearch, Delegatable):
         else:
             self.public = public
 
-        self._metadata = RoleMetadata()
-        self._play = play
-        self._parents = []
-        self._dependencies = []
-        self._all_dependencies = None
-        self._task_blocks = []
-        self._handler_blocks = []
-        self._compiled_handler_blocks = None
-        self._default_vars = dict()
-        self._role_vars = dict()
-        self._had_task_run = dict()
-        self._completed = dict()
-        self._should_validate = validate
+        self._metadata: RoleMetadata = RoleMetadata()
+        self._play: Play = play
+        self._parents: list[Role] = []
+        self._dependencies: list[Role] = []
+        self._all_dependencies: list[Role] | None = None
+        self._task_blocks: list[Block] = []
+        self._handler_blocks: list[Block] = []
+        self._compiled_handler_blocks: list[Block] | None = None
+        self._default_vars: dict[str, str] | None = dict()
+        self._role_vars: dict[str, str] | None = dict()
+        self._had_task_run: dict[str, bool] = dict()
+        self._completed: dict[str, bool] = dict()
+        self._should_validate: bool = validate
 
         if from_files is None:
             from_files = {}
-        self._from_files = from_files
+        self._from_files: dict[str, list[str]] = from_files
 
         # Indicates whether this role was included via include/import_role
-        self.from_include = from_include
+        self.from_include: bool = from_include
 
         self._hash = None
 

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):
@@ -49,16 +51,28 @@ class Taggable:
 
         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/action/__init__.py

@@ -103,7 +103,7 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
         self._display = display
 
     @abstractmethod
-    def run(self, tmp=None, task_vars=None):
+    def run(self, tmp: str | None = None, task_vars: dict[str, t.Any] | None = None) -> dict[str, t.Any]:
         """ Action Plugins should implement this method to perform their
         tasks.  Everything else in this base class is a helper method for the
         action plugin to do that.
@@ -120,7 +120,7 @@ class ActionBase(ABC, _AnsiblePluginInfoMixin):
         * Module parameters.  These are stored in self._task.args
         """
         # does not default to {'changed': False, 'failed': False}, as it used to break async
-        result = {}
+        result: dict[str, t.Any] = {}
 
         if tmp is not None:
             display.warning('ActionModule.run() no longer honors the tmp parameter. Action'

ansible/plugins/action/assemble.py

@@ -81,9 +81,10 @@ class ActionModule(ActionBase):
 
     def run(self, tmp=None, task_vars=None):
 
-        self._supports_check_mode = False
+        self._supports_check_mode = True
 
         super(ActionModule, self).run(tmp, task_vars)
+
         del tmp  # tmp no longer has any effect
 
         if task_vars is None:

ansible/plugins/action/assert.py

@@ -72,12 +72,12 @@ class ActionModule(ActionBase):
         fail_msg = new_module_args['fail_msg']
         success_msg = new_module_args['success_msg']
         quiet = new_module_args['quiet']
-        thats = new_module_args['that']
+        that_list = new_module_args['that']
 
         if not quiet:
             result['_ansible_verbose_always'] = True
 
-        for that in thats:
+        for that in that_list:
             test_result = self._templar.evaluate_conditional(conditional=that)
             if not test_result:
                 result['failed'] = True

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/script.py

@@ -20,6 +20,7 @@ import os
 import pathlib
 import re
 import shlex
+import typing as _t
 
 from ansible.errors import AnsibleError, AnsibleActionFail, AnsibleActionSkip
 from ansible.executor.powershell import module_manifest as ps_manifest
@@ -35,7 +36,7 @@ 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):
+    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()
@@ -130,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:
@@ -164,10 +165,10 @@ class ActionModule(ActionBase):
                 script_cmd = self._connection._shell.build_module_command(env_string='', shebang='#!powershell', cmd='')
 
             # now we execute script, always assume changed.
-            result = dict(self._low_level_execute_command(cmd=script_cmd, in_data=exec_data, sudoable=True, chdir=chdir), changed=True)
+            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=result)
+                result.update(msg='non-zero return code', failed=True)
 
             return result
         finally:

ansible/plugins/action/template.py

@@ -25,7 +25,8 @@ from ansible.module_utils.common.text.converters import to_bytes, to_text, to_na
 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, trust_as_template
+from ansible.template import trust_as_template
+from ansible._internal._templating import _template_vars
 
 
 class ActionModule(ActionBase):
@@ -43,7 +44,7 @@ class ActionModule(ActionBase):
         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:
@@ -115,7 +116,12 @@ class ActionModule(ActionBase):
 
             # add ansible 'template' vars
             temp_vars = task_vars.copy()
-            temp_vars.update(generate_ansible_template_vars(self._task.args.get('src', None), fullpath=source, dest_path=dest))
+            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,

ansible/plugins/cache/__init__.py

@@ -18,7 +18,6 @@
 from __future__ import annotations
 
 import copy
-import errno
 import os
 import tempfile
 import time
@@ -108,8 +107,8 @@ class BaseFileCacheModule(BaseCacheModule):
         if not os.path.exists(self._cache_dir):
             try:
                 os.makedirs(self._cache_dir)
-            except (OSError, IOError) as e:
-                raise AnsibleError("error in '%s' cache plugin while trying to create cache dir %s : %s" % (self.plugin_name, self._cache_dir, to_bytes(e)))
+            except OSError as ex:
+                raise AnsibleError(f"Error in {self.plugin_name!r} cache plugin while trying to create cache dir {self._cache_dir!r}.") from ex
         else:
             for x in (os.R_OK, os.W_OK, os.X_OK):
                 if not os.access(self._cache_dir, x):
@@ -160,13 +159,13 @@ class BaseFileCacheModule(BaseCacheModule):
         try:
             try:
                 self._dump(value, tmpfile_path)
-            except (OSError, IOError) as e:
-                display.warning("error in '%s' cache plugin while trying to write to '%s' : %s" % (self.plugin_name, tmpfile_path, to_bytes(e)))
+            except OSError as ex:
+                display.error_as_warning(f"Error in {self.plugin_name!r} cache plugin while trying to write to {tmpfile_path!r}.", exception=ex)
             try:
                 os.rename(tmpfile_path, cachefile)
                 os.chmod(cachefile, mode=S_IRWU_RG_RO)
-            except (OSError, IOError) as e:
-                display.warning("error in '%s' cache plugin while trying to move '%s' to '%s' : %s" % (self.plugin_name, tmpfile_path, cachefile, to_bytes(e)))
+            except OSError as ex:
+                display.error_as_warning(f"Error in {self.plugin_name!r} cache plugin while trying to move {tmpfile_path!r} to {cachefile!r}.", exception=ex)
         finally:
             try:
                 os.unlink(tmpfile_path)
@@ -181,12 +180,12 @@ class BaseFileCacheModule(BaseCacheModule):
         cachefile = self._get_cache_file_name(key)
         try:
             st = os.stat(cachefile)
-        except (OSError, IOError) as e:
-            if e.errno == errno.ENOENT:
-                return False
-            else:
-                display.warning("error in '%s' cache plugin while trying to stat %s : %s" % (self.plugin_name, cachefile, to_bytes(e)))
-                return False
+        except FileNotFoundError:
+            return False
+        except OSError as ex:
+            display.error_as_warning(f"Error in {self.plugin_name!r} cache plugin while trying to stat {cachefile!r}.", exception=ex)
+
+            return False
 
         if time.time() - st.st_mtime <= self._timeout:
             return False
@@ -223,11 +222,10 @@ class BaseFileCacheModule(BaseCacheModule):
         try:
             os.stat(cachefile)
             return True
-        except (OSError, IOError) as e:
-            if e.errno == errno.ENOENT:
-                return False
-            else:
-                display.warning("error in '%s' cache plugin while trying to stat %s : %s" % (self.plugin_name, cachefile, to_bytes(e)))
+        except FileNotFoundError:
+            return False
+        except OSError as ex:
+            display.error_as_warning(f"Error in {self.plugin_name!r} cache plugin while trying to stat {cachefile!r}.", exception=ex)
 
     def delete(self, key):
         try:
@@ -236,7 +234,7 @@ class BaseFileCacheModule(BaseCacheModule):
             pass
         try:
             os.remove(self._get_cache_file_name(key))
-        except (OSError, IOError):
+        except OSError:
             pass  # TODO: only pass on non existing?
 
     def flush(self):