ansible-core 2.17.4__py3-none-any.whl → 2.18.0b1__py3-none-any.whl

ansible/utils/collection_loader/_collection_finder.py

@@ -9,17 +9,14 @@ from __future__ import annotations
 import itertools
 import os
 import os.path
-import pkgutil
 import re
 import sys
 from keyword import iskeyword
-from tokenize import Name as _VALID_IDENTIFIER_REGEX
 
 
 # DO NOT add new non-stdlib import deps here, this loader is used by external tools (eg ansible-test import sanity)
 # that only allow stdlib and module_utils
 from ansible.module_utils.common.text.converters import to_native, to_text, to_bytes
-from ansible.module_utils.six import string_types, PY3
 from ._collection_config import AnsibleCollectionConfig
 
 from contextlib import contextmanager
@@ -32,11 +29,7 @@ except ImportError:
         __import__(name)
         return sys.modules[name]
 
-try:
-    from importlib import reload as reload_module
-except ImportError:
-    # 2.7 has a global reload function instead...
-    reload_module = reload  # type: ignore[name-defined]  # pylint:disable=undefined-variable
+from importlib import reload as reload_module
 
 try:
     try:
@@ -77,26 +70,7 @@ try:
 except ImportError:
     _meta_yml_to_dict = None
 
-
-if not hasattr(__builtins__, 'ModuleNotFoundError'):
-    # this was introduced in Python 3.6
-    ModuleNotFoundError = ImportError
-
-
-_VALID_IDENTIFIER_STRING_REGEX = re.compile(
-    ''.join((_VALID_IDENTIFIER_REGEX, r'\Z')),
-)
-
-
-try:  # NOTE: py3/py2 compat
-    # py2 mypy can't deal with try/excepts
-    is_python_identifier = str.isidentifier  # type: ignore[attr-defined]
-except AttributeError:  # Python 2
-    def is_python_identifier(self):  # type: (str) -> bool
-        """Determine whether the given string is a Python identifier."""
-        # Ref: https://stackoverflow.com/a/55802320/595220
-        return bool(re.match(_VALID_IDENTIFIER_STRING_REGEX, self))
-
+is_python_identifier = str.isidentifier  # type: ignore[attr-defined]
 
 PB_EXTENSIONS = ('.yml', '.yaml')
 SYNTHETIC_PACKAGE_NAME = '<ansible_synthetic_collection_package>'
@@ -219,7 +193,7 @@ class _AnsibleTraversableResources(TraversableResources):
         parts = package.split('.')
         is_ns = parts[0] == 'ansible_collections' and len(parts) < 3
 
-        if isinstance(package, string_types):
+        if isinstance(package, str):
             if is_ns:
                 # Don't use ``spec_from_loader`` here, because that will point
                 # to exactly 1 location for a namespace. Use ``find_spec``
@@ -241,7 +215,7 @@ class _AnsibleCollectionFinder:
         # TODO: accept metadata loader override
         self._ansible_pkg_path = to_native(os.path.dirname(to_bytes(sys.modules['ansible'].__file__)))
 
-        if isinstance(paths, string_types):
+        if isinstance(paths, str):
             paths = [paths]
         elif paths is None:
             paths = []
@@ -326,7 +300,7 @@ class _AnsibleCollectionFinder:
         return paths
 
     def set_playbook_paths(self, playbook_paths):
-        if isinstance(playbook_paths, string_types):
+        if isinstance(playbook_paths, str):
             playbook_paths = [playbook_paths]
 
         # track visited paths; we have to preserve the dir order as-passed in case there are duplicate collections (first one wins)
@@ -412,19 +386,17 @@ class _AnsiblePathHookFinder:
         # when called from a path_hook, find_module doesn't usually get the path arg, so this provides our context
         self._pathctx = to_native(pathctx)
         self._collection_finder = collection_finder
-        if PY3:
-            # cache the native FileFinder (take advantage of its filesystem cache for future find/load requests)
-            self._file_finder = None
+        # cache the native FileFinder (take advantage of its filesystem cache for future find/load requests)
+        self._file_finder = None
 
     # class init is fun- this method has a self arg that won't get used
     def _get_filefinder_path_hook(self=None):
         _file_finder_hook = None
