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

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

ansible/inventory/group.py

@@ -16,6 +16,8 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
+import typing as t
+
 from collections.abc import Mapping, MutableMapping
 from enum import Enum
 from itertools import chain
@@ -26,8 +28,13 @@ from ansible.module_utils.common.text.converters import to_native, to_text
 from ansible.utils.display import Display
 from ansible.utils.vars import combine_vars
 
+from . import helpers  # this is left as a module import to facilitate easier unit test patching
+
 display = Display()
 
+if t.TYPE_CHECKING:
+    from .host import Host
+
 
 def to_safe_group_name(name, replacer="_", force=False, silent=False):
     # Converts 'bad' characters in a string to underscores (or provided replacer) so they can be used as Ansible hosts or groups
@@ -59,22 +66,23 @@ class InventoryObjectType(Enum):
 
 
 class Group:
-    ''' a group of ansible hosts '''
+    """A group of ansible hosts."""
     base_type = InventoryObjectType.GROUP
 
     # __slots__ = [ 'name', 'hosts', 'vars', 'child_groups', 'parent_groups', 'depth', '_hosts_cache' ]
 
-    def __init__(self, name=None):
+    def __init__(self, name: str) -> None:
+        name = helpers.remove_trust(name)
 
-        self.depth = 0
-        self.name = to_safe_group_name(name)
-        self.hosts = []
-        self._hosts = None
-        self.vars = {}
-        self.child_groups = []
-        self.parent_groups = []
-        self._hosts_cache = None
-        self.priority = 1
+        self.depth: int = 0
+        self.name: str = to_safe_group_name(name)
+        self.hosts: list[Host] = []
+        self._hosts: set[str] | None = None
+        self.vars: dict[str, t.Any] = {}
+        self.child_groups: list[Group] = []
+        self.parent_groups: list[Group] = []
+        self._hosts_cache: list[Host] | None = None
+        self.priority: int = 1
 
     def __repr__(self):
         return self.get_name()
@@ -82,45 +90,8 @@ class Group:
     def __str__(self):
         return self.get_name()
 
