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

ansible/_internal/_ansiballz/_builder.py

@@ -6,7 +6,7 @@ import json
 import typing as t
 
 from ansible.module_utils._internal._ansiballz import _extensions
-from ansible.module_utils._internal._ansiballz._extensions import _pydevd, _coverage
+from ansible.module_utils._internal._ansiballz._extensions import _debugpy, _pydevd, _coverage
 from ansible.constants import config
 
 _T = t.TypeVar('_T')
@@ -17,15 +17,18 @@ class ExtensionManager:
 
     def __init__(
         self,
-        debugger: _pydevd.Options | None = None,
+        pydevd: _pydevd.Options | None = None,
+        debugpy: _debugpy.Options | None = None,
         coverage: _coverage.Options | None = None,
     ) -> None:
         options = dict(
-            _pydevd=debugger,
+            _pydevd=pydevd,
+            _debugpy=debugpy,
             _coverage=coverage,
         )
 
-        self._debugger = debugger
+        self._pydevd = pydevd
+        self._debugpy = debugpy
         self._coverage = coverage
         self._extension_names = tuple(name for name, option in options.items() if option)
         self._module_names = tuple(f'{_extensions.__name__}.{name}' for name in self._extension_names)
@@ -35,7 +38,7 @@ class ExtensionManager:
     @property
     def debugger_enabled(self) -> bool:
         """Returns True if the debugger extension is enabled, otherwise False."""
-        return bool(self._debugger)
+        return bool(self._pydevd or self._debugpy)
 
     @property
     def extension_names(self) -> tuple[str, ...]:
@@ -51,10 +54,16 @@ class ExtensionManager:
         """Return the configured extensions and their options."""
         extension_options: dict[str, t.Any] = {}
 
-        if self._debugger:
+        if self._debugpy:
+            extension_options['_debugpy'] = dataclasses.replace(
+                self._debugpy,
+                source_mapping=self._get_source_mapping(self._debugpy.source_mapping),
+            )
+
+        if self._pydevd:
             extension_options['_pydevd'] = dataclasses.replace(
-                self._debugger,
-                source_mapping=self._get_source_mapping(),
+                self._pydevd,
+                source_mapping=self._get_source_mapping(self._pydevd.source_mapping),
             )
 
         if self._coverage:
@@ -64,18 +73,19 @@ class ExtensionManager:
 
         return extensions
 
-    def _get_source_mapping(self) -> dict[str, str]:
+    def _get_source_mapping(self, debugger_mapping: dict[str, str]) -> dict[str, str]:
         """Get the source mapping, adjusting the source root as needed."""
-        if self._debugger.source_mapping:
-            source_mapping = {self._translate_path(key): value for key, value in self.source_mapping.items()}
+        if debugger_mapping:
+            source_mapping = {self._translate_path(key, debugger_mapping): value for key, value in self.source_mapping.items()}
         else:
             source_mapping = self.source_mapping
 
         return source_mapping
 
-    def _translate_path(self, path: str) -> str:
+    @staticmethod
+    def _translate_path(path: str, debugger_mapping: dict[str, str]) -> str:
         """Translate a local path to a foreign path."""
-        for replace, match in self._debugger.source_mapping.items():
+        for replace, match in debugger_mapping.items():
             if path.startswith(match):
                 return replace + path[len(match) :]
 
@@ -85,7 +95,8 @@ class ExtensionManager:
     def create(cls, task_vars: dict[str, object]) -> t.Self:
         """Create an instance using the provided task vars."""
         return cls(
-            debugger=cls._get_options('_ANSIBALLZ_DEBUGGER_CONFIG', _pydevd.Options, task_vars),
+            pydevd=cls._get_options('_ANSIBALLZ_PYDEVD_CONFIG', _pydevd.Options, task_vars),
+            debugpy=cls._get_options('_ANSIBALLZ_DEBUGPY_CONFIG', _debugpy.Options, task_vars),
             coverage=cls._get_options('_ANSIBALLZ_COVERAGE_CONFIG', _coverage.Options, task_vars),
         )
 

ansible/_internal/_templating/_engine.py

@@ -6,7 +6,6 @@ from __future__ import annotations
 import copy
 import dataclasses
 import enum
-import textwrap
 import typing as t
 import collections.abc as c
 import re