-        if PY3:
-            # try to find the FileFinder hook to call for fallback path-based imports in Py3
-            _file_finder_hook = [ph for ph in sys.path_hooks if 'FileFinder' in repr(ph)]
-            if len(_file_finder_hook) != 1:
-                raise Exception('need exactly one FileFinder import hook (found {0})'.format(len(_file_finder_hook)))
-            _file_finder_hook = _file_finder_hook[0]
+        # try to find the FileFinder hook to call for fallback path-based imports in Py3
+        _file_finder_hook = [ph for ph in sys.path_hooks if 'FileFinder' in repr(ph)]
+        if len(_file_finder_hook) != 1:
+            raise Exception('need exactly one FileFinder import hook (found {0})'.format(len(_file_finder_hook)))
+        _file_finder_hook = _file_finder_hook[0]
 
         return _file_finder_hook
 
@@ -445,20 +417,16 @@ class _AnsiblePathHookFinder:
             # out what we *shouldn't* be loading with the limited info it has. So we'll just delegate to the
             # normal path-based loader as best we can to service it. This also allows us to take advantage of Python's
             # built-in FS caching and byte-compilation for most things.
-            if PY3:
-                # create or consult our cached file finder for this path
-                if not self._file_finder:
-                    try:
-                        self._file_finder = _AnsiblePathHookFinder._filefinder_path_hook(self._pathctx)
-                    except ImportError:
-                        # FUTURE: log at a high logging level? This is normal for things like python36.zip on the path, but
-                        # might not be in some other situation...
-                        return None
-
-                return self._file_finder
+            # create or consult our cached file finder for this path
+            if not self._file_finder:
+                try:
+                    self._file_finder = _AnsiblePathHookFinder._filefinder_path_hook(self._pathctx)
+                except ImportError:
+                    # FUTURE: log at a high logging level? This is normal for things like python36.zip on the path, but
+                    # might not be in some other situation...
+                    return None
 
-            # call py2's internal loader
-            return pkgutil.ImpImporter(self._pathctx)
+            return self._file_finder
 
     def find_module(self, fullname, path=None):
         # we ignore the passed in path here- use what we got from the path hook init
@@ -1124,7 +1092,7 @@ class AnsibleCollectionRef:
 
 def _get_collection_path(collection_name):
     collection_name = to_native(collection_name)
-    if not collection_name or not isinstance(collection_name, string_types) or len(collection_name.split('.')) != 2:
+    if not collection_name or not isinstance(collection_name, str) or len(collection_name.split('.')) != 2:
         raise ValueError('collection_name must be a non-empty string of the form namespace.collection')
     try:
         collection_pkg = import_module('ansible_collections.' + collection_name)
@@ -1307,7 +1275,7 @@ def _iter_modules_impl(paths, prefix=''):
 
 def _get_collection_metadata(collection_name):
     collection_name = to_native(collection_name)
-    if not collection_name or not isinstance(collection_name, string_types) or len(collection_name.split('.')) != 2:
+    if not collection_name or not isinstance(collection_name, str) or len(collection_name.split('.')) != 2:
         raise ValueError('collection_name must be a non-empty string of the form namespace.collection')
 
     try:

ansible/utils/display.py

@@ -33,7 +33,7 @@ import getpass
 import io
 import logging
 import os
-import random
+import secrets
 import subprocess
 import sys
 import termios
@@ -154,27 +154,31 @@ logger = None
 if getattr(C, 'DEFAULT_LOG_PATH'):
     path = C.DEFAULT_LOG_PATH
     if path and (os.path.exists(path) and os.access(path, os.W_OK)) or os.access(os.path.dirname(path), os.W_OK):
