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

ansible/playbook/block.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import ansible.constants as C
 from ansible.errors import AnsibleParserError
+from ansible.module_utils.common.sentinel import Sentinel
 from ansible.playbook.attribute import NonInheritableFieldAttribute
 from ansible.playbook.base import Base
 from ansible.playbook.conditional import Conditional
@@ -28,7 +29,6 @@ from ansible.playbook.helpers import load_list_of_tasks
 from ansible.playbook.notifiable import Notifiable
 from ansible.playbook.role import Role
 from ansible.playbook.taggable import Taggable
-from ansible.utils.sentinel import Sentinel
 
 
 class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatable):
@@ -61,18 +61,18 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
         return "BLOCK(uuid=%s)(id=%s)(parent=%s)" % (self._uuid, id(self), self._parent)
 
     def __eq__(self, other):
-        '''object comparison based on _uuid'''
+        """object comparison based on _uuid"""
         return self._uuid == other._uuid
 
     def __ne__(self, other):
-        '''object comparison based on _uuid'''
+        """object comparison based on _uuid"""
         return self._uuid != other._uuid
 
     def get_vars(self):
-        '''
+        """
         Blocks do not store variables directly, however they may be a member
         of a role or task include which does, so return those if present.
-        '''
+        """
 
         all_vars = {}
 
@@ -100,10 +100,10 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
         return is_block
 
     def preprocess_data(self, ds):
-        '''
+        """
         If a simple task is given, an implicit block for that single task
         is created, which goes in the main portion of the block
-        '''
+        """
 
         if not Block.is_block(ds):
             if isinstance(ds, list):
@@ -113,6 +113,8 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
 
         return super(Block, self).preprocess_data(ds)
 
+    # FIXME: these do nothing but augment the exception message; DRY and nuke
+
     def _load_block(self, attr, ds):
         try:
             return load_list_of_tasks(
@@ -125,8 +127,8 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
                 loader=self._loader,
                 use_handlers=self._use_handlers,
             )
-        except AssertionError as e:
-            raise AnsibleParserError("A malformed block was encountered while loading a block", obj=self._ds, orig_exc=e)
+        except AssertionError as ex:
+            raise AnsibleParserError("A malformed block was encountered while loading a block", obj=self._ds) from ex
 
     def _load_rescue(self, attr, ds):
         try:
@@ -140,8 +142,8 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
                 loader=self._loader,
                 use_handlers=self._use_handlers,
             )
-        except AssertionError as e:
-            raise AnsibleParserError("A malformed block was encountered while loading rescue.", obj=self._ds, orig_exc=e)
+        except AssertionError as ex:
+            raise AnsibleParserError("A malformed block was encountered while loading rescue.", obj=self._ds) from ex
 
     def _load_always(self, attr, ds):
         try:
@@ -155,8 +157,8 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
                 loader=self._loader,
                 use_handlers=self._use_handlers,
             )
-        except AssertionError as e:
-            raise AnsibleParserError("A malformed block was encountered while loading always", obj=self._ds, orig_exc=e)
+        except AssertionError as ex:
+            raise AnsibleParserError("A malformed block was encountered while loading always", obj=self._ds) from ex
 
     def _validate_always(self, attr, name, value):
         if value and not self.block:
@@ -177,7 +179,7 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
         def _dupe_task_list(task_list, new_block):
             new_task_list = []
             for task in task_list:
-                new_task = task.copy(exclude_parent=True)
+                new_task = task.copy(exclude_parent=True, exclude_tasks=exclude_tasks)
                 if task._parent:
                     new_task._parent = task._parent.copy(exclude_tasks=True)
                     if task._parent == new_block:
@@ -219,10 +221,10 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
         return new_me
 
     def serialize(self):
-        '''
+        """
         Override of the default serialize method, since when we're serializing
         a task we don't want to include the attribute list of tasks.
-        '''
+        """
 
         data = dict()
         for attr in self.fattributes:
@@ -240,10 +242,10 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
         return data
 
     def deserialize(self, data):
-        '''
+        """
         Override of the default deserialize method, to match the above overridden
         serialize method
-        '''
+        """
 
         # import is here to avoid import loops
         from ansible.playbook.task_include import TaskInclude
@@ -290,9 +292,9 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
                 dep.set_loader(loader)
 
     def _get_parent_attribute(self, attr, omit=False):
-        '''
+        """
         Generic logic to get the attribute or parent attribute for a block value.