@@ -44,7 +43,7 @@ from ._jinja_bits import (
     _finalize_template_result,
     FinalizeMode,
 )
-from ._jinja_common import _TemplateConfig, MarkerError, ExceptionMarker
+from ._jinja_common import _TemplateConfig, MarkerError, ExceptionMarker, JinjaCallContext
 from ._lazy_containers import _AnsibleLazyTemplateMixin
 from ._marker_behaviors import MarkerBehavior, FAIL_ON_UNDEFINED
 from ._transform import _type_transform_mapping
@@ -260,6 +259,7 @@ class TemplateEngine:
             with (
                 TemplateContext(template_value=variable, templar=self, options=options, stop_on_template=stop_on_template) as ctx,
                 DeprecatedAccessAuditContext.when(ctx.is_top_level),
+                JinjaCallContext(accept_lazy_markers=True),  # let default Jinja marker behavior apply, since we're descending into a new template
             ):
                 try:
                     if not value_is_str:
@@ -559,9 +559,11 @@ class TemplateEngine:
 
         bool_result = bool(result)
 
+        result_origin = Origin.get_tag(result) or Origin.UNKNOWN
+
         msg = (
-            f'Conditional result was {textwrap.shorten(str(result), width=40)!r} of type {native_type_name(result)!r}, '
-            f'which evaluates to {bool_result}. Conditionals must have a boolean result.'
+            f'Conditional result ({bool_result}) was derived from value of type {native_type_name(result)!r} at {str(result_origin)!r}. '
+            'Conditionals must have a boolean result.'
         )
 
         if _TemplateConfig.allow_broken_conditionals:

ansible/_internal/_templating/_jinja_bits.py

@@ -811,7 +811,7 @@ class AnsibleEnvironment(SandboxedEnvironment):
             try:
                 value = obj[attribute]
             except (TypeError, LookupError):
-                return self.undefined(obj=obj, name=attribute) if is_safe else self.unsafe_undefined(obj, attribute)
+                value = self.undefined(obj=obj, name=attribute) if is_safe else self.unsafe_undefined(obj, attribute)
 
         AnsibleAccessContext.current().access(value)
 
@@ -891,6 +891,8 @@ def _flatten_nodes(nodes: t.Iterable[t.Any]) -> t.Iterable[t.Any]:
         else:
             if type(node) is TemplateModule:  # pylint: disable=unidiomatic-typecheck
                 yield from _flatten_nodes(node._body_stream)
+            elif node is None:
+                continue  # avoid yielding `None`-valued nodes to avoid literal "None" in stringified template results
             else:
                 yield node
 

ansible/_internal/_templating/_jinja_plugins.py

@@ -115,7 +115,13 @@ class JinjaPluginIntercept(c.MutableMapping):
 
         try:
             with JinjaCallContext(accept_lazy_markers=instance.accept_lazy_markers):
-                return instance.j2_function(*lazify_container_args(args), **lazify_container_kwargs(kwargs))
+                result = instance.j2_function(*lazify_container_args(args), **lazify_container_kwargs(kwargs))
+
+                if instance.plugin_type == 'filter':
+                    # ensure list conversion occurs under the call context
+                    result = _wrap_plugin_output(result)
+
+                return result
         except MarkerError as ex:
             return ex.source
         except Exception as ex:
@@ -156,7 +162,6 @@ class JinjaPluginIntercept(c.MutableMapping):
         @functools.wraps(instance.j2_function)
         def wrapper(*args, **kwargs) -> t.Any:
             result = self._invoke_plugin(instance, *args, **kwargs)
-            result = _wrap_plugin_output(result)
 
             return result
 

ansible/_internal/_templating/_lazy_containers.py

@@ -229,8 +229,6 @@ class _AnsibleLazyTemplateDict(_AnsibleTaggedDict, _AnsibleLazyTemplateMixin):
     __slots__ = _AnsibleLazyTemplateMixin._SLOTS
 
     def __init__(self, contents: t.Iterable | _LazyValueSource, /, **kwargs) -> None:
-        _AnsibleLazyTemplateMixin.__init__(self, contents)
-
         if isinstance(contents, _AnsibleLazyTemplateDict):
             super().__init__(dict.items(contents), **kwargs)
         elif isinstance(contents, _LazyValueSource):
