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

ansible/cli/_ssh_askpass.py

@@ -0,0 +1,54 @@
+# Copyright: Contributors to the Ansible project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+from __future__ import annotations
+
+import json
+import multiprocessing.resource_tracker
+import os
+import re
+import sys
+import typing as t
+
+from multiprocessing.shared_memory import SharedMemory
+
+
+def main() -> t.Never:
+    if len(sys.argv) > 1:
+        exit_code = 0 if handle_prompt(sys.argv[1]) else 1
+    else:
+        exit_code = 1
+
+    sys.exit(exit_code)
+
+
+def handle_prompt(prompt: str) -> bool:
+    if re.search(r'(The authenticity of host |differs from the key for the IP address)', prompt):
+        sys.stdout.write('no')
+        sys.stdout.flush()
+        return True
+
+    # deprecated: description='Python 3.13 and later support track' python_version='3.12'
+    can_track = sys.version_info[:2] >= (3, 13)
+    kwargs = dict(track=False) if can_track else {}
+
+    # This SharedMemory instance is intentionally not closed or unlinked.
+    # Closing will occur naturally in the SharedMemory finalizer.
+    # Unlinking is the responsibility of the process which created it.
+    shm = SharedMemory(name=os.environ['_ANSIBLE_SSH_ASKPASS_SHM'], **kwargs)
+
+    if not can_track:
+        # When track=False is not available, we must unregister explicitly, since it otherwise only occurs during unlink.
+        # This avoids resource tracker noise on stderr during process exit.
+        multiprocessing.resource_tracker.unregister(shm._name, 'shared_memory')
+
+    cfg = json.loads(shm.buf.tobytes().rstrip(b'\x00'))
+
+    if cfg['prompt'] not in prompt:
+        return False
+
+    # Report the password provided by the SharedMemory instance.
+    # The contents are left untouched after consumption to allow subsequent attempts to succeed.
+    # This can occur when multiple password prompting methods are enabled, such as password and keyboard-interactive, which is the default on macOS.
+    sys.stdout.write(cfg['password'])
+    sys.stdout.flush()
+    return True

ansible/cli/adhoc.py

@@ -6,6 +6,8 @@
 
 from __future__ import annotations
 
+import json
+
 # ansible.cli needs to be imported first, to ensure the source bin/* scripts run that code first
 from ansible.cli import CLI
 from ansible import constants as C
@@ -15,23 +17,26 @@ from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleParserError
 from ansible.executor.task_queue_manager import TaskQueueManager
 from ansible.module_utils.common.text.converters import to_text
 from ansible.parsing.splitter import parse_kv
-from ansible.parsing.utils.yaml import from_yaml
 from ansible.playbook import Playbook
 from ansible.playbook.play import Play
+from ansible._internal._datatag._tags import Origin
 from ansible.utils.display import Display
+from ansible._internal._json._profiles import _legacy
 
 display = Display()
 
 
 class AdHocCLI(CLI):
