ansible-core 2.19.0rc1__py3-none-any.whl → 2.19.1rc1__py3-none-any.whl

ansible/modules/dnf.py

@@ -208,6 +208,8 @@ options:
         packages to install (because dependencies between the downgraded
         package and others can cause changes to the packages which were
         in the earlier transaction).
+      - Since this feature is not provided by C(dnf) itself but by M(ansible.builtin.dnf) module,
+        using this in combination with wildcard characters in O(name) may result in an unexpected results.
     type: bool
     default: "no"
     version_added: "2.7"
@@ -708,72 +710,56 @@ class DnfModule(YumDnf):
         self.module.exit_json(msg="", results=results)
 
     def _is_installed(self, pkg):
-        installed_query = dnf.subject.Subject(pkg).get_best_query(sack=self.base.sack).installed()
-        if dnf.util.is_glob_pattern(pkg):
-            available_query = dnf.subject.Subject(pkg).get_best_query(sack=self.base.sack).available()
-            return not (
-                {p.name for p in available_query} - {p.name for p in installed_query}
-            )
-        else:
-            return bool(installed_query)
+        return bool(dnf.subject.Subject(pkg).get_best_query(sack=self.base.sack).installed())
 
     def _is_newer_version_installed(self, pkg_spec):
+        # expects a versioned package spec
         try:
             if isinstance(pkg_spec, dnf.package.Package):
                 installed = sorted(self.base.sack.query().installed().filter(name=pkg_spec.name, arch=pkg_spec.arch))[-1]
                 return installed.evr_gt(pkg_spec)
             else:
-                available = dnf.subject.Subject(pkg_spec).get_best_query(sack=self.base.sack).available()
-                installed = self.base.sack.query().installed().filter(name=available[0].name)
-                for arch in sorted(set(p.arch for p in installed)):  # select only from already-installed arches for this case
-                    installed_pkg = sorted(installed.filter(arch=arch))[-1]
-                    try:
-                        available_pkg = sorted(available.filter(arch=arch))[-1]
-                    except IndexError:
-                        continue  # nothing currently available for this arch; keep going
-                    if installed_pkg.evr_gt(available_pkg):
-                        return True
-                return False
+                solution = dnf.subject.Subject(pkg_spec).get_best_solution(self.base.sack)
+                q = solution["query"]
+                if not q or not solution['nevra'] or solution['nevra'].has_just_name():
+                    return False
+                installed = self.base.sack.query().installed().filter(name=solution['nevra'].name)
+                if not installed:
+                    return False
+                return installed[0].evr_gt(q[0])
         except IndexError:
             return False
 
     def _mark_package_install(self, pkg_spec, upgrade=False):
         """Mark the package for install."""
-        is_newer_version_installed = self._is_newer_version_installed(pkg_spec)
-        is_installed = self._is_installed(pkg_spec)
         msg = ''
         try:
-            if is_newer_version_installed:
+            if dnf.util.is_glob_pattern(pkg_spec):
+                # Special case for package specs that contain glob characters.
+                # For these we skip `is_installed` and `is_newer_version_installed` tests that allow for the
+                # allow_downgrade feature and pass the package specs to dnf.
+                # Since allow_downgrade is not available in dnf and while it is relatively easy to implement it for
+                # package specs that evaluate to a single package, trying to mimic what would the dnf machinery do
+                # for glob package specs and then filtering those for allow_downgrade appears to always
+                # result in naive/inferior solution.
+                # NOTE this has historically never worked even before https://github.com/ansible/ansible/pull/82725
+                # where our (buggy) custom code ignored wildcards for the installed checks.
+                # TODO reasearch how feasible it is to implement the above
+                if upgrade:
+                    # for upgrade we pass the spec to both upgrade and install, to satisfy both available and installed
+                    # packages evaluated from the glob spec
+                    try:
+                        self.base.upgrade(pkg_spec)
+                    except dnf.exceptions.PackagesNotInstalledError:
+                        pass
+                self.base.install(pkg_spec, strict=self.base.conf.strict)
+            elif self._is_newer_version_installed(pkg_spec):
                 if self.allow_downgrade:
-                    # dnf only does allow_downgrade, we have to handle this ourselves
-                    # because it allows a possibility for non-idempotent transactions
-                    # on a system's package set (pending the yum repo has many old
-                    # NVRs indexed)
-                    if upgrade:
-                        if is_installed:  # Case 1
-                            # TODO: Is this case reachable?
-                            #
-                            # _is_installed() demands a name (*not* NVR) or else is always False
-                            # (wildcards are treated literally).
-                            #
-                            # Meanwhile, _is_newer_version_installed() demands something versioned
-                            # or else is always false.
-                            #
-                            # I fail to see how they can both be true at the same time for any
-                            # given pkg_spec. -re
-                            self.base.upgrade(pkg_spec)
-                        else:  # Case 2
-                            self.base.install(pkg_spec, strict=self.base.conf.strict)
-                    else:  # Case 3
-                        self.base.install(pkg_spec, strict=self.base.conf.strict)
-                else:  # Case 4, Nothing to do, report back
-                    pass
-            elif is_installed:  # A potentially older (or same) version is installed
-                if upgrade:  # Case 5
+                    self.base.install(pkg_spec, strict=self.base.conf.strict)
+            elif self._is_installed(pkg_spec):
+                if upgrade:
                     self.base.upgrade(pkg_spec)
-                else:  # Case 6, Nothing to do, report back
-                    pass
-            else:  # Case 7, The package is not installed, simply install it
+            else:
                 self.base.install(pkg_spec, strict=self.base.conf.strict)
         except dnf.exceptions.MarkingError as e:
             msg = "No package {0} available.".format(pkg_spec)

ansible/modules/dnf5.py

@@ -178,6 +178,8 @@ options:
         packages to install (because dependencies between the downgraded
         package and others can cause changes to the packages which were
         in the earlier transaction).
+      - Since this feature is not provided by C(dnf5) itself but by M(ansible.builtin.dnf5) module,
+        using this in combination with wildcard characters in O(name) may result in an unexpected results.
     type: bool
     default: "no"
   install_repoquery:
@@ -368,7 +370,7 @@ libdnf5 = None
 LIBDNF5_ERRORS = RuntimeError
 
 
-def is_installed(base, spec):
+def get_resolve_spec_settings():
     settings = libdnf5.base.ResolveSpecSettings()
     try:
         settings.set_group_with_name(True)
@@ -394,47 +396,34 @@ def is_installed(base, spec):
         settings.group_with_name = True
         settings.with_binaries = False
         settings.with_provides = False
+    return settings
+
+
+def is_installed(base, spec):
+    settings = get_resolve_spec_settings()
 
     installed_query = libdnf5.rpm.PackageQuery(base)
     installed_query.filter_installed()
     match, nevra = installed_query.resolve_pkg_spec(spec, settings, True)
-
-    # FIXME use `is_glob_pattern` function when available:
-    # https://github.com/rpm-software-management/dnf5/issues/1563
-    glob_patterns = set("*[?")
-    if any(set(char) & glob_patterns for char in spec):
-        available_query = libdnf5.rpm.PackageQuery(base)
-        available_query.filter_available()
-        available_query.resolve_pkg_spec(spec, settings, True)
-
-        return not (
-            {p.get_name() for p in available_query} - {p.get_name() for p in installed_query}
-        )
-    else:
-        return match
+    return match
 
 
 def is_newer_version_installed(base, spec):
-    # FIXME investigate whether this function can be replaced by dnf5's allow_downgrade option
+    # expects a versioned package spec
     if "/" in spec:
         spec = spec.split("/")[-1]
         if spec.endswith(".rpm"):
             spec = spec[:-4]
 
-    try:
-        spec_nevra = next(iter(libdnf5.rpm.Nevra.parse(spec)))
-    except LIBDNF5_ERRORS:
-        return False
-    except StopIteration:
-        return False
-
-    spec_version = spec_nevra.get_version()
-    if not spec_version:
+    settings = get_resolve_spec_settings()
+    match, spec_nevra = libdnf5.rpm.PackageQuery(base).resolve_pkg_spec(spec, settings, True)
+    if not match or spec_nevra.has_just_name():
         return False
+    spec_name = spec_nevra.get_name()
 
     installed = libdnf5.rpm.PackageQuery(base)
     installed.filter_installed()
-    installed.filter_name([spec_nevra.get_name()])
+    installed.filter_name([spec_name])
     installed.filter_latest_evr()
     try:
         installed_package = list(installed)[-1]
@@ -442,8 +431,8 @@ def is_newer_version_installed(base, spec):
         return False
 
     target = libdnf5.rpm.PackageQuery(base)
