ansible-core 2.19.0b5__py3-none-any.whl → 2.19.0b7__py3-none-any.whl

ansible_test/_internal/processes.py

@@ -0,0 +1,80 @@
+"""Wrappers around `ps` for querying running processes."""
+
+from __future__ import annotations
+
+import collections
+import dataclasses
+import os
+import pathlib
+import shlex
+
+from ansible_test._internal.util import raw_command
+
+
+@dataclasses.dataclass(frozen=True)
+class ProcessData:
+    """Data about a running process."""
+
+    pid: int
+    ppid: int
+    command: str
+
+
+@dataclasses.dataclass(frozen=True)
+class Process:
+    """A process in the process tree."""
+
+    pid: int
+    command: str
+    parent: Process | None = None
+    children: tuple[Process, ...] = dataclasses.field(default_factory=tuple)
+
+    @property
+    def args(self) -> list[str]:
+        """The list of arguments that make up `command`."""
+        return shlex.split(self.command)
+
+    @property
+    def path(self) -> pathlib.Path:
+        """The path to the process."""
+        return pathlib.Path(self.args[0])
+
+
+def get_process_data(pids: list[int] | None = None) -> list[ProcessData]:
+    """Return a list of running processes."""
+    if pids:
+        args = ['-p', ','.join(map(str, pids))]
+    else:
+        args = ['-A']
+
+    lines = raw_command(['ps'] + args + ['-o', 'pid,ppid,command'], capture=True)[0].splitlines()[1:]
+    processes = [ProcessData(pid=int(pid), ppid=int(ppid), command=command) for pid, ppid, command in (line.split(maxsplit=2) for line in lines)]
+
+    return processes
+
+
+def get_process_tree() -> dict[int, Process]:
+    """Return the process tree."""
+    processes = get_process_data()
+    pid_to_process: dict[int, Process] = {}
+    pid_to_children: dict[int, list[Process]] = collections.defaultdict(list)
+
+    for data in processes:
+        pid_to_process[data.pid] = process = Process(pid=data.pid, command=data.command)
+
+        if data.ppid:
+            pid_to_children[data.ppid].append(process)
+
+    for data in processes:
+        pid_to_process[data.pid] = dataclasses.replace(
+            pid_to_process[data.pid],
+            parent=pid_to_process.get(data.ppid),
+            children=tuple(pid_to_children[data.pid]),
+        )
+
+    return pid_to_process
+
+
+def get_current_process() -> Process:
+    """Return the current process along with its ancestors and descendants."""
+    return get_process_tree()[os.getpid()]

ansible_test/_internal/provisioning.py

