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

ansible/executor/interpreter_discovery.py

@@ -3,25 +3,17 @@
 
 from __future__ import annotations
 
-import bisect
-import json
-import pkgutil
 import re
 
 from ansible import constants as C
 from ansible.errors import AnsibleError
-from ansible.module_utils.common.text.converters import to_native, to_text
-from ansible.module_utils.distro import LinuxDistribution
 from ansible.utils.display import Display
 from ansible.utils.plugin_docs import get_versioned_doclink
-from ansible.module_utils.compat.version import LooseVersion
-from ansible.module_utils.facts.system.distribution import Distribution
-from traceback import format_exc
 
-OS_FAMILY_LOWER = {k.lower(): v.lower() for k, v in Distribution.OS_FAMILY.items()}
+_FALLBACK_INTERPRETER = '/usr/bin/python3'
 
 display = Display()
-foundre = re.compile(r'(?s)PLATFORM[\r\n]+(.*)FOUND(.*)ENDFOUND')
+foundre = re.compile(r'FOUND(.*)ENDFOUND', flags=re.DOTALL)
 
 
 class InterpreterDiscoveryRequiredError(Exception):
@@ -30,42 +22,28 @@ class InterpreterDiscoveryRequiredError(Exception):
         self.interpreter_name = interpreter_name
         self.discovery_mode = discovery_mode
 
-    def __str__(self):
-        return self.message
-
-    def __repr__(self):
-        # TODO: proper repr impl
-        return self.message
-
 
 def discover_interpreter(action, interpreter_name, discovery_mode, task_vars):
-    # interpreter discovery is a 2-step process with the target. First, we use a simple shell-agnostic bootstrap to
-    # get the system type from uname, and find any random Python that can get us the info we need. For supported
-    # target OS types, we'll dispatch a Python script that calls platform.dist() (for older platforms, where available)
-    # and brings back /etc/os-release (if present). The proper Python path is looked up in a table of known
-    # distros/versions with included Pythons; if nothing is found, depending on the discovery mode, either the
-    # default fallback of /usr/bin/python is used (if we know it's there), or discovery fails.
-
-    # FUTURE: add logical equivalence for "python3" in the case of py3-only modules?
-    if interpreter_name != 'python':
-        raise ValueError('Interpreter discovery not supported for {0}'.format(interpreter_name))
-
+    """Probe the target host for a Python interpreter from the `INTERPRETER_PYTHON_FALLBACK` list, returning the first found or `/usr/bin/python3` if none."""
     host = task_vars.get('inventory_hostname', 'unknown')
     res = None
-    platform_type = 'unknown'
-    found_interpreters = [u'/usr/bin/python3']  # fallback value
-    is_auto_legacy = discovery_mode.startswith('auto_legacy')
+    found_interpreters = [_FALLBACK_INTERPRETER]  # fallback value
     is_silent = discovery_mode.endswith('_silent')
 
+    if discovery_mode.startswith('auto_legacy'):
+        display.deprecated(
+            msg=f"The '{discovery_mode}' option for 'INTERPRETER_PYTHON' now has the same effect as 'auto'.",
+            version='2.21',
+        )
+
     try:
-        platform_python_map = C.config.get_config_value('_INTERPRETER_PYTHON_DISTRO_MAP', variables=task_vars)
         bootstrap_python_list = C.config.get_config_value('INTERPRETER_PYTHON_FALLBACK', variables=task_vars)
 
-        display.vvv(msg=u"Attempting {0} interpreter discovery".format(interpreter_name), host=host)
+        display.vvv(msg=f"Attempting {interpreter_name} interpreter discovery.", host=host)
 
         # not all command -v impls accept a list of commands, so we have to call it once per python
         command_list = ["command -v '%s'" % py for py in bootstrap_python_list]
-        shell_bootstrap = "echo PLATFORM; uname; echo FOUND; {0}; echo ENDFOUND".format('; '.join(command_list))
+        shell_bootstrap = "echo FOUND; {0}; echo ENDFOUND".format('; '.join(command_list))
 
         # FUTURE: in most cases we probably don't want to use become, but maybe sometimes we do?
         res = action._low_level_execute_command(shell_bootstrap, sudoable=False)
@@ -78,131 +56,32 @@ def discover_interpreter(action, interpreter_name, discovery_mode, task_vars):
             display.debug(u'raw interpreter discovery output: {0}'.format(raw_stdout), host=host)
             raise ValueError('unexpected output from Python interpreter discovery')
 
-        platform_type = match.groups()[0].lower().strip()
-
-        found_interpreters = [interp.strip() for interp in match.groups()[1].splitlines() if interp.startswith('/')]
+        found_interpreters = [interp.strip() for interp in match.groups()[0].splitlines() if interp.startswith('/')]
 
         display.debug(u"found interpreters: {0}".format(found_interpreters), host=host)
 
         if not found_interpreters:
             if not is_silent:
-                action._discovery_warnings.append(u'No python interpreters found for '
-                                                  u'host {0} (tried {1})'.format(host, bootstrap_python_list))
-            # this is lame, but returning None or throwing an exception is uglier
-            return u'/usr/bin/python3'
-
-        if platform_type != 'linux':
-            raise NotImplementedError('unsupported platform for extended discovery: {0}'.format(to_native(platform_type)))
-
-        platform_script = pkgutil.get_data('ansible.executor.discovery', 'python_target.py')
-
-        # FUTURE: respect pipelining setting instead of just if the connection supports it?
-        if action._connection.has_pipelining:
-            res = action._low_level_execute_command(found_interpreters[0], sudoable=False, in_data=platform_script)
-        else:
-            # FUTURE: implement on-disk case (via script action or ?)
-            raise NotImplementedError('pipelining support required for extended interpreter discovery')
-
-        platform_info = json.loads(res.get('stdout'))
-
-        distro, version = _get_linux_distro(platform_info)
-        if not distro or not version:
-            raise NotImplementedError('unable to get Linux distribution/version info')
-
-        family = OS_FAMILY_LOWER.get(distro.lower().strip())
-
-        version_map = platform_python_map.get(distro.lower().strip()) or platform_python_map.get(family)
-        if not version_map:
-            raise NotImplementedError('unsupported Linux distribution: {0}'.format(distro))
-
-        platform_interpreter = to_text(_version_fuzzy_match(version, version_map), errors='surrogate_or_strict')
-
-        # provide a transition period for hosts that were using /usr/bin/python previously (but shouldn't have been)
-        if is_auto_legacy:
-            if platform_interpreter != u'/usr/bin/python3' and u'/usr/bin/python3' in found_interpreters:
-                if not is_silent:
-                    action._discovery_warnings.append(
-                        u"Distribution {0} {1} on host {2} should use {3}, but is using "
-                        u"/usr/bin/python3 for backward compatibility with prior Ansible releases. "
-                        u"See {4} for more information"
-                        .format(distro, version, host, platform_interpreter,
-                                get_versioned_doclink('reference_appendices/interpreter_discovery.html')))
-                return u'/usr/bin/python3'
-
-        if platform_interpreter not in found_interpreters:
-            if platform_interpreter not in bootstrap_python_list:
-                # sanity check to make sure we looked for it
-                if not is_silent:
-                    action._discovery_warnings \
-                        .append(u"Platform interpreter {0} on host {1} is missing from bootstrap list"
-                                .format(platform_interpreter, host))
+                display.warning(msg=f'No python interpreters found for host {host!r} (tried {bootstrap_python_list!r}).')
 
-            if not is_silent:
-                action._discovery_warnings \
-                    .append(u"Distribution {0} {1} on host {2} should use {3}, but is using {4}, since the "
-                            u"discovered platform python interpreter was not present. See {5} "
-                            u"for more information."
-                            .format(distro, version, host, platform_interpreter, found_interpreters[0],
-                                    get_versioned_doclink('reference_appendices/interpreter_discovery.html')))
-            return found_interpreters[0]
-
-        return platform_interpreter
-    except NotImplementedError as ex:
-        display.vvv(msg=u'Python interpreter discovery fallback ({0})'.format(to_text(ex)), host=host)
+            # this is lame, but returning None or throwing an exception is uglier
+            return _FALLBACK_INTERPRETER
     except AnsibleError:
         raise
     except Exception as ex:
         if not is_silent:
-            display.warning(msg=u'Unhandled error in Python interpreter discovery for host {0}: {1}'.format(host, to_text(ex)))
-            display.debug(msg=u'Interpreter discovery traceback:\n{0}'.format(to_text(format_exc())), host=host)
-            if res and res.get('stderr'):
-                display.vvv(msg=u'Interpreter discovery remote stderr:\n{0}'.format(to_text(res.get('stderr'))), host=host)
-
-    if not is_silent:
-        action._discovery_warnings \
-            .append(u"Platform {0} on host {1} is using the discovered Python interpreter at {2}, but future installation of "
-                    u"another Python interpreter could change the meaning of that path. See {3} "
-                    u"for more information."
-                    .format(platform_type, host, found_interpreters[0],
-                            get_versioned_doclink('reference_appendices/interpreter_discovery.html')))
-    return found_interpreters[0]
-
+            display.error_as_warning(msg=f'Unhandled error in Python interpreter discovery for host {host!r}.', exception=ex)
 
-def _get_linux_distro(platform_info):
-    dist_result = platform_info.get('platform_dist_result', [])
+            if res and res.get('stderr'):  # the current ssh plugin implementation always has stderr, making coverage of the false case difficult
+                display.vvv(msg=f"Interpreter discovery remote stderr:\n{res.get('stderr')}", host=host)
 
-    if len(dist_result) == 3 and any(dist_result):
-        return dist_result[0], dist_result[1]
-
-    osrelease_content = platform_info.get('osrelease_content')
-
-    if not osrelease_content:
-        return u'', u''
-
-    osr = LinuxDistribution._parse_os_release_content(osrelease_content)
-
-    return osr.get('id', u''), osr.get('version_id', u'')
-
-
-def _version_fuzzy_match(version, version_map):
-    # try exact match first
-    res = version_map.get(version)
-    if res:
-        return res
-
-    sorted_looseversions = sorted([LooseVersion(v) for v in version_map.keys()])
-
-    find_looseversion = LooseVersion(version)
-
-    # slot match; return nearest previous version we're newer than
-    kpos = bisect.bisect(sorted_looseversions, find_looseversion)
-
-    if kpos == 0:
-        # older than everything in the list, return the oldest version
-        # TODO: warning-worthy?
-        return version_map.get(sorted_looseversions[0].vstring)
-
-    # TODO: is "past the end of the list" warning-worthy too (at least if it's not a major version match)?
+    if not is_silent:
+        display.warning(
+            msg=(
+                f"Host {host!r} is using the discovered Python interpreter at {found_interpreters[0]!r}, "
+                "but future installation of another Python interpreter could cause a different interpreter to be discovered."
+            ),
+            help_text=f"See {get_versioned_doclink('reference_appendices/interpreter_discovery.html')} for more information.",
+        )
 
-    # return the next-oldest entry that we're newer than...
-    return version_map.get(sorted_looseversions[kpos - 1].vstring)
+    return found_interpreters[0]