-    target.filter_name([spec_nevra.get_name()])
-    target.filter_version([spec_version])
+    target.filter_name([spec_name])
+    target.filter_version([spec_nevra.get_version()])
     spec_release = spec_nevra.get_release()
     if spec_release:
         target.filter_release([spec_release])
@@ -725,8 +714,26 @@ class Dnf5Module(YumDnf):
             goal.add_rpm_upgrade(settings)
         elif self.state in {"installed", "present", "latest"}:
             upgrade = self.state == "latest"
+            # FIXME use `is_glob_pattern` function when available:
+            # https://github.com/rpm-software-management/dnf5/issues/1563
+            glob_patterns = set("*[?")
             for spec in self.names:
-                if is_newer_version_installed(base, spec):
+                if any(set(char) & glob_patterns for char in spec):
+                    # Special case for package specs that contain glob characters.
+                    # For these we skip `is_installed` and `is_newer_version_installed` tests that allow for the
+                    # allow_downgrade feature and pass the package specs to dnf.
+                    # Since allow_downgrade is not available in dnf and while it is relatively easy to implement it for
+                    # package specs that evaluate to a single package, trying to mimic what would the dnf machinery do
+                    # for glob package specs and then filtering those for allow_downgrade appears to always
+                    # result in naive/inferior solution.
+                    # TODO reasearch how feasible it is to implement the above
+                    if upgrade:
+                        # for upgrade we pass the spec to both upgrade and install, to satisfy both available and installed
+                        # packages evaluated from the glob spec
+                        goal.add_upgrade(spec, settings)
+                    if not self.update_only:
+                        goal.add_install(spec, settings)
+                elif is_newer_version_installed(base, spec):
                     if self.allow_downgrade:
                         goal.add_install(spec, settings)
                 elif is_installed(base, spec):

ansible/modules/meta.py

@@ -33,6 +33,7 @@ options:
         - V(clear_facts) (added in Ansible 2.1) causes the gathered facts for the hosts specified in the play's list of hosts to be cleared,
           including the fact cache.
         - V(clear_host_errors) (added in Ansible 2.1) clears the failed state (if any) from hosts specified in the play's list of hosts.
+          This will make them available for targetting in subsequent plays, but not continue execution in the current play.
         - V(end_play) (added in Ansible 2.2) causes the play to end without failing the host(s). Note that this affects all hosts.
         - V(reset_connection) (added in Ansible 2.3) interrupts a persistent connection (i.e. ssh + control persist)
         - V(end_host) (added in Ansible 2.8) is a per-host variation of V(end_play). Causes the play to end for the current host without failing it.