@@ -116,9 +116,11 @@ def prepare_profiles(
     else:
         run_pypi_proxy(args, targets_use_pypi)
 
+        controller_host_profile = t.cast(ControllerHostProfile, create_host_profile(args, args.controller, None))
+
         host_state = HostState(
-            controller_profile=t.cast(ControllerHostProfile, create_host_profile(args, args.controller, True)),
-            target_profiles=[create_host_profile(args, target, False) for target in args.targets],
+            controller_profile=controller_host_profile,
+            target_profiles=[create_host_profile(args, target, controller_host_profile) for target in args.targets],
         )
 
         if args.prime_containers:
@@ -137,7 +139,9 @@ def prepare_profiles(
             if not skip_setup:
                 profile.setup()
 
-        dispatch_jobs([(profile, WrappedThread(functools.partial(provision, profile))) for profile in host_state.profiles])
+        dispatch_jobs(
+            [(profile, WrappedThread(functools.partial(provision, profile), f'Provision: {profile}')) for profile in host_state.profiles]
+        )
 
         host_state.controller_profile.configure()
 
@@ -157,7 +161,9 @@ def prepare_profiles(
             if requirements:
                 requirements(profile)
 
-        dispatch_jobs([(profile, WrappedThread(functools.partial(configure, profile))) for profile in host_state.target_profiles])
+        dispatch_jobs(
+            [(profile, WrappedThread(functools.partial(configure, profile), f'Configure: {profile}')) for profile in host_state.target_profiles]
+        )
 
     return host_state
 

ansible_test/_internal/python_requirements.py

@@ -55,6 +55,11 @@ from .coverage_util import (
     get_coverage_version,
 )
 
+if t.TYPE_CHECKING:
+    from .host_profiles import (
+        HostProfile,
+    )
+
 QUIET_PIP_SCRIPT_PATH = os.path.join(ANSIBLE_TEST_TARGET_ROOT, 'setup', 'quiet_pip.py')
 REQUIREMENTS_SCRIPT_PATH = os.path.join(ANSIBLE_TEST_TARGET_ROOT, 'setup', 'requirements.py')
 
@@ -122,6 +127,7 @@ class PipBootstrap(PipCommand):
 
 def install_requirements(
     args: EnvironmentConfig,
+    host_profile: HostProfile | None,
     python: PythonConfig,
     ansible: bool = False,
     command: bool = False,
@@ -133,6 +139,7 @@ def install_requirements(
     create_result_directories(args)
 
     if not requirements_allowed(args, controller):
+        post_install(host_profile)
         return
 
     if command and isinstance(args, (UnitsConfig, IntegrationConfig)) and args.coverage:
@@ -161,7 +168,17 @@ def install_requirements(
         sanity=None,
     )
 
+    from .host_profiles import DebuggableProfile
+
+    if isinstance(host_profile, DebuggableProfile) and host_profile.debugging_enabled and args.metadata.debugger_settings.package:
+        commands.append(PipInstall(
+            requirements=[],
+            constraints=[],
+            packages=[args.metadata.debugger_settings.package],
+        ))
+
     if not commands:
+        post_install(host_profile)
         return
 
     run_pip(args, python, commands, connection)
@@ -170,6 +187,16 @@ def install_requirements(
     if any(isinstance(command, PipInstall) and command.has_package('pyyaml') for command in commands):
         check_pyyaml(python)
 
+    post_install(host_profile)
+
+
+def post_install(host_profile: HostProfile) -> None:
+    """Operations to perform after requirements are installed."""
+    from .host_profiles import DebuggableProfile
+
+    if isinstance(host_profile, DebuggableProfile):
+        host_profile.activate_debugger()
+
 
 def collect_bootstrap(python: PythonConfig) -> list[PipCommand]:
     """Return the details necessary to bootstrap pip into an empty virtual environment."""

ansible_test/_internal/ssh.py

@@ -13,7 +13,6 @@ import shlex
 import typing as t
 
 from .encoding import (
-    to_bytes,
     to_text,
 )
 
@@ -223,13 +222,10 @@ def run_ssh_command(
     cmd_show = shlex.join(cmd)
     display.info('Run background command: %s' % cmd_show, verbosity=1, truncate=True)
 
-    cmd_bytes = [to_bytes(arg) for arg in cmd]
-    env_bytes = dict((to_bytes(k), to_bytes(v)) for k, v in env.items())
-
     if args.explain:
         process = SshProcess(None)
     else:
-        process = SshProcess(subprocess.Popen(cmd_bytes, env=env_bytes, bufsize=-1,  # pylint: disable=consider-using-with
+        process = SshProcess(subprocess.Popen(cmd, env=env, bufsize=-1,  # pylint: disable=consider-using-with
                                               stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE))
 
     return process

ansible_test/_internal/target.py

@@ -582,6 +582,14 @@ class IntegrationTarget(CompletionTarget):
         else:
             static_aliases = tuple()
 
+        # non-group aliases which need to be extracted before group mangling occurs
+
+        self.env_set: dict[str, str] = {
+            match.group('key'): match.group('value') for match in (
+                re.match(r'env/set/(?P<key>[^/]+)/(?P<value>.*)', alias) for alias in static_aliases
+            ) if match
+        }
+
         # modules
 
         if self.name in modules:

ansible_test/_internal/thread.py

@@ -17,11 +17,12 @@ TCallable = t.TypeVar('TCallable', bound=t.Callable[..., t.Any])
 class WrappedThread(threading.Thread):
     """Wrapper around Thread which captures results and exceptions."""
 
-    def __init__(self, action: c.Callable[[], t.Any]) -> None:
+    def __init__(self, action: c.Callable[[], t.Any], name: str) -> None:
         super().__init__()
         self._result: queue.Queue[t.Any] = queue.Queue()
         self.action = action
         self.result = None
+        self.name = name
 
     def run(self) -> None:
         """

ansible_test/_internal/timeout.py

@@ -126,6 +126,6 @@ def configure_test_timeout(args: TestConfig) -> None:
 
     signal.signal(signal.SIGUSR1, timeout_handler)
 
-    instance = WrappedThread(functools.partial(timeout_waiter, timeout_remaining.total_seconds()))
+    instance = WrappedThread(functools.partial(timeout_waiter, timeout_remaining.total_seconds()), 'Timeout Watchdog')
     instance.daemon = True
     instance.start()

ansible_test/_internal/util.py

@@ -533,16 +533,23 @@ def raw_command(
 
     try:
         try:
-            cmd_bytes = [to_bytes(arg) for arg in cmd]
-            env_bytes = dict((to_bytes(k), to_bytes(v)) for k, v in env.items())
-            process = subprocess.Popen(cmd_bytes, env=env_bytes, stdin=stdin, stdout=stdout, stderr=stderr, cwd=cwd)  # pylint: disable=consider-using-with
+            process = subprocess.Popen(cmd, env=env, stdin=stdin, stdout=stdout, stderr=stderr, cwd=cwd)  # pylint: disable=consider-using-with
         except FileNotFoundError as ex:
             raise ApplicationError('Required program "%s" not found.' % cmd[0]) from ex
 
         if communicate:
             data_bytes = to_optional_bytes(data)
-            stdout_bytes, stderr_bytes = communicate_with_process(process, data_bytes, stdout == subprocess.PIPE, stderr == subprocess.PIPE, capture=capture,
-                                                                  output_stream=output_stream)
+
+            stdout_bytes, stderr_bytes = communicate_with_process(
+                name=cmd[0],
+                process=process,
+                stdin=data_bytes,
+                stdout=stdout == subprocess.PIPE,
+                stderr=stderr == subprocess.PIPE,
+                capture=capture,
+                output_stream=output_stream,
+            )
+
             stdout_text = to_optional_text(stdout_bytes, str_errors) or ''
             stderr_text = to_optional_text(stderr_bytes, str_errors) or ''
         else:
@@ -566,6 +573,7 @@ def raw_command(
 
 
 def communicate_with_process(
+    name: str,
     process: subprocess.Popen,
     stdin: t.Optional[bytes],
     stdout: bool,
@@ -583,16 +591,16 @@ def communicate_with_process(
         reader = OutputThread
 
     if stdin is not None:
-        threads.append(WriterThread(process.stdin, stdin))
+        threads.append(WriterThread(process.stdin, stdin, name))
 
     if stdout:
-        stdout_reader = reader(process.stdout, output_stream.get_buffer(sys.stdout.buffer))
+        stdout_reader = reader(process.stdout, output_stream.get_buffer(sys.stdout.buffer), name)
         threads.append(stdout_reader)
     else:
         stdout_reader = None
 
     if stderr:
-        stderr_reader = reader(process.stderr, output_stream.get_buffer(sys.stderr.buffer))
+        stderr_reader = reader(process.stderr, output_stream.get_buffer(sys.stderr.buffer), name)
         threads.append(stderr_reader)
     else:
         stderr_reader = None
@@ -624,8 +632,8 @@ def communicate_with_process(
 class WriterThread(WrappedThread):
     """Thread to write data to stdin of a subprocess."""
 
-    def __init__(self, handle: t.IO[bytes], data: bytes) -> None:
-        super().__init__(self._run)
+    def __init__(self, handle: t.IO[bytes], data: bytes, name: str) -> None:
+        super().__init__(self._run, f'{self.__class__.__name__}: {name}')
 
         self.handle = handle
         self.data = data
@@ -642,8 +650,8 @@ class WriterThread(WrappedThread):
 class ReaderThread(WrappedThread, metaclass=abc.ABCMeta):
     """Thread to read stdout from a subprocess."""
 
-    def __init__(self, handle: t.IO[bytes], buffer: t.BinaryIO) -> None:
-        super().__init__(self._run)
+    def __init__(self, handle: t.IO[bytes], buffer: t.BinaryIO, name: str) -> None:
+        super().__init__(self._run, f'{self.__class__.__name__}: {name}')
 
         self.handle = handle
         self.buffer = buffer

ansible_test/_internal/util_common.py

@@ -451,10 +451,20 @@ def intercept_python(
     """
     Run a command while intercepting invocations of Python to control the version used.
     If the specified Python is an ansible-test managed virtual environment, it will be added to PATH to activate it.
-    Otherwise a temporary directory will be created to ensure the correct Python can be found in PATH.
+    Otherwise, a temporary directory will be created to ensure the correct Python can be found in PATH.
     """
-    env = env.copy()
     cmd = list(cmd)
+    env = get_injector_env(python, env)
+
+    return run_command(args, cmd, capture=capture, env=env, data=data, cwd=cwd, always=always)
+
+
+def get_injector_env(
+    python: PythonConfig,
+    env: dict[str, str],
+) -> dict[str, str]:
+    """Get the environment variables needed to inject the given Python interpreter into the environment."""
+    env = env.copy()
     inject_path = get_injector_path()
 
     # make sure scripts (including injector.py) find the correct Python interpreter
@@ -467,7 +477,7 @@ def intercept_python(
     env['ANSIBLE_TEST_PYTHON_VERSION'] = python.version
     env['ANSIBLE_TEST_PYTHON_INTERPRETER'] = python.path
 
-    return run_command(args, cmd, capture=capture, env=env, data=data, cwd=cwd, always=always)
+    return env
 
 
 def run_command(

ansible_test/_util/target/injector/python.py

@@ -15,6 +15,7 @@ def main():
     args = [sys.executable]
 
     ansible_lib_root = os.environ.get('ANSIBLE_TEST_ANSIBLE_LIB_ROOT')
+    debugger_config = os.environ.get('ANSIBLE_TEST_DEBUGGER_CONFIG')
     coverage_config = os.environ.get('COVERAGE_CONF')
     coverage_output = os.environ.get('COVERAGE_FILE')
 
@@ -28,6 +29,13 @@ def main():
                 sys.exit('ERROR: Could not find `coverage` module. '
                          'Did you use a virtualenv created without --system-site-packages or with the wrong interpreter?')
 
+    if debugger_config:
+        import json
+
+        debugger_options = json.loads(debugger_config)
+        os.environ.update(debugger_options['env'])
+        args += debugger_options['args']
+
     if name == 'python.py':
         if sys.argv[1] == '-c':
             # prevent simple misuse of python.py with -c which does not work with coverage

ansible_test/_util/target/setup/requirements.py

@@ -19,7 +19,6 @@ if DESIRED_RLIMIT_NOFILE < CURRENT_RLIMIT_NOFILE:
 
 import base64
 import contextlib
-import errno
 import io
 import json
 import os
@@ -349,18 +348,13 @@ def remove_tree(path):  # type: (str) -> None
     """Remove the specified directory tree."""
     try:
         shutil.rmtree(to_bytes(path))
-    except OSError as ex:
-        if ex.errno != errno.ENOENT:
-            raise
+    except FileNotFoundError:
+        pass
 
 
 def make_dirs(path):  # type: (str) -> None
     """Create a directory at path, including any necessary parent directories."""
-    try:
-        os.makedirs(to_bytes(path))
-    except OSError as ex:
-        if ex.errno != errno.EEXIST:
-            raise
+    os.makedirs(to_bytes(path), exist_ok=True)
 
 
 def open_binary_file(path, mode='rb'):  # type: (str, str) -> t.IO[bytes]