@@ -238,6 +236,8 @@ class _AnsibleLazyTemplateDict(_AnsibleTaggedDict, _AnsibleLazyTemplateMixin):
         else:
             raise UnsupportedConstructionMethodError()
 
+        _AnsibleLazyTemplateMixin.__init__(self, contents)
+
     def get(self, key: t.Any, default: t.Any = None) -> t.Any:
         if (value := super().get(key, _NoKeySentinel)) is _NoKeySentinel:
             return default
@@ -372,8 +372,6 @@ class _AnsibleLazyTemplateList(_AnsibleTaggedList, _AnsibleLazyTemplateMixin):
     __slots__ = _AnsibleLazyTemplateMixin._SLOTS
 
     def __init__(self, contents: t.Iterable | _LazyValueSource, /) -> None:
-        _AnsibleLazyTemplateMixin.__init__(self, contents)
-
         if isinstance(contents, _AnsibleLazyTemplateList):
             super().__init__(list.__iter__(contents))
         elif isinstance(contents, _LazyValueSource):
@@ -381,6 +379,8 @@ class _AnsibleLazyTemplateList(_AnsibleTaggedList, _AnsibleLazyTemplateMixin):
         else:
             raise UnsupportedConstructionMethodError()
 
+        _AnsibleLazyTemplateMixin.__init__(self, contents)
+
     def __getitem__(self, key: t.SupportsIndex | slice, /) -> t.Any:
         if type(key) is slice:  # pylint: disable=unidiomatic-typecheck
             return _AnsibleLazyTemplateList(_LazyValueSource(source=super().__getitem__(key), templar=self._templar, lazy_options=self._lazy_options))
@@ -567,7 +567,7 @@ class _AnsibleLazyAccessTuple(_AnsibleTaggedTuple, _AnsibleLazyTemplateMixin):
 
     def __getitem__(self, key: t.SupportsIndex | slice, /) -> t.Any:
         if type(key) is slice:  # pylint: disable=unidiomatic-typecheck
-            return _AnsibleLazyAccessTuple(super().__getitem__(key))
+            return _AnsibleLazyAccessTuple(_LazyValueSource(source=super().__getitem__(key), templar=self._templar, lazy_options=self._lazy_options))
 
         value = super().__getitem__(key)
 

ansible/config/base.yml

@@ -11,16 +11,26 @@ _ANSIBALLZ_COVERAGE_CONFIG:
   vars:
   - {name: _ansible_ansiballz_coverage_config}
   version_added: '2.19'
-_ANSIBALLZ_DEBUGGER_CONFIG:
-  name: Configure the AnsiballZ remote debugging extension
+_ANSIBALLZ_DEBUGPY_CONFIG:
+  name: Configure the AnsiballZ remote debugging extension for debugpy
   description:
-    - Enables and configures the AnsiballZ remote debugging extension.
+    - Enables and configures the AnsiballZ remote debugging extension for debugpy.
     - This is for internal use only.
   env:
-  - {name: _ANSIBLE_ANSIBALLZ_DEBUGGER_CONFIG}
+  - {name: _ANSIBLE_ANSIBALLZ_DEBUGPY_CONFIG}
   vars:
-  - {name: _ansible_ansiballz_debugger_config}
-  version_added: '2.19'
+  - {name: _ansible_ansiballz_debugpy_config}
+  version_added: '2.20'
+_ANSIBALLZ_PYDEVD_CONFIG:
+  name: Configure the AnsiballZ remote debugging extension for pydevd
+  description:
+    - Enables and configures the AnsiballZ remote debugging extension for pydevd.
+    - This is for internal use only.
+  env:
+  - {name: _ANSIBLE_ANSIBALLZ_PYDEVD_CONFIG}
+  vars:
+  - {name: _ansible_ansiballz_pydevd_config}
+  version_added: '2.20'
 _ANSIBLE_CONNECTION_PATH:
   env:
   - name: _ANSIBLE_CONNECTION_PATH

ansible/config/manager.py

@@ -450,13 +450,17 @@ class ConfigManager:
         pass
 
     def get_plugin_options(self, plugin_type, name, keys=None, variables=None, direct=None):
+        options, dummy = self.get_plugin_options_and_origins(plugin_type, name, keys=keys, variables=variables, direct=direct)
+        return options
 
+    def get_plugin_options_and_origins(self, plugin_type, name, keys=None, variables=None, direct=None):
         options = {}