-    ''' is an extra-simple tool/framework/API for doing 'remote things'.
+    """ is an extra-simple tool/framework/API for doing 'remote things'.
         this command allows you to define and run a single task 'playbook' against a set of hosts
-    '''
+    """
 
     name = 'ansible'
 
+    USES_CONNECTION = True
+
     def init_parser(self):
-        ''' create an options parser for bin/ansible '''
+        """ create an options parser for bin/ansible """
         super(AdHocCLI, self).init_parser(usage='%prog <host-pattern> [options]',
                                           desc="Define and run a single task 'playbook' against a set of hosts",
                                           epilog="Some actions do not make sense in Ad-Hoc (include, meta, etc)")
@@ -60,7 +65,7 @@ class AdHocCLI(CLI):
         self.parser.add_argument('args', metavar='pattern', help='host pattern')
 
     def post_process_args(self, options):
-        '''Post process and validate options for bin/ansible '''
+        """Post process and validate options for bin/ansible """
 
         options = super(AdHocCLI, self).post_process_args(options)
 
@@ -76,15 +81,20 @@ class AdHocCLI(CLI):
         module_args = None
         if module_args_raw and module_args_raw.startswith('{') and module_args_raw.endswith('}'):
             try:
-                module_args = from_yaml(module_args_raw.strip(), json_only=True)
+                module_args = json.loads(module_args_raw, cls=_legacy.Decoder)
             except AnsibleParserError:
                 pass
 
         if not module_args:
             module_args = parse_kv(module_args_raw, check_raw=check_raw)
 
-        mytask = {'action': {'module': context.CLIARGS['module_name'], 'args': module_args},
-                  'timeout': context.CLIARGS['task_timeout']}
+        mytask = dict(
+            action=context.CLIARGS['module_name'],
+            args=module_args,
+            timeout=context.CLIARGS['task_timeout'],
+        )
+
+        mytask = Origin(description=f'<adhoc {context.CLIARGS["module_name"]!r} task>').tag(mytask)
 
         # avoid adding to tasks that don't support it, unless set, then give user an error
         if context.CLIARGS['module_name'] not in C._ACTION_ALL_INCLUDE_ROLE_TASKS and any(frozenset((async_val, poll))):
@@ -98,7 +108,7 @@ class AdHocCLI(CLI):
             tasks=[mytask])
 
     def run(self):
-        ''' create and execute the single task playbook '''
+        """ create and execute the single task playbook """
 
         super(AdHocCLI, self).run()
 
@@ -177,7 +187,7 @@ class AdHocCLI(CLI):
                 variable_manager=variable_manager,
                 loader=loader,
                 passwords=passwords,
-                stdout_callback=cb,
+                stdout_callback_name=cb,
                 run_additional_callbacks=C.DEFAULT_LOAD_CALLBACK_PLUGINS,
                 run_tree=run_tree,
                 forks=context.CLIARGS['forks'],

ansible/cli/arguments/option_helpers.py

@@ -4,22 +4,28 @@
 from __future__ import annotations
 
 import copy
+import dataclasses
+import inspect
 import operator
 import argparse
 import os
 import os.path
 import sys
 import time
+import typing as t
 
-from jinja2 import __version__ as j2_version
+import yaml
 
 import ansible
 from ansible import constants as C
+from ansible._internal import _templating
 from ansible.module_utils.common.text.converters import to_native
 from ansible.module_utils.common.yaml import HAS_LIBYAML, yaml_load
 from ansible.release import __version__
 from ansible.utils.path import unfrackpath
 
+from ansible._internal._datatag._tags import TrustedAsTemplate, Origin
+
 
 #
 # Special purpose OptionParsers
@@ -30,13 +36,118 @@ class SortingHelpFormatter(argparse.HelpFormatter):
         super(SortingHelpFormatter, self).add_arguments(actions)
 
 
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class DeprecatedArgument:
+    version: str
+    """The Ansible version that will remove the deprecated argument."""
+
+    option: str | None = None
+    """The specific option string that is deprecated; None applies to all options for this argument."""
+
+    def is_deprecated(self, option: str) -> bool:
+        """Return True if the given option is deprecated, otherwise False."""
+        return self.option is None or option == self.option
+
+    def check(self, option: str) -> None:
+        """Display a deprecation warning if the given option is deprecated."""
+        if not self.is_deprecated(option):
+            return
+
+        from ansible.utils.display import Display
+
+        Display().deprecated(  # pylint: disable=ansible-invalid-deprecated-version
+            msg=f'The {option!r} argument is deprecated.',
+            version=self.version,
+        )
+
+
 class ArgumentParser(argparse.ArgumentParser):
-    def add_argument(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
+        self.__actions: dict[str | None, type[argparse.Action]] = {}
+
+        super().__init__(*args, **kwargs)
+
+    def register(self, registry_name, value, object):
+        """Track registration of actions so that they can be resolved later by name, without depending on the internals of ArgumentParser."""
+        if registry_name == 'action':
+            self.__actions[value] = object
+
+        super().register(registry_name, value, object)
+
+    def _patch_argument(self, args: tuple[str, ...], kwargs: dict[str, t.Any]) -> None:
+        """
+        Patch `kwargs` for an `add_argument` call using the given `args` and `kwargs`.
+        This is used to apply tags to entire categories of CLI arguments.
+        """
+        name = args[0]
+        action = kwargs.get('action')
+        resolved_action = self.__actions.get(action, action)  # get the action by name, or use as-is (assume it's a subclass of argparse.Action)
+        action_signature = inspect.signature(resolved_action.__init__)
+
+        if action_signature.parameters.get('type'):
+            arg_type = kwargs.get('type', str)
+
+            if not callable(arg_type):
+                raise ValueError(f'Argument {name!r} requires a callable for the {"type"!r} parameter, not {arg_type!r}.')
+
+            wrapped_arg_type = _tagged_type_factory(name, arg_type)
+
+            kwargs.update(type=wrapped_arg_type)
+
+    def _patch_parser(self, parser):
+        """Patch and return the given parser to intercept the `add_argument` method for further patching."""
+        parser_add_argument = parser.add_argument
+
+        def add_argument(*ag_args, **ag_kwargs):
+            self._patch_argument(ag_args, ag_kwargs)
+
+            parser_add_argument(*ag_args, **ag_kwargs)
+
+        parser.add_argument = add_argument
+
+        return parser
+
+    def add_subparsers(self, *args, **kwargs):
+        sub = super().add_subparsers(*args, **kwargs)
+        sub_add_parser = sub.add_parser
+
+        def add_parser(*sub_args, **sub_kwargs):
+            return self._patch_parser(sub_add_parser(*sub_args, **sub_kwargs))
+
+        sub.add_parser = add_parser
+
+        return sub
+
+    def add_argument_group(self, *args, **kwargs):
+        return self._patch_parser(super().add_argument_group(*args, **kwargs))
+
+    def add_mutually_exclusive_group(self, *args, **kwargs):
+        return self._patch_parser(super().add_mutually_exclusive_group(*args, **kwargs))
+
+    def add_argument(self, *args, **kwargs) -> argparse.Action:
         action = kwargs.get('action')
         help = kwargs.get('help')
         if help and action in {'append', 'append_const', 'count', 'extend', PrependListAction}:
             help = f'{help.rstrip(".")}. This argument may be specified multiple times.'
         kwargs['help'] = help
+
+        self._patch_argument(args, kwargs)
+
+        deprecated: DeprecatedArgument | None
+
+        if deprecated := kwargs.pop('deprecated', None):
+            action_type = self.__actions.get(action, action)
+
+            class DeprecatedAction(action_type):  # type: ignore[misc, valid-type]
+                """A wrapper around an action which handles deprecation warnings."""
+
+                def __call__(self, parser, namespace, values, option_string=None) -> t.Any:
+                    deprecated.check(option_string)
+
+                    return super().__call__(parser, namespace, values, option_string)
+
+            kwargs['action'] = DeprecatedAction
+
         return super().add_argument(*args, **kwargs)
 
 
@@ -132,7 +243,7 @@ def _git_repo_info(repo_path):
                     repo_path = gitdir
                 else:
                     repo_path = os.path.join(repo_path[:-4], gitdir)
-            except (IOError, AttributeError):
+            except (OSError, AttributeError):
                 return ''
         with open(os.path.join(repo_path, "HEAD")) as f:
             line = f.readline().rstrip("\n")
@@ -182,13 +293,28 @@ def version(prog=None):
         cpath = "Default w/o overrides"
     else:
         cpath = C.DEFAULT_MODULE_PATH
+
+    if HAS_LIBYAML:
+        libyaml_fragment = "with libyaml"
+
+        # noinspection PyBroadException
+        try:
+            from yaml._yaml import get_version_string
+
+            libyaml_fragment += f" v{get_version_string()}"
+        except Exception:  # pylint: disable=broad-except
+            libyaml_fragment += ", version unknown"
+    else:
+        libyaml_fragment = "without libyaml"
+
     result.append("  configured module search path = %s" % cpath)
     result.append("  ansible python module location = %s" % ':'.join(ansible.__path__))
     result.append("  ansible collection location = %s" % ':'.join(C.COLLECTIONS_PATHS))
     result.append("  executable location = %s" % sys.argv[0])
     result.append("  python version = %s (%s)" % (''.join(sys.version.splitlines()), to_native(sys.executable)))
-    result.append("  jinja version = %s" % j2_version)
-    result.append("  libyaml = %s" % HAS_LIBYAML)
+    result.append(f"  jinja version = {_templating.jinja2_version}")
+    result.append(f"  pyyaml version = {yaml.__version__} ({libyaml_fragment})")
+
     return "\n".join(result)
 
 
@@ -292,19 +418,20 @@ def add_fork_options(parser):
 def add_inventory_options(parser):
     """Add options for commands that utilize inventory"""
     parser.add_argument('-i', '--inventory', '--inventory-file', dest='inventory', action="append",
-                        help="specify inventory host path or comma separated host list. --inventory-file is deprecated")
+                        help="specify inventory host path or comma separated host list",
+                        deprecated=DeprecatedArgument(version='2.23', option='--inventory-file'))
     parser.add_argument('--list-hosts', dest='listhosts', action='store_true',
                         help='outputs a list of matching hosts; does not execute anything else')
     parser.add_argument('-l', '--limit', default=C.DEFAULT_SUBSET, dest='subset',
                         help='further limit selected hosts to an additional pattern')
+    parser.add_argument('--flush-cache', dest='flush_cache', action='store_true',
+                        help="clear the fact cache for every host in inventory")
 
 
 def add_meta_options(parser):
     """Add options for commands which can launch meta tasks from the command line"""
     parser.add_argument('--force-handlers', default=C.DEFAULT_FORCE_HANDLERS, dest='force_handlers', action='store_true',
                         help="run handlers even if a task fails")
-    parser.add_argument('--flush-cache', dest='flush_cache', action='store_true',
-                        help="clear the fact cache for every host in inventory")
 
 
 def add_module_options(parser):
@@ -318,9 +445,9 @@ def add_module_options(parser):
 def add_output_options(parser):
     """Add options for commands which can change their output"""
     parser.add_argument('-o', '--one-line', dest='one_line', action='store_true',
-                        help='condense output')
+                        help='condense output', deprecated=DeprecatedArgument(version='2.23'))
     parser.add_argument('-t', '--tree', dest='tree', default=None,
-                        help='log output to this directory')
+                        help='log output to this directory', deprecated=DeprecatedArgument(version='2.23'))
 
 
 def add_runas_options(parser):
@@ -396,3 +523,29 @@ def add_vault_options(parser):
                             help='ask for vault password')
     base_group.add_argument('--vault-password-file', '--vault-pass-file', default=[], dest='vault_password_files',
                             help="vault password file", type=unfrack_path(follow=False), action='append')
+
+
+def _tagged_type_factory(name: str, func: t.Callable[[str], object], /) -> t.Callable[[str], object]:
+    """
+    Return a callable that wraps the given function.
+    The result of the wrapped function will be tagged with Origin.
+    It will also be tagged with TrustedAsTemplate if it is equal to the original input string.
+    """
+    def tag_value(value: str) -> object:
+        result = func(value)
+
+        if result is value or func is str:
+            # Values which are not mutated are automatically trusted for templating.
+            # The `is` reference equality is critically important, as other types may only alter the tags, so object equality is
+            # not sufficient to prevent them being tagged as trusted when they should not.
+            # Explicitly include all usages using the `str` type factory since it strips tags.
+            result = TrustedAsTemplate().tag(result)
+
+        if not (origin := Origin.get_tag(value)):
+            origin = Origin(description=f'<CLI option {name!r}>')
+
+        return origin.tag(result)
+
+    tag_value._name = name  # simplify debugging by attaching the argument name to the function
+
+    return tag_value

ansible/cli/config.py

@@ -10,7 +10,6 @@ from ansible.cli import CLI
 
 import os
 import shlex
-import subprocess
 import sys
 import yaml
 
@@ -21,10 +20,10 @@ import ansible.plugins.loader as plugin_loader
 
 from ansible import constants as C
 from ansible.cli.arguments import option_helpers as opt_help
-from ansible.config.manager import ConfigManager, Setting
+from ansible.config.manager import ConfigManager
 from ansible.errors import AnsibleError, AnsibleOptionsError, AnsibleRequiredOptionError
 from ansible.module_utils.common.text.converters import to_native, to_text, to_bytes
-from ansible.module_utils.common.json import json_dump
+from ansible._internal import _json
 from ansible.module_utils.six import string_types
 from ansible.parsing.quoting import is_quoted
 from ansible.parsing.yaml.dumper import AnsibleDumper
@@ -47,14 +46,14 @@ def yaml_short(data):
 
 
 def get_constants():
-    ''' helper method to ensure we can template based on existing constants '''
+    """ helper method to ensure we can template based on existing constants """
     if not hasattr(get_constants, 'cvars'):
         get_constants.cvars = {k: getattr(C, k) for k in dir(C) if not k.startswith('__')}
     return get_constants.cvars
 
 
 def _ansible_env_vars(varname):
-    ''' return true or false depending if variable name is possibly a 'configurable' ansible env variable '''
+    """ return true or false depending if variable name is possibly a 'configurable' ansible env variable """
     return all(
         [
             varname.startswith("ANSIBLE_"),
@@ -178,8 +177,6 @@ class ConfigCLI(CLI):
             except Exception:
                 if context.CLIARGS['action'] in ['view']:
                     raise
-                elif context.CLIARGS['action'] in ['edit', 'update']:
-                    display.warning("File does not exist, used empty file: %s" % self.config_file)
 
         elif context.CLIARGS['action'] == 'view':
             raise AnsibleError('Invalid or no config file was supplied')
@@ -187,54 +184,16 @@ class ConfigCLI(CLI):
         # run the requested action
         context.CLIARGS['func']()
 
-    def execute_update(self):
-        '''
-        Updates a single setting in the specified ansible.cfg
-        '''
-        raise AnsibleError("Option not implemented yet")
-
-        # pylint: disable=unreachable
-        if context.CLIARGS['setting'] is None:
-            raise AnsibleOptionsError("update option requires a setting to update")
-
-        (entry, value) = context.CLIARGS['setting'].split('=')
-        if '.' in entry:
-            (section, option) = entry.split('.')
-        else:
-            section = 'defaults'
-            option = entry
-        subprocess.call([
-            'ansible',
-            '-m', 'ini_file',
-            'localhost',
-            '-c', 'local',
-            '-a', '"dest=%s section=%s option=%s value=%s backup=yes"' % (self.config_file, section, option, value)
-        ])
-
     def execute_view(self):
-        '''
+        """
         Displays the current config file