-    def __getstate__(self):
-        return self.serialize()
-
-    def __setstate__(self, data):
-        return self.deserialize(data)
-
-    def serialize(self):
-        parent_groups = []
-        for parent in self.parent_groups:
-            parent_groups.append(parent.serialize())
-
-        self._hosts = None
-
-        result = dict(
-            name=self.name,
-            vars=self.vars.copy(),
-            parent_groups=parent_groups,
-            depth=self.depth,
-            hosts=self.hosts,
-        )
-
-        return result
-
-    def deserialize(self, data):
-        self.__init__()  # used by __setstate__ to deserialize in place  # pylint: disable=unnecessary-dunder-call
-        self.name = data.get('name')
-        self.vars = data.get('vars', dict())
-        self.depth = data.get('depth', 0)
-        self.hosts = data.get('hosts', [])
-        self._hosts = None
-
-        parent_groups = data.get('parent_groups', [])
-        for parent_data in parent_groups:
-            g = Group()
-            g.deserialize(parent_data)
-            self.parent_groups.append(g)
-
-    def _walk_relationship(self, rel, include_self=False, preserve_ordering=False):
-        '''
+    def _walk_relationship(self, rel, include_self=False, preserve_ordering=False) -> set[Group] | list[Group]:
+        """
         Given `rel` that is an iterable property of Group,
         consitituting a directed acyclic graph among all groups,
         Returns a set of all groups in full tree
@@ -132,13 +103,13 @@ class Group:
         | /     are directed upward
         F
         Called on F, returns set of (A, B, C, D, E)
-        '''
-        seen = set([])
+        """
+        seen: set[Group] = set([])
         unprocessed = set(getattr(self, rel))
         if include_self:
             unprocessed.add(self)
         if preserve_ordering:
-            ordered = [self] if include_self else []
+            ordered: list[Group] = [self] if include_self else []
             ordered.extend(getattr(self, rel))
 
         while unprocessed:
@@ -158,22 +129,22 @@ class Group:
             return ordered
         return seen
 
-    def get_ancestors(self):
-        return self._walk_relationship('parent_groups')
+    def get_ancestors(self) -> set[Group]:
+        return t.cast(set, self._walk_relationship('parent_groups'))
 
-    def get_descendants(self, **kwargs):
+    def get_descendants(self, **kwargs) -> set[Group] | list[Group]:
         return self._walk_relationship('child_groups', **kwargs)
 
     @property
-    def host_names(self):
+    def host_names(self) -> set[str]:
         if self._hosts is None:
-            self._hosts = set(self.hosts)
+            self._hosts = {h.name for h in self.hosts}
         return self._hosts
 
-    def get_name(self):
+    def get_name(self) -> str:
         return self.name
 
-    def add_child_group(self, group):
+    def add_child_group(self, group: Group) -> bool:
         added = False
         if self == group:
             raise Exception("can't add group to itself")
@@ -208,7 +179,7 @@ class Group:
             self.clear_hosts_cache()
         return added
 
-    def _check_children_depth(self):
+    def _check_children_depth(self) -> None:
 
         depth = self.depth
         start_depth = self.depth  # self.depth could change over loop
@@ -227,7 +198,7 @@ class Group:
             if depth - start_depth > len(seen):
                 raise AnsibleError("The group named '%s' has a recursive dependency loop." % to_native(self.name))
 
-    def add_host(self, host):
+    def add_host(self, host: Host) -> bool:
         added = False
         if host.name not in self.host_names:
             self.hosts.append(host)
@@ -237,7 +208,7 @@ class Group:
             added = True
         return added
 
-    def remove_host(self, host):
+    def remove_host(self, host: Host) -> bool:
         removed = False
         if host.name in self.host_names:
             self.hosts.remove(host)
@@ -247,7 +218,8 @@ class Group:
             removed = True
         return removed
 
-    def set_variable(self, key, value):
+    def set_variable(self, key: str, value: t.Any) -> None:
+        key = helpers.remove_trust(key)
 
         if key == 'ansible_group_priority':
             self.set_priority(int(value))
@@ -257,36 +229,36 @@ class Group:
             else:
                 self.vars[key] = value
 
-    def clear_hosts_cache(self):
+    def clear_hosts_cache(self) -> None:
 
         self._hosts_cache = None
         for g in self.get_ancestors():
             g._hosts_cache = None
 
-    def get_hosts(self):
+    def get_hosts(self) -> list[Host]:
 
         if self._hosts_cache is None:
             self._hosts_cache = self._get_hosts()
         return self._hosts_cache
 
-    def _get_hosts(self):
+    def _get_hosts(self) -> list[Host]:
 
-        hosts = []
-        seen = {}
+        hosts: list[Host] = []
+        seen: set[Host] = set()
         for kid in self.get_descendants(include_self=True, preserve_ordering=True):
             kid_hosts = kid.hosts
             for kk in kid_hosts:
                 if kk not in seen:
-                    seen[kk] = 1
+                    seen.add(kk)
                     if self.name == 'all' and kk.implicit:
                         continue
                     hosts.append(kk)
         return hosts
 
-    def get_vars(self):
+    def get_vars(self) -> dict[str, t.Any]:
         return self.vars.copy()
 
-    def set_priority(self, priority):
+    def set_priority(self, priority: int | str) -> None:
         try:
             self.priority = int(priority)
         except TypeError:

ansible/inventory/helpers.py

@@ -18,6 +18,7 @@
 #############################################
 from __future__ import annotations
 
+from ansible._internal._datatag._tags import TrustedAsTemplate
 from ansible.utils.vars import combine_vars
 
 
@@ -37,3 +38,11 @@ def get_group_vars(groups):
         results = combine_vars(results, group.get_vars())
 
     return results
+
+
+def remove_trust(value: str) -> str:
+    """
+    Remove trust from strings which should not be trusted.
+    This exists to centralize the untagging call which facilitate patching it out in unit tests.
+    """
+    return TrustedAsTemplate.untag(value)