+        origins = {}
         defs = self.get_configuration_definitions(plugin_type=plugin_type, name=name)
         for option in defs:
-            options[option] = self.get_config_value(option, plugin_type=plugin_type, plugin_name=name, keys=keys, variables=variables, direct=direct)
-
-        return options
+            options[option], origins[option] = self.get_config_value_and_origin(option, plugin_type=plugin_type, plugin_name=name, keys=keys,
+                                                                                variables=variables, direct=direct)
+        return options, origins
 
     def get_plugin_vars(self, plugin_type, name):
 

ansible/executor/task_executor.py

@@ -712,7 +712,10 @@ class TaskExecutor:
                     condname = 'failed'
 
                     if self._task.failed_when:
-                        result['failed_when_result'] = result['failed'] = self._task._resolve_conditional(self._task.failed_when, vars_copy)
+                        is_failed = result['failed_when_result'] = result['failed'] = self._task._resolve_conditional(self._task.failed_when, vars_copy)
+
+                        if not is_failed and (suppressed_exception := result.pop('exception', None)):
+                            result['failed_when_suppressed_exception'] = suppressed_exception
 
                 except AnsibleError as e:
                     result['failed'] = True

ansible/executor/task_queue_manager.py

@@ -179,7 +179,7 @@ class TaskQueueManager:
             for fd in (STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO):
                 os.set_inheritable(fd, False)
         except Exception as ex:
-            self.warning(f"failed to set stdio as non inheritable: {ex}")
+            display.error_as_warning("failed to set stdio as non inheritable", exception=ex)
 
         self._callback_lock = threading.Lock()
 
@@ -269,7 +269,7 @@ class TaskQueueManager:
                     display.warning("Skipping callback '%s', as it does not create a valid plugin instance." % callback_name)
                     continue
             except Exception as ex:
-                display.warning_as_error(f"Failed to load callback plugin {callback_name!r}.", exception=ex)
+                display.error_as_warning(f"Failed to load callback plugin {callback_name!r}.", exception=ex)
                 continue
 
     def run(self, play):

ansible/module_utils/_internal/_ansiballz/_extensions/_debugpy.py

@@ -0,0 +1,97 @@
+"""
+Remote debugging support for AnsiballZ modules with debugpy.
+
+To use with VS Code:
+
+1) Choose an available port for VS Code to listen on (e.g. 5678).
+2) Ensure `debugpy` is installed for the interpreter(s) which will run the code being debugged.
+3) Create the following launch.json configuration
+
+    {
+        "version": "0.2.0",
+        "configurations": [
+            {
+                "name": "Python Debug Server",
+                "type": "debugpy",
+                "request": "attach",
+                "listen": {
+                    "host": "localhost",
+                    "port": 5678,
+                },
+            },
+            {
+                "name": "ansible-playbook main.yml",
+                "type": "debugpy",
+                "request": "launch",
+                "module": "ansible",
+                "args": [
+                    "playbook",
+                    "main.yml"
+                ],
+                "env": {
+                    "_ANSIBLE_ANSIBALLZ_DEBUGPY_CONFIG": "{\"host\": \"localhost\", \"port\": 5678}"
+                },
+                "console": "integratedTerminal",
+            }
+        ],
+        "compounds": [
+            {
+                "name": "Test Module Debugging",
+                "configurations": [
+                    "Python Debug Server",
+                    "ansible-playbook main.yml"
+                ],
+                "stopAll": true
+            }
+        ]
+    }
+
+4) Set any desired breakpoints.
+5) Configure the Run and Debug view to use the "Test Module Debugging" compound configuration.
+6) Press F5 to start debugging.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+import os
+import pathlib
+
+import typing as t
+
+
+@dataclasses.dataclass(frozen=True)
+class Options:
+    """Debugger options for debugpy."""
+
+    host: str = 'localhost'
+    """The host to connect to for remote debugging."""
+    port: int = 5678
+    """The port to connect to for remote debugging."""
+    connect: dict[str, object] = dataclasses.field(default_factory=dict)
+    """The options to pass to the `debugpy.connect` method."""
+    source_mapping: dict[str, str] = dataclasses.field(default_factory=dict)
+    """
+    A mapping of source paths to provide to debugpy.
+    This setting is used internally by AnsiballZ and is not required unless Ansible CLI commands are run from a different system than your IDE.
+    In that scenario, use this setting instead of configuring source mapping in your IDE.
+    The key is a path known to the IDE.
+    The value is the same path as known to the Ansible CLI.
+    Both file paths and directories are supported.
+    """
+
+
+def run(args: dict[str, t.Any]) -> None:  # pragma: nocover
+    """Enable remote debugging."""
+    import debugpy
+
+    options = Options(**args)
+    temp_dir = pathlib.Path(__file__).parent.parent.parent.parent.parent.parent
+    path_mapping = [[key, str(temp_dir / value)] for key, value in options.source_mapping.items()]
+
+    os.environ['PATHS_FROM_ECLIPSE_TO_PYTHON'] = json.dumps(path_mapping)
+
+    debugpy.connect((options.host, options.port), **options.connect)
+
+    pass  # A convenient place to put a breakpoint

ansible/module_utils/_internal/_ansiballz/_extensions/_pydevd.py

@@ -7,14 +7,12 @@ To use with PyCharm:
 2) Create a Python Debug Server using that port.
 3) Start the Python Debug Server.
 4) Ensure the correct version of `pydevd-pycharm` is installed for the interpreter(s) which will run the code being debugged.
-5) Configure Ansible with the `_ANSIBALLZ_DEBUGGER_CONFIG` option.
+5) Configure Ansible with the `_ANSIBALLZ_PYDEVD_CONFIG` option.
    See `Options` below for the structure of the debugger configuration.
    Example configuration using an environment variable:
-     export _ANSIBLE_ANSIBALLZ_DEBUGGER_CONFIG='{"module": "pydevd_pycharm", "settrace": {"host": "localhost", "port": 5678, "suspend": false}}'
+     export _ANSIBLE_ANSIBALLZ_PYDEVD_CONFIG='{"module": "pydevd_pycharm", "settrace": {"host": "localhost", "port": 5678, "suspend": false}}'
 6) Set any desired breakpoints.
 7) Run Ansible commands.
-
-A similar process should work for other pydevd based debuggers, such as Visual Studio Code, but they have not been tested.
 """
 
 from __future__ import annotations