-        # NOTE: level is kept at INFO to avoid security disclosures caused by certain libraries when using DEBUG
-        logging.basicConfig(filename=path, level=logging.INFO,  # DO NOT set to logging.DEBUG
-                            format='%(asctime)s p=%(process)d u=%(user)s n=%(name)s | %(message)s')
-
-        logger = logging.getLogger('ansible')
-        for handler in logging.root.handlers:
-            handler.addFilter(FilterBlackList(getattr(C, 'DEFAULT_LOG_FILTER', [])))
-            handler.addFilter(FilterUserInjector())
+        if not os.path.isdir(path):
+            # NOTE: level is kept at INFO to avoid security disclosures caused by certain libraries when using DEBUG
+            logging.basicConfig(filename=path, level=logging.INFO,  # DO NOT set to logging.DEBUG
+                                format='%(asctime)s p=%(process)d u=%(user)s n=%(name)s %(levelname)s| %(message)s')
+
+            logger = logging.getLogger('ansible')
+            for handler in logging.root.handlers:
+                handler.addFilter(FilterBlackList(getattr(C, 'DEFAULT_LOG_FILTER', [])))
+                handler.addFilter(FilterUserInjector())
+        else:
+            print(f"[WARNING]: DEFAULT_LOG_PATH can not be a directory '{path}', aborting", file=sys.stderr)
     else:
-        print("[WARNING]: log file at %s is not writeable and we cannot create it, aborting\n" % path, file=sys.stderr)
+        print(f"[WARNING]: log file at '{path}' is not writeable and we cannot create it, aborting\n", file=sys.stderr)
 