@@ -108,7 +109,7 @@ EXAMPLES = r"""
 - name: Clear gathered facts from all currently targeted hosts
   ansible.builtin.meta: clear_facts
 
-# Example showing how to continue using a failed target
+# Example showing how to continue using a failed target, for the next play
 - name: Bring host back to play after failure
   ansible.builtin.copy:
     src: file

ansible/modules/service_facts.py

@@ -232,7 +232,11 @@ class ServiceScanService(BaseService):
             if service_name == "*":
                 continue
             service_state = line_data[1]
-            service_runlevels = all_services_runlevels[service_name]
+            try:
+                service_runlevels = all_services_runlevels[service_name]
+            except KeyError:
+                self.module.warn(f"Service {service_name} not found in the service list")
+                continue
             service_data = {"name": service_name, "runlevels": service_runlevels, "state": service_state, "source": "openrc"}
             services[service_name] = service_data
 

ansible/playbook/helpers.py

@@ -169,6 +169,7 @@ 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
+                        parent_include.post_validate(templar=templar)
                         parent_include_dir = os.path.dirname(parent_include.args.get('_raw_params'))
                         if cumulative_path is None:
                             cumulative_path = parent_include_dir

ansible/playbook/taggable.py

@@ -20,7 +20,6 @@ from __future__ import annotations
 import typing as t
 
 from ansible.errors import AnsibleError
-from ansible.module_utils.six import string_types
 from ansible.module_utils.common.sentinel import Sentinel
 from ansible.module_utils._internal._datatag import AnsibleTagHelper
 from ansible.playbook.attribute import FieldAttribute
@@ -40,7 +39,7 @@ def _flatten_tags(tags: list[str | int]) -> list[str | int]:
 class Taggable:
 
     untagged = frozenset(['untagged'])
-    tags = FieldAttribute(isa='list', default=list, listof=(string_types, int), extend=True)
+    tags = FieldAttribute(isa='list', default=list, listof=(str, int), extend=True)
 
     def _load_tags(self, attr, ds):
         if isinstance(ds, list):

ansible/plugins/__init__.py

@@ -79,6 +79,7 @@ class AnsiblePlugin(_AnsiblePluginInfoMixin, _ConfigurablePlugin, metaclass=abc.
 
     def __init__(self):
         self._options = {}
+        self._origins = {}
         self._defs = None
 
     @property
@@ -98,11 +99,16 @@ class AnsiblePlugin(_AnsiblePluginInfoMixin, _ConfigurablePlugin, metaclass=abc.
         return bool(possible_fqcns.intersection(set(self.ansible_aliases)))
 
     def get_option_and_origin(self, option, hostvars=None):
-        try:
-            option_value, origin = C.config.get_config_value_and_origin(option, plugin_type=self.plugin_type, plugin_name=self._load_name, variables=hostvars)
-        except AnsibleError as e:
-            raise KeyError(str(e))
-        return option_value, origin
+        if option not in self._options:
+            try:
+                # some plugins don't use set_option(s) and cannot use direct settings, so this populates the local copy for them
+                self._options[option], self._origins[option] = C.config.get_config_value_and_origin(option, plugin_type=self.plugin_type,
+                                                                                                    plugin_name=self._load_name, variables=hostvars)
+            except AnsibleError as e:
+                # callers expect key error on missing
+                raise KeyError() from e
+
+        return self._options[option], self._origins[option]
 
     @functools.cached_property
     def __plugin_info(self):
@@ -113,11 +119,10 @@ class AnsiblePlugin(_AnsiblePluginInfoMixin, _ConfigurablePlugin, metaclass=abc.
         return _plugin_info.get_plugin_info(self)
 
     def get_option(self, option, hostvars=None):
-
         if option not in self._options:
-            option_value, dummy = self.get_option_and_origin(option, hostvars=hostvars)
-            self.set_option(option, option_value)
-        return self._options.get(option)
+            # let it populate _options
+            self.get_option_and_origin(option, hostvars=hostvars)
+        return self._options[option]
 
     def get_options(self, hostvars=None):
         options = {}
@@ -127,6 +132,7 @@ class AnsiblePlugin(_AnsiblePluginInfoMixin, _ConfigurablePlugin, metaclass=abc.
 
     def set_option(self, option, value):
         self._options[option] = C.config.get_config_value(option, plugin_type=self.plugin_type, plugin_name=self._load_name, direct={option: value})
+        self._origins[option] = 'Direct'
         _display._report_config_warnings(self.__plugin_info)
 
     def set_options(self, task_keys=None, var_options=None, direct=None):
@@ -137,12 +143,14 @@ class AnsiblePlugin(_AnsiblePluginInfoMixin, _ConfigurablePlugin, metaclass=abc.
         :arg var_options: Dict with either 'connection variables'
         :arg direct: Dict with 'direct assignment'
         """
-        self._options = C.config.get_plugin_options(self.plugin_type, self._load_name, keys=task_keys, variables=var_options, direct=direct)
+        self._options, self._origins = C.config.get_plugin_options_and_origins(self.plugin_type, self._load_name, keys=task_keys,
+                                                                               variables=var_options, direct=direct)
 
         # allow extras/wildcards from vars that are not directly consumed in configuration
         # this is needed to support things like winrm that can have extended protocol options we don't directly handle
         if self.allow_extras and var_options and '_extras' in var_options:
             # these are largely unvalidated passthroughs, either plugin or underlying API will validate
+            # TODO: deprecate and remove, most plugins that needed this don't use this facility anymore
             self._options['_extras'] = var_options['_extras']
         _display._report_config_warnings(self.__plugin_info)
 

ansible/plugins/callback/__init__.py

@@ -228,10 +228,14 @@ class CallbackBase(AnsiblePlugin):
 
     def set_option(self, k, v):
         self._plugin_options[k] = C.config.get_config_value(k, plugin_type=self.plugin_type, plugin_name=self._load_name, direct={k: v})
+        self._origins[k] = 'direct'
 
     def get_option(self, k, hostvars=None):
         return self._plugin_options[k]
 
+    def get_option_and_origin(self, k, hostvars=None):
+        return self._plugin_options[k], self._origins[k]
+
     def has_option(self, option):
         return (option in self._plugin_options)
 
