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

ansible/galaxy/dependency_resolution/providers.py

@@ -39,7 +39,7 @@ except ImportError:
 
 # TODO: add python requirements to ansible-test's ansible-core distribution info and remove the hardcoded lowerbound/upperbound fallback
 RESOLVELIB_LOWERBOUND = SemanticVersion("0.5.3")
-RESOLVELIB_UPPERBOUND = SemanticVersion("1.1.0")
+RESOLVELIB_UPPERBOUND = SemanticVersion("2.0.0")
 RESOLVELIB_VERSION = SemanticVersion.from_loose_version(LooseVersion(resolvelib_version))
 
 
@@ -148,7 +148,7 @@ class CollectionDependencyProviderBase(AbstractProvider):
 
         :param resolutions: Mapping of identifier, candidate pairs.
 
-        :param candidates: Possible candidates for the identifer.
+        :param candidates: Possible candidates for the identifier.
             Mapping of identifier, list of candidate pairs.
 
         :param information: Requirement information of each package.
@@ -158,7 +158,7 @@ class CollectionDependencyProviderBase(AbstractProvider):
         :param backtrack_causes: Sequence of requirement information that were
             the requirements that caused the resolver to most recently backtrack.
 
-        The preference could depend on a various of issues, including
+        The preference could depend on various of issues, including
         (not necessarily in this order):
 
           * Is this package pinned in the current resolution result?
@@ -404,7 +404,7 @@ class CollectionDependencyProviderBase(AbstractProvider):
 
         :param requirement: A requirement that produced the `candidate`.
 
-        :param candidate: A pinned candidate supposedly matchine the \
+        :param candidate: A pinned candidate supposedly matching the \
                           `requirement` specifier. It is guaranteed to \
                           have been generated from the `requirement`.
 

ansible/galaxy/dependency_resolution/reporters.py

@@ -5,12 +5,46 @@
 
 from __future__ import annotations
 
+from collections import defaultdict
+
 try:
     from resolvelib import BaseReporter
 except ImportError:
     class BaseReporter:  # type: ignore[no-redef]
         pass
 
+try:
+    from resolvelib.resolvers import Criterion
+except ImportError:
+    class Criterion:  # type: ignore[no-redef]
+        pass
+
+from ansible.utils.display import Display
+from .dataclasses import Candidate, Requirement
+
+
+display = Display()
+
+
+_CLI_APP_NAME = 'ansible-galaxy'
+_MESSAGES_AT_REJECT_COUNT = {
+    1: (
+        f'{_CLI_APP_NAME} is looking at multiple versions of {{fqcn}} to '
+        'determine which version is compatible with other '
+        'requirements. This could take a while.'
+    ),
+    8: (
+        f'{_CLI_APP_NAME} is looking at multiple versions of {{fqcn}} to '
+        'determine which version is compatible with other '
+        'requirements. This could take a while.'
+    ),
+    13: (
+        'This is taking longer than usual. You might need to provide '
+        'the dependency resolver with stricter constraints to reduce '
+        'runtime. If you want to abort this run, press Ctrl + C.'
+    ),
+}
+
 
 class CollectionDependencyReporter(BaseReporter):
     """A dependency reporter for Ansible Collections.
@@ -18,3 +52,50 @@ class CollectionDependencyReporter(BaseReporter):
     This is a proxy class allowing us to abstract away importing resolvelib
     outside of the `ansible.galaxy.dependency_resolution` Python package.
     """
+
+    def __init__(self) -> None:
+        """Initialize the collection rejection counter."""
+        super().__init__()
+
+        self.reject_count_by_fqcn: defaultdict[str, int] = defaultdict(int)
+
+    def _maybe_log_rejection_message(self, candidate: Candidate) -> bool:
+        """Print out rejection messages on pre-defined limit hits."""
+        # Inspired by https://github.com/pypa/pip/commit/9731131
+        self.reject_count_by_fqcn[candidate.fqcn] += 1
+
+        collection_rejections_count = self.reject_count_by_fqcn[candidate.fqcn]
+
+        if collection_rejections_count not in _MESSAGES_AT_REJECT_COUNT:
+            return False
+
+        collection_rejection_message = _MESSAGES_AT_REJECT_COUNT[
+            collection_rejections_count
+        ]
+        display.display(collection_rejection_message.format(fqcn=candidate.fqcn))
+
+        return True
+
+    def rejecting_candidate(  # resolvelib >= 0.9.0
+            self,
+            criterion: Criterion[Candidate, Requirement],
+            candidate: Candidate,
+    ) -> None:
+        """Augment rejection messages with conflict details."""
+        if not self._maybe_log_rejection_message(candidate):
+            return
+
+        msg = 'Will try a different candidate, due to conflict:'
+        for req_info in criterion.information:
+            req, parent = req_info.requirement, req_info.parent
+            msg += '\n    '
+            if parent:
+                msg += f'{parent !s} depends on '
+            else:
+                msg += 'The user requested '
+            msg += str(req)
+        display.v(msg)
+
+    def backtracking(self, candidate: Candidate) -> None:  # resolvelib < 0.9.0
+        """Print out rejection messages on pre-defined limit hits."""
+        self._maybe_log_rejection_message(candidate)