ansible/module_utils/_internal/_traceback.py

@@ -80,7 +80,7 @@ def _is_module_traceback_enabled(event: TracebackEvent) -> bool:
             from ..basic import _PARSED_MODULE_ARGS
 
             _module_tracebacks_enabled_events = frozenset(
-                TracebackEvent[value.upper()] for value in _PARSED_MODULE_ARGS.get('_ansible_tracebacks_for')
+                TracebackEvent[value.upper()] for value in _PARSED_MODULE_ARGS.get('_ansible_tracebacks_for', [])
             )  # type: ignore[union-attr]
         except BaseException:
             return True  # if things failed early enough that we can't figure this out, assume we want a traceback for troubleshooting

ansible/module_utils/ansible_release.py

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

ansible/module_utils/basic.py

@@ -1512,11 +1512,19 @@ class AnsibleModule(object):
         # strip no_log collisions
         kwargs = remove_values(kwargs, self.no_log_values)
 
-        # return preserved
+        # graft preserved values back on
         kwargs.update(preserved)
 
+        self._record_module_result(kwargs)
+
+    def _record_module_result(self, o: dict[str, t.Any]) -> None:
+        """
+        Temporary internal hook to enable modification/bypass of module result serialization.
+
+        Monkeypatched by ansible.netcommon for direct in-worker module execution.
+        """
         encoder = _json.get_module_encoder(_ANSIBLE_PROFILE, _json.Direction.MODULE_TO_CONTROLLER)
-        print('\n%s' % json.dumps(kwargs, cls=encoder))
+        print('\n%s' % json.dumps(o, cls=encoder))
 
     def exit_json(self, **kwargs) -> t.NoReturn:
         """ return from the module, without error """

ansible/module_utils/common/validation.py

@@ -376,7 +376,10 @@ def check_type_str(value, allow_conversion=True, param=None, prefix=''):
     if isinstance(value, string_types):
         return value
 
-    if allow_conversion and value is not None:
+    if value is None:
+        return ''  # approximate pre-2.19 templating None->empty str equivalency here for backward compatibility
+
+    if allow_conversion:
         return to_native(value, errors='surrogate_or_strict')
 
     msg = "'{0!r}' is not a string and conversion is not allowed".format(value)

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)