@@ -241,7 +245,8 @@ class CallbackBase(AnsiblePlugin):
         """
 
         # load from config
-        self._plugin_options = C.config.get_plugin_options(self.plugin_type, self._load_name, keys=task_keys, variables=var_options, direct=direct)
+        self._plugin_options, self._origins = C.config.get_plugin_options_and_origins(self.plugin_type, self._load_name,
+                                                                                      keys=task_keys, variables=var_options, direct=direct)
 
     @staticmethod
     def host_label(result: CallbackTaskResult) -> str:

ansible/plugins/filter/to_json.yml

@@ -23,8 +23,9 @@ DOCUMENTATION:
       default: True
       version_added: '2.9'
     allow_nan:
-      description: When V(False), strict adherence to float value limits of the JSON specifications, so C(nan), C(inf) and C(-inf) values will produce errors.
-                   When V(True), JavaScript equivalents will be used (C(NaN), C(Infinity), C(-Infinity)).
+      description:
+        - When V(False), out-of-range float values C(nan), C(inf) and C(-inf) will result in an error.
+        - When V(True), out-of-range float values will be represented using their JavaScript equivalents, C(NaN), C(Infinity) and C(-Infinity).
       default: True
       type: bool
     check_circular:
@@ -42,8 +43,11 @@ DOCUMENTATION:
     separators:
       description: The C(item) and C(key) separator to be used in the serialized output,
                    default may change depending on O(indent) and Python version.
-      default: "(', ', ': ')"
-      type: tuple
+      default:
+        - ', '
+        - ': '
+      type: list
+      elements: str
     skipkeys:
       description: If V(True), keys that are not basic Python types will be skipped.
       default: False

ansible/plugins/filter/to_nice_json.yml

@@ -23,8 +23,9 @@ DOCUMENTATION:
       default: True
       version_added: '2.9'
     allow_nan:
-      description: When V(False), strict adherence to float value limits of the JSON specification, so C(nan), C(inf) and C(-inf) values will produce errors.
-                   When V(True), JavaScript equivalents will be used (C(NaN), C(Infinity), C(-Infinity)).
+      description:
+        - When V(False), out-of-range float values C(nan), C(inf) and C(-inf) will result in an error.
+        - When V(True), out-of-range float values will be represented using their JavaScript equivalents, C(NaN), C(Infinity) and C(-Infinity).
       default: True
       type: bool
     check_circular:

ansible/plugins/lookup/template.py

@@ -107,6 +107,7 @@ from ansible.errors import AnsibleError
 from ansible.plugins.lookup import LookupBase
 from ansible.template import trust_as_template
 from ansible._internal._templating import _template_vars
+from ansible._internal._templating._engine import TemplateOptions, TemplateOverrides
 from ansible.utils.display import Display
 
 
@@ -174,7 +175,11 @@ class LookupModule(LookupBase):
                 )
 
                 data_templar = templar.copy_with_new_env(available_variables=vars, searchpath=searchpath)
-                res = data_templar.template(template_data, escape_backslashes=False, overrides=overrides)
+                # use the internal template API to avoid forced top-level finalization behavior imposed by the public API
+                res = data_templar._engine.template(template_data, options=TemplateOptions(
+                    escape_backslashes=False,
+                    overrides=TemplateOverrides.from_kwargs(overrides),
+                ))
 
                 ret.append(res)
             else:

ansible/release.py

@@ -17,6 +17,6 @@
 
 from __future__ import annotations
 
-__version__ = '2.19.0rc1'
+__version__ = '2.19.1rc1'
 __author__ = 'Ansible, Inc.'
 __codename__ = "What Is and What Should Never Be"

ansible/utils/encrypt.py

@@ -99,6 +99,8 @@ class PasslibHash(BaseHash):
         salt = self._clean_salt(salt)
         rounds = self._clean_rounds(rounds)
         ident = self._clean_ident(ident)
+        if salt_size is not None and not isinstance(salt_size, int):
+            raise TypeError("salt_size must be an integer")
         return self._hash(secret, salt=salt, salt_size=salt_size, rounds=rounds, ident=ident)
 
     def _clean_ident(self, ident):

{ansible_core-2.19.0rc1.dist-info → ansible_core-2.19.1rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ansible-core
-Version: 2.19.0rc1
+Version: 2.19.1rc1
 Summary: Radically simple IT automation
 Author: Ansible Project
 Project-URL: Homepage, https://ansible.com/