ansible/galaxy/role.py

@@ -185,13 +185,11 @@ class GalaxyRole(object):
             info_path = os.path.join(self.path, self.META_INSTALL)
             if os.path.isfile(info_path):
                 try:
-                    f = open(info_path, 'r')
-                    self._install_info = yaml_load(f)
+                    with open(info_path, 'r') as f:
+                        self._install_info = yaml_load(f)
                 except Exception:
                     display.vvvvv("Unable to load Galaxy install info for %s" % self.name)
                     return False
-                finally:
-                    f.close()
         return self._install_info
 
     @property
@@ -440,8 +438,8 @@ class GalaxyRole(object):
                 if not (self.src and os.path.isfile(self.src)):
                     try:
                         os.unlink(tmp_file)
-                    except (OSError, IOError) as e:
-                        display.warning(u"Unable to remove tmp file (%s): %s" % (tmp_file, to_text(e)))
+                    except OSError as ex:
+                        display.error_as_warning(f"Unable to remove tmp file {tmp_file!r}.", exception=ex)
                 return True
 
         return False
@@ -470,12 +468,10 @@ class GalaxyRole(object):
                 meta_path = os.path.join(self.path, meta_requirements)
                 if os.path.isfile(meta_path):
                     try:
-                        f = open(meta_path, 'r')
-                        self._requirements = yaml_load(f)
+                        with open(meta_path, 'r') as f:
+                            self._requirements = yaml_load(f)
                     except Exception:
                         display.vvvvv("Unable to load requirements for %s" % self.name)
-                    finally:
-                        f.close()
 
                     break
 

ansible/galaxy/token.py

@@ -26,10 +26,12 @@ import os
 import time
 from stat import S_IRUSR, S_IWUSR
 from urllib.error import HTTPError
+from urllib.parse import urlencode
 
 from ansible import constants as C
 from ansible.galaxy.api import GalaxyError
 from ansible.galaxy.user_agent import user_agent
+from ansible.module_utils.common.sentinel import Sentinel as NoTokenSentinel
 from ansible.module_utils.common.text.converters import to_bytes, to_native, to_text
 from ansible.module_utils.common.yaml import yaml_dump, yaml_load
 from ansible.module_utils.urls import open_url
@@ -38,21 +40,15 @@ from ansible.utils.display import Display
 display = Display()
 
 
-class NoTokenSentinel(object):
-    """ Represents an ansible.cfg server with not token defined (will ignore cmdline and GALAXY_TOKEN_PATH. """
-    def __new__(cls, *args, **kwargs):
-        return cls
-
-
 class KeycloakToken(object):