-        '''
+        """
         try:
             with open(self.config_file, 'rb') as f:
                 self.pager(to_text(f.read(), errors='surrogate_or_strict'))
         except Exception as e:
             raise AnsibleError("Failed to open config file: %s" % to_native(e))
 
-    def execute_edit(self):
-        '''
-        Opens ansible.cfg in the default EDITOR
-        '''
-        raise AnsibleError("Option not implemented yet")
-
-        # pylint: disable=unreachable
-        try:
-            editor = shlex.split(C.config.get_config_value('EDITOR'))
-            editor.append(self.config_file)
-            subprocess.call(editor)
-        except Exception as e:
-            raise AnsibleError("Failed to open editor: %s" % to_native(e))
-
     def _list_plugin_settings(self, ptype, plugins=None):
         entries = {}
         loader = getattr(plugin_loader, '%s_loader' % ptype)
@@ -266,9 +225,9 @@ class ConfigCLI(CLI):
         return entries
 
     def _list_entries_from_args(self):
-        '''
+        """
         build a dict with the list requested configs
-        '''
+        """
 
         config_entries = {}
         if context.CLIARGS['type'] in ('base', 'all'):
@@ -294,15 +253,15 @@ class ConfigCLI(CLI):
         return config_entries
 
     def execute_list(self):