-        '''
+        """
         fattr = self.fattributes[attr]
 
         extend = fattr.extend
@@ -363,9 +365,9 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
         return value
 
     def filter_tagged_tasks(self, all_vars):
-        '''
+        """
         Creates a new block, with task lists filtered based on the tags.
-        '''
+        """
 
         def evaluate_and_append_task(target):
             tmp_list = []
@@ -417,12 +419,12 @@ class Block(Base, Conditional, CollectionSearch, Taggable, Notifiable, Delegatab
             return dict()
 
     def all_parents_static(self):
-        '''
+        """
         Determine if all of the parents of this block were statically loaded
         or not. Since Task/TaskInclude objects may be in the chain, they simply
         call their parents all_parents_static() method. Only Block objects in
         the chain check the statically_loaded value of the parent.
-        '''
+        """
         from ansible.playbook.task_include import TaskInclude
         if self._parent:
             if isinstance(self._parent, TaskInclude) and not self._parent.statically_loaded:

ansible/playbook/collectionsearch.py

@@ -6,11 +6,8 @@ from __future__ import annotations
 from ansible.module_utils.six import string_types
 from ansible.playbook.attribute import FieldAttribute
 from ansible.utils.collection_loader import AnsibleCollectionConfig
-from ansible.template import is_template
 from ansible.utils.display import Display
 
-from jinja2.nativetypes import NativeEnvironment
-
 display = Display()
 
 
@@ -35,8 +32,7 @@ def _ensure_default_collection(collection_list=None):
 class CollectionSearch:
 
     # this needs to be populated before we can resolve tasks/roles/etc
-    collections = FieldAttribute(isa='list', listof=string_types, priority=100, default=_ensure_default_collection,
-                                 always_post_validate=True, static=True)
+    collections = FieldAttribute(isa='list', listof=string_types, priority=100, default=_ensure_default_collection, always_post_validate=True, static=True)
 
     def _load_collections(self, attr, ds):
         # We are always a mixin with Base, so we can validate this untemplated
@@ -49,14 +45,4 @@ class CollectionSearch:
         if not ds:  # don't return an empty collection list, just return None
             return None
 
-        # This duplicates static attr checking logic from post_validate()
-        # because if the user attempts to template a collection name, it may
-        # error before it ever gets to the post_validate() warning (e.g. trying
-        # to import a role from the collection).
-        env = NativeEnvironment()
-        for collection_name in ds:
-            if is_template(collection_name, env):
-                display.warning('"collections" is not templatable, but we found: %s, '
-                                'it will not be templated and will be used "as is".' % (collection_name))
-
         return ds

ansible/playbook/conditional.py

@@ -17,97 +17,23 @@
 
 from __future__ import annotations
 
-import typing as t
-
-from ansible.errors import AnsibleError, AnsibleUndefinedVariable, AnsibleTemplateError
-from ansible.module_utils.common.text.converters import to_native
 from ansible.playbook.attribute import FieldAttribute
-from ansible.template import Templar
 from ansible.utils.display import Display
 
 display = Display()
 
 
 class Conditional:
-    '''
+    """
     This is a mix-in class, to be used with Base to allow the object
     to be run conditionally when a condition is met or skipped.
-    '''
+    """
 
     when = FieldAttribute(isa='list', default=list, extend=True, prepend=True)
 
-    def __init__(self, loader=None):
-        # when used directly, this class needs a loader, but we want to
-        # make sure we don't trample on the existing one if this class
-        # is used as a mix-in with a playbook base class
-        if not hasattr(self, '_loader'):
-            if loader is None:
-                raise AnsibleError("a loader must be specified when using Conditional() directly")
-            else:
-                self._loader = loader
+    def __init__(self, *args, **kwargs):
         super().__init__()
 
     def _validate_when(self, attr, name, value):
         if not isinstance(value, list):
             setattr(self, name, [value])
-
-    def evaluate_conditional(self, templar: Templar, all_vars: dict[str, t.Any]) -> bool:
-        '''
-        Loops through the conditionals set on this object, returning
-        False if any of them evaluate as such.
-        '''
-        return self.evaluate_conditional_with_result(templar, all_vars)[0]
-
-    def evaluate_conditional_with_result(self, templar: Templar, all_vars: dict[str, t.Any]) -> tuple[bool, t.Optional[str]]:
-        """Loops through the conditionals set on this object, returning
-        False if any of them evaluate as such as well as the condition
-        that was false.
-        """
-        for conditional in self.when:
-            if conditional is None or conditional == "":
-                res = True
-            elif isinstance(conditional, bool):
-                res = conditional
-            else:
-                try:
-                    res = self._check_conditional(conditional, templar, all_vars)
-                except AnsibleError as e:
-                    raise AnsibleError(
-                        "The conditional check '%s' failed. The error was: %s" % (to_native(conditional), to_native(e)),
-                        obj=getattr(self, '_ds', None)
-                    )
-
-            display.debug("Evaluated conditional (%s): %s" % (conditional, res))
-            if not res:
-                return res, conditional
-
-        return True, None
-
-    def _check_conditional(self, conditional: str, templar: Templar, all_vars: dict[str, t.Any]) -> bool:
-        original = conditional
-        templar.available_variables = all_vars
-        try:
-            if templar.is_template(conditional):
-                display.warning(
-                    "conditional statements should not include jinja2 "
-                    "templating delimiters such as {{ }} or {%% %%}. "
-                    "Found: %s" % conditional
-                )
-                conditional = templar.template(conditional)
-                if isinstance(conditional, bool):
-                    return conditional
-                elif conditional == "":
-                    return False
-
-            # If the result of the first-pass template render (to resolve inline templates) is marked unsafe,
-            # explicitly fail since the next templating operation would never evaluate
-            if hasattr(conditional, '__UNSAFE__'):
-                raise AnsibleTemplateError('Conditional is marked as unsafe, and cannot be evaluated.')
-
-            # NOTE The spaces around True and False are intentional to short-circuit literal_eval for
-            #      jinja2_native=False and avoid its expensive calls.
-            return templar.template(
-                "{%% if %s %%} True {%% else %%} False {%% endif %%}" % conditional,
-            ).strip() == "True"
-        except AnsibleUndefinedVariable as e:
-            raise AnsibleUndefinedVariable("error while evaluating conditional (%s): %s" % (original, e))

ansible/playbook/handler.py

@@ -17,6 +17,7 @@
 
 from __future__ import annotations
 
+from ansible.errors import AnsibleAssertionError
 from ansible.playbook.attribute import NonInheritableFieldAttribute
 from ansible.playbook.task import Task
 from ansible.module_utils.six import string_types
@@ -34,7 +35,7 @@ class Handler(Task):
         super(Handler, self).__init__(block=block, role=role, task_include=task_include)
 
     def __repr__(self):
-        ''' returns a human-readable representation of the handler '''
+        """ returns a human-readable representation of the handler """
         return "HANDLER: %s" % self.get_name()
 
     def _validate_listen(self, attr, name, value):
@@ -59,7 +60,12 @@ class Handler(Task):
         return False
 
     def remove_host(self, host):
-        self.notified_hosts = [h for h in self.notified_hosts if h != host]
+        try:
+            self.notified_hosts.remove(host)
+        except ValueError:
+            raise AnsibleAssertionError(
+                f"Attempting to remove a notification on handler '{self}' for host '{host}' but it has not been notified."
+            )
 
     def clear_hosts(self):
         self.notified_hosts = []

ansible/playbook/helpers.py

@@ -21,19 +21,19 @@ import os
 
 from ansible import constants as C
 from ansible.errors import AnsibleParserError, AnsibleUndefinedVariable, AnsibleAssertionError
-from ansible.module_utils.common.text.converters import to_native
 from ansible.parsing.mod_args import ModuleArgsParser
 from ansible.utils.display import Display
+from ansible._internal._templating._engine import TemplateEngine
 
 display = Display()
 
 
 def load_list_of_blocks(ds, play, parent_block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
-    '''
+    """
     Given a list of mixed task/block data (parsed from YAML),
     return a list of Block() objects, where implicit blocks
     are created for each bare Task.
-    '''
+    """
 
     # we import here to prevent a circular dependency with imports
     from ansible.playbook.block import Block
@@ -80,10 +80,10 @@ def load_list_of_blocks(ds, play, parent_block=None, role=None, task_include=Non
 
 
 def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
-    '''
+    """
     Given a list of task datastructures (parsed from YAML),
     return a list of Task() or TaskInclude() objects.
-    '''
+    """
 
     # we import here to prevent a circular dependency with imports
     from ansible.playbook.block import Block
@@ -92,7 +92,6 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
     from ansible.playbook.task_include import TaskInclude
     from ansible.playbook.role_include import IncludeRole
     from ansible.playbook.handler_task_include import HandlerTaskInclude
-    from ansible.template import Templar
 
     if not isinstance(ds, list):
         raise AnsibleAssertionError('The ds (%s) should be a list but was a %s' % (ds, type(ds)))
@@ -105,7 +104,7 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
         if 'block' in task_ds:
             if use_handlers:
                 raise AnsibleParserError("Using a block as a handler is not supported.", obj=task_ds)
-            t = Block.load(
+            task = Block.load(
                 task_ds,
                 play=play,
                 parent_block=block,
@@ -115,18 +114,20 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
                 variable_manager=variable_manager,
                 loader=loader,
             )
-            task_list.append(t)
+            task_list.append(task)
         else:
             args_parser = ModuleArgsParser(task_ds)
             try:
                 (action, args, delegate_to) = args_parser.parse(skip_action_validation=True)
-            except AnsibleParserError as e:
+            except AnsibleParserError as ex:
                 # if the raises exception was created with obj=ds args, then it includes the detail
                 # so we dont need to add it so we can just re raise.
-                if e.obj:
+                if ex.obj:
                     raise
                 # But if it wasn't, we can add the yaml object now to get more detail
-                raise AnsibleParserError(to_native(e), obj=task_ds, orig_exc=e)
+                # DTFIX-FUTURE: this *should* be unnecessary- check code coverage.
+                #  Will definitely be unnecessary once we have proper contexts to consult.
+                raise AnsibleParserError("Error loading tasks.", obj=task_ds) from ex
 
             if action in C._ACTION_ALL_INCLUDE_IMPORT_TASKS:
 
@@ -135,7 +136,7 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
                 else:
                     include_class = TaskInclude
 
-                t = include_class.load(
+                task = include_class.load(
                     task_ds,
                     block=block,
                     role=role,
@@ -144,16 +145,16 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
                     loader=loader
                 )
 
-                all_vars = variable_manager.get_vars(play=play, task=t)
-                templar = Templar(loader=loader, variables=all_vars)
+                all_vars = variable_manager.get_vars(play=play, task=task)
+                templar = TemplateEngine(loader=loader, variables=all_vars)
 
                 # check to see if this include is dynamic or static:
                 if action in C._ACTION_IMPORT_TASKS:
-                    if t.loop is not None:
+                    if task.loop is not None:
                         raise AnsibleParserError("You cannot use loops on 'import_tasks' statements. You should use 'include_tasks' instead.", obj=task_ds)
 
                     # we set a flag to indicate this include was static
-                    t.statically_loaded = True
+                    task.statically_loaded = True
 
                     # handle relative includes by walking up the list of parent include
                     # tasks and checking the relative result to see if it exists
@@ -168,26 +169,14 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
                         if not isinstance(parent_include, TaskInclude):
                             parent_include = parent_include._parent
                             continue
-                        try:
-                            parent_include_dir = os.path.dirname(templar.template(parent_include.args.get('_raw_params')))
-                        except AnsibleUndefinedVariable as e:
-                            if not parent_include.statically_loaded:
-                                raise AnsibleParserError(
-                                    "Error when evaluating variable in dynamic parent include path: %s. "
-                                    "When using static imports, the parent dynamic include cannot utilize host facts "
-                                    "or variables from inventory" % parent_include.args.get('_raw_params'),
-                                    obj=task_ds,
-                                    suppress_extended_error=True,
-                                    orig_exc=e
-                                )
-                            raise
+                        parent_include_dir = os.path.dirname(parent_include.args.get('_raw_params'))
                         if cumulative_path is None:
                             cumulative_path = parent_include_dir
                         elif not os.path.isabs(cumulative_path):
                             cumulative_path = os.path.join(parent_include_dir, cumulative_path)
-                        include_target = templar.template(t.args['_raw_params'])
-                        if t._role:
-                            new_basedir = os.path.join(t._role._role_path, subdir, cumulative_path)
+                        include_target = templar.template(task.args['_raw_params'])
+                        if task._role:
+                            new_basedir = os.path.join(task._role._role_path, subdir, cumulative_path)
                             include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
                         else:
                             include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)
@@ -200,22 +189,21 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
 
                     if not found:
                         try:
-                            include_target = templar.template(t.args['_raw_params'])
-                        except AnsibleUndefinedVariable as e:
+                            include_target = templar.template(task.args['_raw_params'])
+                        except AnsibleUndefinedVariable as ex:
                             raise AnsibleParserError(
-                                "Error when evaluating variable in import path: %s.\n\n"
-                                "When using static imports, ensure that any variables used in their names are defined in vars/vars_files\n"
+                                message=f"Error when evaluating variable in import path {task.args['_raw_params']!r}.",
+                                help_text="When using static imports, ensure that any variables used in their names are defined in vars/vars_files\n"
                                 "or extra-vars passed in from the command line. Static imports cannot use variables from facts or inventory\n"
-                                "sources like group or host vars." % t.args['_raw_params'],
+                                "sources like group or host vars.",
                                 obj=task_ds,
-                                suppress_extended_error=True,
-                                orig_exc=e)
-                        if t._role:
-                            include_file = loader.path_dwim_relative(t._role._role_path, subdir, include_target)
+                            ) from ex
+                        if task._role:
+                            include_file = loader.path_dwim_relative(task._role._role_path, subdir, include_target)
                         else:
                             include_file = loader.path_dwim(include_target)
 
-                    data = loader.load_from_file(include_file)
+                    data = loader.load_from_file(include_file, trusted_as_template=True)
                     if not data:
                         display.warning('file %s is empty and had no tasks to include' % include_file)
                         continue
@@ -228,7 +216,7 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
                     # nested includes, and we want the include order printed correctly
                     display.vv("statically imported: %s" % include_file)
 
-                    ti_copy = t.copy(exclude_parent=True)
+                    ti_copy = task.copy(exclude_parent=True)
                     ti_copy._parent = block
                     included_blocks = load_list_of_blocks(
                         data,
@@ -246,7 +234,7 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
                     # now we extend the tags on each of the included blocks
                     for b in included_blocks:
                         b.tags = list(set(b.tags).union(tags))
-                    # END FIXME
+                    # FIXME - END
 
                     # FIXME: handlers shouldn't need this special handling, but do
                     #        right now because they don't iterate blocks correctly
@@ -256,7 +244,7 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
                     else:
                         task_list.extend(included_blocks)
                 else:
-                    task_list.append(t)
+                    task_list.append(task)
 
             elif action in C._ACTION_ALL_PROPER_INCLUDE_IMPORT_ROLES:
                 if use_handlers:
@@ -280,7 +268,7 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
 
                     # template the role name now, if needed
                     all_vars = variable_manager.get_vars(play=play, task=ir)
-                    templar = Templar(loader=loader, variables=all_vars)
+                    templar = TemplateEngine(loader=loader, variables=all_vars)
                     ir.post_validate(templar=templar)
                     ir._role_name = templar.template(ir._role_name)
 
@@ -292,15 +280,15 @@ def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_h
                     task_list.append(ir)
             else:
                 if use_handlers:
-                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
-                    if t.action in C._ACTION_META and t.args.get('_raw_params') == "end_role":
-                        raise AnsibleParserError("Cannot execute 'end_role' from a handler")
+                    task = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
+                    if task._get_meta() == "end_role":
+                        raise AnsibleParserError("Cannot execute 'end_role' from a handler", obj=task)
                 else:
-                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
-                    if t.action in C._ACTION_META and t.args.get('_raw_params') == "end_role" and role is None:
-                        raise AnsibleParserError("Cannot execute 'end_role' from outside of a role")
+                    task = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
+                    if task._get_meta() == "end_role" and role is None:
+                        raise AnsibleParserError("Cannot execute 'end_role' from outside of a role", obj=task)
 
-                task_list.append(t)
+                task_list.append(task)
 
     return task_list