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

ansible/_internal/_plugins/_cache.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import functools
+import json
+import json.encoder
+import json.decoder
+import typing as t
+
+from .._wrapt import ObjectProxy
+from .._json._profiles import _cache_persistence
+
+
+class PluginInterposer(ObjectProxy):
+    """Proxies a Cache plugin instance to implement transparent encapsulation of serialized Ansible internal data types."""
+
+    _PAYLOAD_KEY = '__payload__'
+    """The key used to store the serialized payload."""
+
+    def get(self, key: str) -> dict[str, object]:
+        return self._decode(self.__wrapped__.get(self._get_key(key)))
+
+    def set(self, key: str, value: dict[str, object]) -> None:
+        self.__wrapped__.set(self._get_key(key), self._encode(value))
+
+    def keys(self) -> t.Sequence[str]:
+        return [k for k in (self._restore_key(k) for k in self.__wrapped__.keys()) if k is not None]
+
+    def contains(self, key: t.Any) -> bool:
+        return self.__wrapped__.contains(self._get_key(key))
+
+    def delete(self, key: str) -> None:
+        self.__wrapped__.delete(self._get_key(key))
+
+    @classmethod
+    def _restore_key(cls, wrapped_key: str) -> str | None:
+        prefix = cls._get_wrapped_key_prefix()
+
+        if not wrapped_key.startswith(prefix):
+            return None
+
+        return wrapped_key[len(prefix) :]
+
+    @classmethod
+    @functools.cache
+    def _get_wrapped_key_prefix(cls) -> str:
+        return f's{_cache_persistence._Profile.schema_id}_'
+
+    @classmethod
+    def _get_key(cls, key: str) -> str:
+        """Augment the supplied key with a schema identifier to allow for side-by-side caching across incompatible schemas."""
+        return f'{cls._get_wrapped_key_prefix()}{key}'
+
+    def _encode(self, value: dict[str, object]) -> dict[str, object]:
+        return {self._PAYLOAD_KEY: json.dumps(value, cls=_cache_persistence.Encoder)}
+
+    def _decode(self, value: dict[str, t.Any]) -> dict[str, object]:
+        return json.loads(value[self._PAYLOAD_KEY], cls=_cache_persistence.Decoder)

ansible/_internal/_ssh/_agent_launch.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import atexit
+import os
+import subprocess
+
+from ansible import constants as C
+from ansible._internal._errors import _alarm_timeout
+from ansible._internal._ssh._ssh_agent import SshAgentClient
+from ansible.cli import display
+from ansible.errors import AnsibleError
+from ansible.module_utils.common.process import get_bin_path
+
+_SSH_AGENT_STDOUT_READ_TIMEOUT = 5  # seconds
+
+
+def launch_ssh_agent() -> None:
+    """If configured via `SSH_AGENT`, launch an ssh-agent for Ansible's use and/or verify access to an existing one."""
+    try:
+        _launch_ssh_agent()
+    except Exception as ex:
+        raise AnsibleError("Failed to launch ssh agent.") from ex
+
+
+def _launch_ssh_agent() -> None:
+    ssh_agent_cfg = C.config.get_config_value('SSH_AGENT')
+
+    match ssh_agent_cfg:
+        case 'none':
+            display.debug('SSH_AGENT set to none')
+            return
+        case 'auto':
+            try:
+                ssh_agent_bin = get_bin_path(C.config.get_config_value('SSH_AGENT_EXECUTABLE'))
+            except ValueError as e:
+                raise AnsibleError('SSH_AGENT set to auto, but cannot find ssh-agent binary.') from e
+
+            ssh_agent_dir = os.path.join(C.DEFAULT_LOCAL_TMP, 'ssh_agent')
+            os.mkdir(ssh_agent_dir, 0o700)
+            sock = os.path.join(ssh_agent_dir, 'agent.sock')
+            display.vvv('SSH_AGENT: starting...')
+
+            try:
+                p = subprocess.Popen(
+                    [ssh_agent_bin, '-D', '-s', '-a', sock],
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                )
+            except OSError as e:
+                raise AnsibleError('Could not start ssh-agent.') from e
+
+            atexit.register(p.terminate)
+
+            help_text = f'The ssh-agent {ssh_agent_bin!r} might be an incompatible agent.'
+            expected_stdout = 'SSH_AUTH_SOCK'
+
+            try:
+                with _alarm_timeout.AnsibleTimeoutError.alarm_timeout(_SSH_AGENT_STDOUT_READ_TIMEOUT):
+                    stdout = p.stdout.read(len(expected_stdout))
+            except _alarm_timeout.AnsibleTimeoutError as e:
+                display.error_as_warning(
+                    msg=f'Timed out waiting for expected stdout {expected_stdout!r} from ssh-agent.',
+                    exception=e,
+                    help_text=help_text,
+                )
+            else:
+                if stdout != expected_stdout:
+                    display.warning(
+                        msg=f'The ssh-agent output {stdout!r} did not match expected {expected_stdout!r}.',
+                        help_text=help_text,
+                    )
+
+            if p.poll() is not None:
+                raise AnsibleError(
+                    message='The ssh-agent terminated prematurely.',
+                    help_text=f'{help_text}\n\nReturn Code: {p.returncode}\nStandard Error:\n{p.stderr.read()}',
+                )
+
+            display.vvv(f'SSH_AGENT: ssh-agent[{p.pid}] started and bound to {sock}')
+        case _:
+            sock = ssh_agent_cfg
+
+    try:
+        with SshAgentClient(sock) as client:
+            client.list()
+    except Exception as e:
+        raise AnsibleError(f'Could not communicate with ssh-agent using auth sock {sock!r}.') from e
+
+    os.environ['SSH_AUTH_SOCK'] = os.environ['ANSIBLE_SSH_AGENT'] = sock