-# map color to log levels
-color_to_log_level = {C.COLOR_ERROR: logging.ERROR,
-                      C.COLOR_WARN: logging.WARNING,
+# map color to log levels, in order of priority (low to high)
+color_to_log_level = {C.COLOR_DEBUG: logging.DEBUG,
+                      C.COLOR_VERBOSE: logging.INFO,
                       C.COLOR_OK: logging.INFO,
-                      C.COLOR_SKIP: logging.WARNING,
-                      C.COLOR_UNREACHABLE: logging.ERROR,
-                      C.COLOR_DEBUG: logging.DEBUG,
+                      C.COLOR_INCLUDED: logging.INFO,
                       C.COLOR_CHANGED: logging.INFO,
+                      C.COLOR_SKIP: logging.WARNING,
                       C.COLOR_DEPRECATE: logging.WARNING,
-                      C.COLOR_VERBOSE: logging.INFO}
+                      C.COLOR_WARN: logging.WARNING,
+                      C.COLOR_UNREACHABLE: logging.ERROR,
+                      C.COLOR_ERROR: logging.ERROR}
 
 b_COW_PATHS = (
     b"/usr/bin/cowsay",
@@ -310,8 +314,8 @@ class Display(metaclass=Singleton):
 
         codecs.register_error('_replacing_warning_handler', self._replacing_warning_handler)
         try:
-            sys.stdout.reconfigure(errors='_replacing_warning_handler')
-            sys.stderr.reconfigure(errors='_replacing_warning_handler')
+            sys.stdout.reconfigure(errors='_replacing_warning_handler')  # type: ignore[union-attr]
+            sys.stderr.reconfigure(errors='_replacing_warning_handler')  # type: ignore[union-attr]
         except Exception as ex:
             self.warning(f"failed to reconfigure stdout/stderr with custom encoding error handler: {ex}")
 
@@ -398,6 +402,7 @@ class Display(metaclass=Singleton):
         screen_only: bool = False,
         log_only: bool = False,
         newline: bool = True,
+        caplevel: int | None = None,
     ) -> None:
         """ Display a message to the user
 
@@ -424,7 +429,7 @@ class Display(metaclass=Singleton):
                 msg2 = msg2 + u'\n'
 
             # Note: After Display() class is refactored need to update the log capture
-            # code in 'bin/ansible-connection' (and other relevant places).
+            # code in 'cli/scripts/ansible_connection_cli_stub.py' (and other relevant places).
             if not stderr:
                 fileobj = sys.stdout
             else:
@@ -447,20 +452,28 @@ class Display(metaclass=Singleton):
             #         raise
 
         if logger and not screen_only:
-            self._log(nocolor, color)
+            self._log(nocolor, color, caplevel)
 
     def _log(self, msg: str, color: str | None = None, caplevel: int | None = None):
 
         if logger and (caplevel is None or self.log_verbosity > caplevel):
             msg2 = msg.lstrip('\n')
 
-            lvl = logging.INFO
-            if color:
+            if caplevel is None or caplevel > 0:
+                lvl = logging.INFO
+            elif caplevel == -1:
+                lvl = logging.ERROR
+            elif caplevel == -2:
+                lvl = logging.WARNING
+            elif caplevel == -3:
+                lvl = logging.DEBUG
+            elif color:
                 # set logger level based on color (not great)
+                # but last resort and backwards compatible
                 try:
                     lvl = color_to_log_level[color]
                 except KeyError:
-                    # this should not happen, but JIC
+                    # this should not happen if mapping is updated with new color configs, but JIC
                     raise AnsibleAssertionError('Invalid color supplied to display: %s' % color)
 
             # actually log
@@ -509,10 +522,10 @@ class Display(metaclass=Singleton):
     @_meets_debug
     @_proxy
     def debug(self, msg: str, host: str | None = None) -> None:
-        if host is None:
-            self.display("%6d %0.5f: %s" % (os.getpid(), time.time(), msg), color=C.COLOR_DEBUG)
-        else:
-            self.display("%6d %0.5f [%s]: %s" % (os.getpid(), time.time(), host, msg), color=C.COLOR_DEBUG)
+        prefix = "%6d %0.5f" % (os.getpid(), time.time())
+        if host is not None:
+            prefix += f" [{host}]"
+        self.display(f"{prefix}: {msg}", color=C.COLOR_DEBUG, caplevel=-3)
 
     def get_deprecation_message(
         self,
@@ -591,7 +604,7 @@ class Display(metaclass=Singleton):
             new_msg = "\n[WARNING]: \n%s" % msg
 
         if new_msg not in self._warns:
-            self.display(new_msg, color=C.COLOR_WARN, stderr=True)
+            self.display(new_msg, color=C.COLOR_WARN, stderr=True, caplevel=-2)
             self._warns[new_msg] = 1
 
     @_proxy
@@ -633,7 +646,7 @@ class Display(metaclass=Singleton):
         if self.noncow:
             thecow = self.noncow
             if thecow == 'random':
-                thecow = random.choice(list(self.cows_available))
+                thecow = secrets.choice(list(self.cows_available))
             runcmd.append(b'-f')
             runcmd.append(to_bytes(thecow))
         runcmd.append(to_bytes(msg))
@@ -650,7 +663,7 @@ class Display(metaclass=Singleton):
         else:
             new_msg = u"ERROR! %s" % msg
         if new_msg not in self._errors:
-            self.display(new_msg, color=C.COLOR_ERROR, stderr=True)
+            self.display(new_msg, color=C.COLOR_ERROR, stderr=True, caplevel=-1)
             self._errors[new_msg] = 1
 
     @staticmethod

ansible/utils/jsonrpc.py

@@ -83,7 +83,7 @@ class JsonRpcServer(object):
             result = to_text(result)
         if not isinstance(result, text_type):
             response["result_type"] = "pickle"
-            result = to_text(pickle.dumps(result, protocol=0))
+            result = to_text(pickle.dumps(result), errors='surrogateescape')
         response['result'] = result
         return response
 

ansible/utils/listify.py

@@ -27,11 +27,7 @@ display = Display()
 __all__ = ['listify_lookup_plugin_terms']
 
 
-def listify_lookup_plugin_terms(terms, templar, loader=None, fail_on_undefined=True, convert_bare=False):
-
-    if loader is not None:
-        display.deprecated('"listify_lookup_plugin_terms" does not use "dataloader" anymore, the ability to pass it in will be removed in future versions.',
-                           version='2.18')
+def listify_lookup_plugin_terms(terms, templar, fail_on_undefined=True, convert_bare=False):
 
     if isinstance(terms, string_types):
         terms = templar.template(terms.strip(), convert_bare=convert_bare, fail_on_undefined=fail_on_undefined)

ansible/utils/path.py

@@ -33,6 +33,9 @@ def unfrackpath(path, follow=True, basedir=None):
 
     :arg path: A byte or text string representing a path to be canonicalized
     :arg follow: A boolean to indicate of symlinks should be resolved or not
+    :arg basedir: A byte string, text string, PathLike object, or `None`
+        representing where a relative path should be resolved from.
+        `None` will be substituted for the current working directory.
     :raises UnicodeDecodeError: If the canonicalized version of the path
         contains non-utf8 byte sequences.
     :rtype: A text string (unicode on pyyhon2, str on python3).

ansible/utils/vars.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 
 import keyword
-import random
+import secrets
 import uuid
 
 from collections.abc import MutableMapping, MutableSequence
@@ -32,12 +32,10 @@ from ansible.module_utils.common.text.converters import to_native, to_text
 from ansible.parsing.splitter import parse_kv
 
 
-ADDITIONAL_PY2_KEYWORDS = frozenset(("True", "False", "None"))
-
 _MAXSIZE = 2 ** 32
 cur_id = 0
 node_mac = ("%012x" % uuid.getnode())[:12]
-random_int = ("%08x" % random.randint(0, _MAXSIZE))[:8]
+random_int = ("%08x" % secrets.randbelow(_MAXSIZE))[:8]
 
 
 def get_unique_id():
@@ -237,7 +235,22 @@ def load_options_vars(version):
     return load_options_vars.options_vars
 
 
-def _isidentifier_PY3(ident):
+def isidentifier(ident):
+    """Determine if string is valid identifier.
+
+    The purpose of this function is to be used to validate any variables created in
+    a play to be valid Python identifiers and to not conflict with Python keywords
+    to prevent unexpected behavior. Since Python 2 and Python 3 differ in what
+    a valid identifier is, this function unifies the validation so playbooks are
+    portable between the two. The following changes were made:
+
+        * disallow non-ascii characters (Python 3 allows for them as opposed to Python 2)
+
+    :arg ident: A text string of identifier to check. Note: It is callers
+        responsibility to convert ident to text if it is not already.
+
+    Originally posted at https://stackoverflow.com/a/29586366
+    """
     if not isinstance(ident, string_types):
         return False
 
@@ -251,25 +264,3 @@ def _isidentifier_PY3(ident):
         return False
 
     return True
-
-
-isidentifier = _isidentifier_PY3
-
-
-isidentifier.__doc__ = """Determine if string is valid identifier.
-
-The purpose of this function is to be used to validate any variables created in
-a play to be valid Python identifiers and to not conflict with Python keywords
-to prevent unexpected behavior. Since Python 2 and Python 3 differ in what
-a valid identifier is, this function unifies the validation so playbooks are
-portable between the two. The following changes were made:
-
-    * disallow non-ascii characters (Python 3 allows for them as opposed to Python 2)
-    * True, False and None are reserved keywords (these are reserved keywords
-      on Python 3 as opposed to Python 2)
-
-:arg ident: A text string of identifier to check. Note: It is callers
-    responsibility to convert ident to text if it is not already.
-
-Originally posted at http://stackoverflow.com/a/29586366
-"""

ansible/vars/manager.py

@@ -27,16 +27,14 @@ from hashlib import sha1
 from jinja2.exceptions import UndefinedError
 
 from ansible import constants as C
-from ansible.errors import AnsibleError, AnsibleParserError, AnsibleUndefinedVariable, AnsibleFileNotFound, AnsibleAssertionError, AnsibleTemplateError
+from ansible.errors import AnsibleError, AnsibleParserError, AnsibleUndefinedVariable, AnsibleFileNotFound, AnsibleAssertionError
 from ansible.inventory.host import Host
 from ansible.inventory.helpers import sort_groups, get_group_vars
 from ansible.module_utils.common.text.converters import to_text
-from ansible.module_utils.six import text_type, string_types
-from ansible.plugins.loader import lookup_loader
+from ansible.module_utils.six import text_type
 from ansible.vars.fact_cache import FactCache
 from ansible.template import Templar
 from ansible.utils.display import Display
-from ansible.utils.listify import listify_lookup_plugin_terms
 from ansible.utils.vars import combine_vars, load_extra_vars, load_options_vars
 from ansible.utils.unsafe_proxy import wrap_var
 from ansible.vars.clean import namespace_facts, clean_facts
@@ -161,6 +159,11 @@ class VariableManager:
         on the functionality they provide. These arguments may be removed at a later date without a deprecation
         period and without warning.
         '''
+        if include_delegate_to:
+            display.deprecated(
+                "`VariableManager.get_vars`'s argument `include_delegate_to` has no longer any effect.",
+                version="2.19",
+            )
 
         display.debug("in VariableManager get_vars()")
 
@@ -363,11 +366,6 @@ class VariableManager:
                                 continue
                             except AnsibleParserError:
                                 raise
-                        else:
-                            # if include_delegate_to is set to False or we don't have a host, we ignore the missing
-                            # vars file here because we're working on a delegated host or require host vars, see NOTE above
-                            if include_delegate_to and host:
-                                raise AnsibleFileNotFound("vars file %s was not found" % vars_file_item)
                     except (UndefinedError, AnsibleUndefinedVariable):
                         if host is not None and self._fact_cache.get(host.name, dict()).get('module_setup') and task is not None:
                             raise AnsibleUndefinedVariable("an undefined variable was found when attempting to template the vars_files item '%s'"
@@ -430,11 +428,6 @@ class VariableManager:
             # has to be copy, otherwise recursive ref
             all_vars['vars'] = all_vars.copy()
 
-        # if we have a host and task and we're delegating to another host,
-        # figure out the variables for that host now so we don't have to rely on host vars later
-        if task and host and task.delegate_to is not None and include_delegate_to:
-            all_vars['ansible_delegated_vars'], all_vars['_ansible_loop_cache'] = self._get_delegated_vars(play, task, all_vars)
-
         display.debug("done with get_vars()")
         if C.DEFAULT_DEBUG:
             # Use VarsWithSources wrapper class to display var sources
@@ -546,7 +539,6 @@ class VariableManager:
                         play=task.get_play(),
                         host=delegated_host,
                         task=task,
-                        include_delegate_to=False,
                         include_hostvars=True,
                     )
                 }
@@ -554,141 +546,6 @@ class VariableManager:
 
         return delegated_vars, delegated_host_name
 
-    def _get_delegated_vars(self, play, task, existing_variables):
-        # This method has a lot of code copied from ``TaskExecutor._get_loop_items``
-        # if this is failing, and ``TaskExecutor._get_loop_items`` is not
-        # then more will have to be copied here.
-        # TODO: dedupe code here and with ``TaskExecutor._get_loop_items``
-        #       this may be possible once we move pre-processing pre fork
-
-        if not hasattr(task, 'loop'):
-            # This "task" is not a Task, so we need to skip it
-            return {}, None
-
-        display.deprecated(
-            'Getting delegated variables via get_vars is no longer used, and is handled within the TaskExecutor.',
-            version='2.18',
-        )
-
-        # we unfortunately need to template the delegate_to field here,
-        # as we're fetching vars before post_validate has been called on
-        # the task that has been passed in
-        vars_copy = existing_variables.copy()
-
-        # get search path for this task to pass to lookup plugins
-        vars_copy['ansible_search_path'] = task.get_search_path()
-
-        # ensure basedir is always in (dwim already searches here but we need to display it)
-        if self._loader.get_basedir() not in vars_copy['ansible_search_path']:
-            vars_copy['ansible_search_path'].append(self._loader.get_basedir())
-
-        templar = Templar(loader=self._loader, variables=vars_copy)
-
-        items = []
-        has_loop = True
-        if task.loop_with is not None:
-            if task.loop_with in lookup_loader:
-                fail = True
-                if task.loop_with == 'first_found':
-                    # first_found loops are special. If the item is undefined then we want to fall through to the next
-                    fail = False
-                try:
-                    loop_terms = listify_lookup_plugin_terms(terms=task.loop, templar=templar, fail_on_undefined=fail, convert_bare=False)
-
-                    if not fail:
-                        loop_terms = [t for t in loop_terms if not templar.is_template(t)]
-
-                    mylookup = lookup_loader.get(task.loop_with, loader=self._loader, templar=templar)
-
-                    # give lookup task 'context' for subdir (mostly needed for first_found)
-                    for subdir in ['template', 'var', 'file']:  # TODO: move this to constants?
-                        if subdir in task.action:
-                            break
-                    setattr(mylookup, '_subdir', subdir + 's')
-
-                    items = wrap_var(mylookup.run(terms=loop_terms, variables=vars_copy))
-
-                except AnsibleTemplateError:
-                    # This task will be skipped later due to this, so we just setup
-                    # a dummy array for the later code so it doesn't fail
-                    items = [None]
-            else:
-                raise AnsibleError("Failed to find the lookup named '%s' in the available lookup plugins" % task.loop_with)
-        elif task.loop is not None:
-            try:
-                items = templar.template(task.loop)
-            except AnsibleTemplateError:
-                # This task will be skipped later due to this, so we just setup
-                # a dummy array for the later code so it doesn't fail
-                items = [None]
-        else:
-            has_loop = False
-            items = [None]
-
-        # since host can change per loop, we keep dict per host name resolved
-        delegated_host_vars = dict()
-        item_var = getattr(task.loop_control, 'loop_var', 'item')
-        cache_items = False
-        for item in items:
-            # update the variables with the item value for templating, in case we need it
-            if item is not None:
-                vars_copy[item_var] = item
-
-            templar.available_variables = vars_copy
-            delegated_host_name = templar.template(task.delegate_to, fail_on_undefined=False)
-            if delegated_host_name != task.delegate_to:
-                cache_items = True
-            if delegated_host_name is None:
-                raise AnsibleError(message="Undefined delegate_to host for task:", obj=task._ds)
-            if not isinstance(delegated_host_name, string_types):
-                raise AnsibleError(message="the field 'delegate_to' has an invalid type (%s), and could not be"
-                                           " converted to a string type." % type(delegated_host_name), obj=task._ds)
-
-            if delegated_host_name in delegated_host_vars:
-                # no need to repeat ourselves, as the delegate_to value
-                # does not appear to be tied to the loop item variable
-                continue
-
-            # now try to find the delegated-to host in inventory, or failing that,
-            # create a new host on the fly so we can fetch variables for it
-            delegated_host = None
-            if self._inventory is not None:
-                delegated_host = self._inventory.get_host(delegated_host_name)
-                # try looking it up based on the address field, and finally
-                # fall back to creating a host on the fly to use for the var lookup
-                if delegated_host is None:
-                    for h in self._inventory.get_hosts(ignore_limits=True, ignore_restrictions=True):
-                        # check if the address matches, or if both the delegated_to host
-                        # and the current host are in the list of localhost aliases
-                        if h.address == delegated_host_name:
-                            delegated_host = h
-                            break
-                    else:
-                        delegated_host = Host(name=delegated_host_name)
-            else:
-                delegated_host = Host(name=delegated_host_name)
-
-            # now we go fetch the vars for the delegated-to host and save them in our
-            # master dictionary of variables to be used later in the TaskExecutor/PlayContext
-            delegated_host_vars[delegated_host_name] = self.get_vars(
-                play=play,
-                host=delegated_host,
-                task=task,
-                include_delegate_to=False,
-                include_hostvars=True,
-            )
-            delegated_host_vars[delegated_host_name]['inventory_hostname'] = vars_copy.get('inventory_hostname')
-
-        _ansible_loop_cache = None
-        if has_loop and cache_items:
-            # delegate_to templating produced a change, so we will cache the templated items
-            # in a special private hostvar
-            # this ensures that delegate_to+loop doesn't produce different results than TaskExecutor
-            # which may reprocess the loop
-            _ansible_loop_cache = items
-
-        return delegated_host_vars, _ansible_loop_cache
-
     def clear_facts(self, hostname):
         '''
         Clears the facts for a host

ansible/vars/plugins.py

@@ -90,7 +90,7 @@ def get_vars_from_path(loader, path, entities, stage):
 
         collection = '.' in plugin.ansible_name and not plugin.ansible_name.startswith('ansible.builtin.')
         # Warn if a collection plugin has REQUIRES_ENABLED because it has no effect.
-        if collection and (hasattr(plugin, 'REQUIRES_ENABLED') or hasattr(plugin, 'REQUIRES_WHITELIST')):
+        if collection and hasattr(plugin, 'REQUIRES_ENABLED'):
             display.warning(
                 "Vars plugins in collections must be enabled to be loaded, REQUIRES_ENABLED is not supported. "
                 "This should be removed from the plugin %s." % plugin.ansible_name