-    '''A token granted by a Keycloak server.
+    """A token granted by a Keycloak server.
 
     Like sso.redhat.com as used by cloud.redhat.com
-    ie Automation Hub'''
+    ie Automation Hub"""
 
     token_type = 'Bearer'
 
-    def __init__(self, access_token=None, auth_url=None, validate_certs=True, client_id=None):
+    def __init__(self, access_token=None, auth_url=None, validate_certs=True, client_id=None, client_secret=None):
         self.access_token = access_token
         self.auth_url = auth_url
         self._token = None
@@ -60,11 +56,26 @@ class KeycloakToken(object):
         self.client_id = client_id
         if self.client_id is None:
             self.client_id = 'cloud-services'
+        self.client_secret = client_secret
         self._expiration = None
 
     def _form_payload(self):
-        return 'grant_type=refresh_token&client_id=%s&refresh_token=%s' % (self.client_id,
-                                                                           self.access_token)
+        payload = {
+            'client_id': self.client_id,
+        }
+        if self.client_secret:
+            payload['client_secret'] = self.client_secret
+            payload['scope'] = 'api.console'
+            payload['grant_type'] = 'client_credentials'
+            if self.access_token not in (None, NoTokenSentinel):
+                display.warning(
+                    'Found both a client_secret and access_token for galaxy authentication, ignoring access_token'
+                )
+        else:
+            payload['refresh_token'] = self.access_token
+            payload['grant_type'] = 'refresh_token'
+
+        return urlencode(payload)
 
     def get(self):
         if self._expiration and time.time() >= self._expiration:
@@ -73,16 +84,9 @@ class KeycloakToken(object):
         if self._token:
             return self._token
 
-        # - build a request to POST to auth_url
-        #  - body is form encoded
-        #    - 'refresh_token' is the offline token stored in ansible.cfg
-        #    - 'grant_type' is 'refresh_token'
-        #    - 'client_id' is 'cloud-services'
-        #       - should probably be based on the contents of the
-        #         offline_ticket's JWT payload 'aud' (audience)
-        #         or 'azp' (Authorized party - the party to which the ID Token was issued)
         payload = self._form_payload()
 
+        display.vvv(f'Authenticating via {self.auth_url}')
         try:
             resp = open_url(to_native(self.auth_url),
                             data=payload,
@@ -91,15 +95,18 @@ class KeycloakToken(object):
                             http_agent=user_agent())
         except HTTPError as e:
             raise GalaxyError(e, 'Unable to get access token')
+        display.vvv('Authentication successful')
 
         data = json.load(resp)
 
         # So that we have a buffer, expire the token in ~2/3 the given value
         expires_in = data['expires_in'] // 3 * 2
         self._expiration = time.time() + expires_in
+        display.vvv(f'Authentication token expires in {expires_in} seconds')
 
-        # - extract 'access_token'
         self._token = data.get('access_token')
+        if token_type := data.get('token_type'):
+            self.token_type = token_type
 
         return self._token
 
@@ -110,7 +117,7 @@ class KeycloakToken(object):
 
 
 class GalaxyToken(object):
-    ''' Class to storing and retrieving local galaxy token '''
+    """ Class to storing and retrieving local galaxy token """
 
     token_type = 'Token'
 

ansible/inventory/data.py

@@ -19,64 +19,49 @@
 from __future__ import annotations
 
 import sys
+import typing as t
 
 from ansible import constants as C
 from ansible.errors import AnsibleError
 from ansible.inventory.group import Group
 from ansible.inventory.host import Host
-from ansible.module_utils.six import string_types
 from ansible.utils.display import Display
 from ansible.utils.vars import combine_vars
 from ansible.utils.path import basedir
 
+from . import helpers  # this is left as a module import to facilitate easier unit test patching
+
+
 display = Display()
 
 
-class InventoryData(object):
+class InventoryData:
     """
     Holds inventory data (host and group objects).
-    Using it's methods should guarantee expected relationships and data.
+    Using its methods should guarantee expected relationships and data.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
 
-        self.groups = {}
-        self.hosts = {}
+        self.groups: dict[str, Group] = {}
+        self.hosts: dict[str, Host] = {}
 
         # provides 'groups' magic var, host object has group_names
-        self._groups_dict_cache = {}
+        self._groups_dict_cache: dict[str, list[str]] = {}
 
         # current localhost, implicit or explicit
-        self.localhost = None
+        self.localhost: Host | None = None
 
-        self.current_source = None
-        self.processed_sources = []
+        self.current_source: str | None = None
+        self.processed_sources: list[str] = []
 
         # Always create the 'all' and 'ungrouped' groups,
         for group in ('all', 'ungrouped'):
             self.add_group(group)
-        self.add_child('all', 'ungrouped')
 
-    def serialize(self):
-        self._groups_dict_cache = None
-        data = {
-            'groups': self.groups,
-            'hosts': self.hosts,
-            'local': self.localhost,
-            'source': self.current_source,
-            'processed_sources': self.processed_sources
-        }
-        return data
-
-    def deserialize(self, data):
-        self._groups_dict_cache = {}
-        self.hosts = data.get('hosts')
-        self.groups = data.get('groups')
-        self.localhost = data.get('local')
-        self.current_source = data.get('source')
-        self.processed_sources = data.get('processed_sources')
+        self.add_child('all', 'ungrouped')
 
-    def _create_implicit_localhost(self, pattern):
+    def _create_implicit_localhost(self, pattern: str) -> Host:
 
         if self.localhost:
             new_host = self.localhost
@@ -100,8 +85,8 @@ class InventoryData(object):
 
         return new_host
 
-    def reconcile_inventory(self):
-        ''' Ensure inventory basic rules, run after updates '''
+    def reconcile_inventory(self) -> None:
+        """Ensure inventory basic rules, run after updates."""
 
         display.debug('Reconcile groups and hosts in inventory.')
         self.current_source = None
@@ -125,7 +110,7 @@ class InventoryData(object):
 
             if self.groups['ungrouped'] in mygroups:
                 # clear ungrouped of any incorrectly stored by parser
-                if set(mygroups).difference(set([self.groups['all'], self.groups['ungrouped']])):
+                if set(mygroups).difference({self.groups['all'], self.groups['ungrouped']}):
                     self.groups['ungrouped'].remove_host(host)
 
             elif not host.implicit:
@@ -144,8 +129,10 @@ class InventoryData(object):
 
         self._groups_dict_cache = {}
 
-    def get_host(self, hostname):
-        ''' fetch host object using name deal with implicit localhost '''
+    def get_host(self, hostname: str) -> Host | None:
+        """Fetch host object using name deal with implicit localhost."""
+
+        hostname = helpers.remove_trust(hostname)
 
         matching_host = self.hosts.get(hostname, None)
 
@@ -156,19 +143,19 @@ class InventoryData(object):
 
         return matching_host
 
-    def add_group(self, group):
-        ''' adds a group to inventory if not there already, returns named actually used '''
+    def add_group(self, group: str) -> str:
+        """Adds a group to inventory if not there already, returns named actually used."""
 
         if group:
-            if not isinstance(group, string_types):
+            if not isinstance(group, str):
                 raise AnsibleError("Invalid group name supplied, expected a string but got %s for %s" % (type(group), group))
             if group not in self.groups:
                 g = Group(group)
-                if g.name not in self.groups:
-                    self.groups[g.name] = g
+                group = g.name  # the group object may have sanitized the group name; use whatever it has
+                if group not in self.groups:
+                    self.groups[group] = g
                     self._groups_dict_cache = {}
                     display.debug("Added group %s to inventory" % group)
-                group = g.name
             else:
                 display.debug("group %s already in inventory" % group)
         else:
@@ -176,22 +163,24 @@ class InventoryData(object):
 
         return group
 
-    def remove_group(self, group):
+    def remove_group(self, group: Group) -> None:
 
-        if group in self.groups:
-            del self.groups[group]
-            display.debug("Removed group %s from inventory" % group)
+        if group.name in self.groups:
+            del self.groups[group.name]
+            display.debug("Removed group %s from inventory" % group.name)
             self._groups_dict_cache = {}
 
         for host in self.hosts:
             h = self.hosts[host]
             h.remove_group(group)
 
-    def add_host(self, host, group=None, port=None):
-        ''' adds a host to inventory and possibly a group if not there already '''
+    def add_host(self, host: str, group: str | None = None, port: int | str | None = None) -> str:
+        """Adds a host to inventory and possibly a group if not there already."""
+
+        host = helpers.remove_trust(host)
 
         if host:
-            if not isinstance(host, string_types):
+            if not isinstance(host, str):
                 raise AnsibleError("Invalid host name supplied, expected a string but got %s for %s" % (type(host), host))
 
             # TODO: add to_safe_host_name
@@ -211,7 +200,7 @@ class InventoryData(object):
                 else:
                     self.set_variable(host, 'inventory_file', None)
                     self.set_variable(host, 'inventory_dir', None)
-                display.debug("Added host %s to inventory" % (host))
+                display.debug("Added host %s to inventory" % host)
 
                 # set default localhost from inventory to avoid creating an implicit one. Last localhost defined 'wins'.
                 if host in C.LOCALHOST:
@@ -232,7 +221,7 @@ class InventoryData(object):
 
         return host
 
-    def remove_host(self, host):
+    def remove_host(self, host: Host) -> None:
 
         if host.name in self.hosts:
             del self.hosts[host.name]
@@ -241,8 +230,10 @@ class InventoryData(object):
             g = self.groups[group]
             g.remove_host(host)
 
-    def set_variable(self, entity, varname, value):
-        ''' sets a variable for an inventory object '''
+    def set_variable(self, entity: str, varname: str, value: t.Any) -> None:
+        """Sets a variable for an inventory object."""
+
+        inv_object: Host | Group
 
         if entity in self.groups:
             inv_object = self.groups[entity]
@@ -254,9 +245,8 @@ class InventoryData(object):
         inv_object.set_variable(varname, value)
         display.debug('set %s for %s' % (varname, entity))
 
-    def add_child(self, group, child):
-        ''' Add host or group to group '''
-        added = False
+    def add_child(self, group: str, child: str) -> bool:
+        """Add host or group to group."""
         if group in self.groups:
             g = self.groups[group]
             if child in self.groups:
@@ -271,12 +261,12 @@ class InventoryData(object):
             raise AnsibleError("%s is not a known group" % group)
         return added
 
-    def get_groups_dict(self):
+    def get_groups_dict(self) -> dict[str, list[str]]:
         """
         We merge a 'magic' var 'groups' with group name keys and hostname list values into every host variable set. Cache for speed.
         """
         if not self._groups_dict_cache:
-            for (group_name, group) in self.groups.items():
+            for group_name, group in self.groups.items():
                 self._groups_dict_cache[group_name] = [h.name for h in group.get_hosts()]
 
         return self._groups_dict_cache