-        '''
+        """
         list and output available configs
-        '''
+        """
 
         config_entries = self._list_entries_from_args()
         if context.CLIARGS['format'] == 'yaml':
             output = yaml_dump(config_entries)
         elif context.CLIARGS['format'] == 'json':
-            output = json_dump(config_entries)
+            output = _json.json_dumps_formatted(config_entries)
 
         self.pager(to_text(output, errors='surrogate_or_strict'))
 
@@ -458,21 +417,21 @@ class ConfigCLI(CLI):
 
         entries = []
         for setting in sorted(config):
-            changed = (config[setting].origin not in ('default', 'REQUIRED') and setting not in _IGNORE_CHANGED)
+            changed = (config[setting]['origin'] not in ('default', 'REQUIRED') and setting not in _IGNORE_CHANGED)
 
             if context.CLIARGS['format'] == 'display':
-                if isinstance(config[setting], Setting):
+                if isinstance(config[setting], dict):
                     # proceed normally
-                    value = config[setting].value
-                    if config[setting].origin == 'default' or setting in _IGNORE_CHANGED:
+                    value = config[setting]['value']
+                    if config[setting]['origin'] == 'default' or setting in _IGNORE_CHANGED:
                         color = 'green'
                         value = self.config.template_default(value, get_constants())
-                    elif config[setting].origin == 'REQUIRED':
+                    elif config[setting]['origin'] == 'REQUIRED':
                         # should include '_terms', '_input', etc
                         color = 'red'
                     else:
                         color = 'yellow'
-                    msg = "%s(%s) = %s" % (setting, config[setting].origin, value)
+                    msg = "%s(%s) = %s" % (setting, config[setting]['origin'], value)
                 else:
                     color = 'green'
                     msg = "%s(%s) = %s" % (setting, 'default', config[setting].get('default'))
@@ -480,10 +439,10 @@ class ConfigCLI(CLI):
                 entry = stringc(msg, color)
             else:
                 entry = {}
-                for key in config[setting]._fields:
+                for key in config[setting].keys():
                     if key == 'type':
                         continue
-                    entry[key] = getattr(config[setting], key)
+                    entry[key] = config[setting][key]
 
             if not context.CLIARGS['only_changed'] or changed:
                 entries.append(entry)
@@ -495,11 +454,17 @@ class ConfigCLI(CLI):
         # Add base
         config = self.config.get_configuration_definitions(ignore_private=True)
         # convert to settings
+        settings = {}
         for setting in config.keys():
             v, o = C.config.get_config_value_and_origin(setting, cfile=self.config_file, variables=get_constants())
-            config[setting] = Setting(setting, v, o, None)
+            settings[setting] = {
+                'name': setting,
+                'value': v,
+                'origin': o,
+                'type': None
+            }
 
-        return self._render_settings(config)
+        return self._render_settings(settings)
 
     def _get_plugin_configs(self, ptype, plugins):
 
@@ -554,7 +519,12 @@ class ConfigCLI(CLI):
                     # not all cases will be error
                     o = 'REQUIRED'
 
-                config_entries[finalname][setting] = Setting(setting, v, o, None)
+                config_entries[finalname][setting] = {
+                    'name': setting,
+                    'value': v,
+                    'origin': o,
+                    'type': None
+                }
 
             # pretty please!
             results = self._render_settings(config_entries[finalname])
@@ -587,7 +557,12 @@ class ConfigCLI(CLI):
                 if v is None and o is None:
                     # not all cases will be error
                     o = 'REQUIRED'
-                server_config[setting] = Setting(setting, v, o, None)
+                server_config[setting] = {
+                    'name': setting,
+                    'value': v,
+                    'origin': o,
+                    'type': None
+                }
             if context.CLIARGS['format'] == 'display':
                 if not context.CLIARGS['only_changed'] or server_config:
                     equals = '=' * len(server)
@@ -599,9 +574,9 @@ class ConfigCLI(CLI):
         return output
 
     def execute_dump(self):
-        '''
+        """
         Shows the current settings, merges ansible.cfg if specified
-        '''
+        """
         output = []
         if context.CLIARGS['type'] in ('base', 'all'):
             # deal with base
@@ -617,7 +592,7 @@ class ConfigCLI(CLI):
                 for server_config in server_config_list:
                     server = list(server_config.keys())[0]
                     server_reduced_config = server_config.pop(server)
-                    configs[server] = server_reduced_config
+                    configs[server] = list(server_reduced_config.values())
                 output.append({'GALAXY_SERVERS': configs})
 
         if context.CLIARGS['type'] == 'all':
@@ -644,7 +619,7 @@ class ConfigCLI(CLI):
         if context.CLIARGS['format'] == 'yaml':
             text = yaml_dump(output)
         elif context.CLIARGS['format'] == 'json':
-            text = json_dump(output)
+            text = _json.json_dumps_formatted(output)
 
         self.pager(to_text(text, errors='surrogate_or_strict'))