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

ansible_test/_internal/delegation.py

@@ -113,23 +113,27 @@ def delegate(args: CommonConfig, host_state: HostState, exclude: list[str], requ
     assert isinstance(args, EnvironmentConfig)
 
     with delegation_context(args, host_state):
-        if isinstance(args, TestConfig):
-            args.metadata.ci_provider = get_ci_provider().code
+        args.metadata.ci_provider = get_ci_provider().code
 
-            make_dirs(ResultType.TMP.path)
+        make_dirs(ResultType.TMP.path)
 
-            with tempfile.NamedTemporaryFile(prefix='metadata-', suffix='.json', dir=ResultType.TMP.path) as metadata_fd:
-                args.metadata_path = os.path.join(ResultType.TMP.relative_path, os.path.basename(metadata_fd.name))
-                args.metadata.to_file(args.metadata_path)
-
-                try:
-                    delegate_command(args, host_state, exclude, require)
-                finally:
-                    args.metadata_path = None
-        else:
+        with metadata_context(args):
             delegate_command(args, host_state, exclude, require)
 
 
+@contextlib.contextmanager
+def metadata_context(args: EnvironmentConfig) -> t.Generator[None]:
+    """A context manager which exports delegation metadata."""
+    with tempfile.NamedTemporaryFile(prefix='metadata-', suffix='.json', dir=ResultType.TMP.path) as metadata_fd:
+        args.metadata_path = os.path.join(ResultType.TMP.relative_path, os.path.basename(metadata_fd.name))
+        args.metadata.to_file(args.metadata_path)
+
+        try:
+            yield
+        finally:
+            args.metadata_path = None
+
+
 def delegate_command(args: EnvironmentConfig, host_state: HostState, exclude: list[str], require: list[str]) -> None:
     """Delegate execution based on the provided host state."""
     con = host_state.controller_profile.get_origin_controller_connection()
@@ -189,6 +193,10 @@ def delegate_command(args: EnvironmentConfig, host_state: HostState, exclude: li
             networks = container.get_network_names()
 
             if networks is not None:
+                if args.metadata.debugger_flags.enable:
+                    networks = []
+                    display.warning('Skipping network isolation to enable remote debugging.')
+
                 for network in networks:
                     try:
                         con.disconnect_network(network)
@@ -334,6 +342,7 @@ def filter_options(
         ('--redact', 0, False),
         ('--no-redact', 0, not args.redact),
         ('--host-path', 1, args.host_path),
+        ('--metadata', 1, args.metadata_path),
     ]
 
     if isinstance(args, TestConfig):
@@ -346,7 +355,6 @@ def filter_options(
             ('--ignore-unstaged', 0, False),
             ('--changed-from', 1, False),
             ('--changed-path', 1, False),
-            ('--metadata', 1, args.metadata_path),
             ('--exclude', 1, exclude),
             ('--require', 1, require),
             ('--base-branch', 1, False),

ansible_test/_internal/host_profiles.py

@@ -4,7 +4,10 @@ from __future__ import annotations
 
 import abc
 import dataclasses
+import importlib
+import json
 import os
+import pathlib
 import shlex
 import tempfile
 import time
@@ -58,6 +61,9 @@ from .util import (
     HostConnectionError,
     ANSIBLE_TEST_TARGET_ROOT,
     WINDOWS_CONNECTION_VARIABLES,
+    ANSIBLE_SOURCE_ROOT,
+    ANSIBLE_LIB_ROOT,
+    ANSIBLE_TEST_ROOT,
 )
 
 from .util_common import (
@@ -92,6 +98,8 @@ from .venv import (
 
 from .ssh import (
     SshConnectionDetail,
+    create_ssh_port_forwards,
+    SshProcess,
 )
 
 from .ansible_util import (
@@ -284,6 +292,176 @@ class HostProfile(t.Generic[THostConfig], metaclass=abc.ABCMeta):
         return f'{self.__class__.__name__}: {self.name}'
 
 
+class DebuggableProfile(HostProfile[THostConfig], metaclass=abc.ABCMeta):
+    """Base class for profiles remote debugging."""
+
+    __PYDEVD_PORT_KEY = 'pydevd_port'
+    __DEBUGGING_FORWARDER_KEY = 'debugging_forwarder'
+
+    @property
+    def debugging_enabled(self) -> bool:
+        """Returns `True` if debugging is enabled for this profile, otherwise `False`."""
+        if self.controller:
+            return self.args.metadata.debugger_flags.enable
+
+        return self.args.metadata.debugger_flags.ansiballz
+
+    @property
+    def pydevd_port(self) -> int:
+        """The pydevd port to use."""
+        return self.state.get(self.__PYDEVD_PORT_KEY) or self.origin_pydev_port
+
+    @property
+    def debugging_forwarder(self) -> SshProcess | None:
+        """The SSH forwarding process, if enabled."""
+        return self.cache.get(self.__DEBUGGING_FORWARDER_KEY)
+
+    @debugging_forwarder.setter
+    def debugging_forwarder(self, value: SshProcess) -> None:
+        """The SSH forwarding process, if enabled."""
+        self.cache[self.__DEBUGGING_FORWARDER_KEY] = value
+
+    @property
+    def origin_pydev_port(self) -> int:
+        """The pydevd port on the origin."""
+        return self.args.metadata.debugger_settings.port
+
+    def enable_debugger_forwarding(self, ssh: SshConnectionDetail) -> None:
+        """Enable pydevd port forwarding from the origin."""
+        if not self.debugging_enabled:
+            return
+
+        endpoint = ('localhost', self.origin_pydev_port)
+        forwards = [endpoint]
+
+        self.debugging_forwarder = create_ssh_port_forwards(self.args, ssh, forwards)
+
+        port_forwards = self.debugging_forwarder.collect_port_forwards()
+
+        self.state[self.__PYDEVD_PORT_KEY] = port = port_forwards[endpoint]
+
+        display.info(f'Remote debugging of {self.name!r} is available on port {port}.', verbosity=1)
+
+    def deprovision(self) -> None:
+        """Deprovision the host after delegation has completed."""
+        super().deprovision()
+
+        if not self.debugging_forwarder:
+            return  # forwarding not in use
+
+        self.debugging_forwarder.terminate()
+
+        display.info(f'Waiting for the {self.name!r} remote debugging SSH port forwarding process to terminate.', verbosity=1)
+
+        self.debugging_forwarder.wait()
+
+    def get_pydevd_settrace_arguments(self) -> dict[str, object]:
+        """Get settrace arguments for pydevd."""
+        return self.args.metadata.debugger_settings.settrace | dict(
+            host="localhost",
+            port=self.pydevd_port,
+        )
+
+    def get_pydevd_environment_variables(self) -> dict[str, str]:
+        """Get environment variables needed to configure pydevd for debugging."""
+        return dict(
+            PATHS_FROM_ECLIPSE_TO_PYTHON=json.dumps(list(self.get_source_mapping().items())),
+        )
+
+    def get_source_mapping(self) -> dict[str, str]:
+        """Get the source mapping from the given metadata."""
+        from . import data_context
+
+        if collection := data_context().content.collection:
+            source_mapping = {
+                f"{self.args.metadata.ansible_test_root}/": f'{ANSIBLE_TEST_ROOT}/',
+                f"{self.args.metadata.ansible_lib_root}/": f'{ANSIBLE_LIB_ROOT}/',
+                f'{self.args.metadata.collection_root}/ansible_collections/': f'{collection.root}/ansible_collections/',
+            }
+        else:
+            ansible_source_root = pathlib.Path(self.args.metadata.ansible_lib_root).parent.parent
+
+            source_mapping = {
+                f"{ansible_source_root}/": f'{ANSIBLE_SOURCE_ROOT}/',
+            }
+
+        source_mapping = {key: value for key, value in source_mapping.items() if key != value}
+
+        return source_mapping
+
+    def activate_debugger(self) -> None:
+        """Activate the debugger after delegation."""
+        if not self.args.metadata.loaded or not self.args.metadata.debugger_flags.self:
+            return
+
+        display.info('Activating remote debugging of ansible-test.', verbosity=1)
+
+        os.environ.update(self.get_pydevd_environment_variables())
+
+        debugging_module = importlib.import_module(self.args.metadata.debugger_settings.module)
+        debugging_module.settrace(**self.get_pydevd_settrace_arguments())
+
+        pass  # pylint: disable=unnecessary-pass  # when suspend is True, execution pauses here -- it's also a convenient place to put a breakpoint
+
+    def get_ansiballz_inventory_variables(self) -> dict[str, t.Any]:
+        """
+        Return inventory variables for remote debugging of AnsiballZ modules.
+        When delegating, this function must be called after delegation.
+        """
+        if not self.args.metadata.debugger_flags.ansiballz:
+            return {}
+
+        return dict(
+            _ansible_ansiballz_debugger_config=json.dumps(self.get_ansiballz_debugger_config()),
+        )
+
+    def get_ansiballz_environment_variables(self) -> dict[str, t.Any]:
+        """
+        Return environment variables for remote debugging of AnsiballZ modules.
+        When delegating, this function must be called after delegation.
+        """
+        if not self.args.metadata.debugger_flags.ansiballz:
+            return {}
+
+        return dict(
+            _ANSIBLE_ANSIBALLZ_DEBUGGER_CONFIG=json.dumps(self.get_ansiballz_debugger_config()),
+        )
+
+    def get_ansiballz_debugger_config(self) -> dict[str, t.Any]:
+        """
+        Return config for remote debugging of AnsiballZ modules.
+        When delegating, this function must be called after delegation.
+        """
+        debugger_config = dict(
+            module=self.args.metadata.debugger_settings.module,
+            settrace=self.get_pydevd_settrace_arguments(),
+            source_mapping=self.get_source_mapping(),
+        )
+
+        display.info(f'>>> Debugger Config ({self.name} AnsiballZ)\n{json.dumps(debugger_config, indent=4)}', verbosity=3)
+
+        return debugger_config
+
+    def get_ansible_cli_environment_variables(self) -> dict[str, t.Any]:
+        """
+        Return environment variables for remote debugging of the Ansible CLI.
+        When delegating, this function must be called after delegation.
+        """
+        if not self.args.metadata.debugger_flags.cli:
+            return {}
+
+        debugger_config = dict(
+            args=['-m', 'pydevd', '--client', 'localhost', '--port', str(self.pydevd_port)] + self.args.metadata.debugger_settings.args + ['--file'],
+            env=self.get_pydevd_environment_variables(),
+        )
+
+        display.info(f'>>> Debugger Config ({self.name} Ansible CLI)\n{json.dumps(debugger_config, indent=4)}', verbosity=3)
+
+        return dict(
+            ANSIBLE_TEST_DEBUGGER_CONFIG=json.dumps(debugger_config),
+        )
+
+
 class PosixProfile(HostProfile[TPosixConfig], metaclass=abc.ABCMeta):
     """Base class for POSIX host profiles."""
 
@@ -306,7 +484,7 @@ class PosixProfile(HostProfile[TPosixConfig], metaclass=abc.ABCMeta):
         return python
 
 
-class ControllerHostProfile(PosixProfile[TControllerHostConfig], metaclass=abc.ABCMeta):
+class ControllerHostProfile(PosixProfile[TControllerHostConfig], DebuggableProfile[TControllerHostConfig], metaclass=abc.ABCMeta):
     """Base class for profiles usable as a controller."""
 
     @abc.abstractmethod
@@ -410,7 +588,7 @@ class RemoteProfile(SshTargetHostProfile[TRemoteConfig], metaclass=abc.ABCMeta):
         )
 
 
-class ControllerProfile(SshTargetHostProfile[ControllerConfig], PosixProfile[ControllerConfig]):
+class ControllerProfile(SshTargetHostProfile[ControllerConfig], PosixProfile[ControllerConfig], DebuggableProfile[ControllerConfig]):
     """Host profile for the controller as a target."""
 
     @property
@@ -418,6 +596,11 @@ class ControllerProfile(SshTargetHostProfile[ControllerConfig], PosixProfile[Con
         """The name of the host profile."""
         return self.controller_profile.name
 
+    @property
+    def pydevd_port(self) -> int:
+        """The pydevd port to use."""
+        return self.controller_profile.pydevd_port
+
     def get_controller_target_connections(self) -> list[SshConnection]:
         """Return SSH connection(s) for accessing the host as a target from the controller."""
         settings = SshConnectionDetail(
@@ -432,7 +615,7 @@ class ControllerProfile(SshTargetHostProfile[ControllerConfig], PosixProfile[Con
         return [SshConnection(self.args, settings)]
 
 
-class DockerProfile(ControllerHostProfile[DockerConfig], SshTargetHostProfile[DockerConfig]):
+class DockerProfile(ControllerHostProfile[DockerConfig], SshTargetHostProfile[DockerConfig], DebuggableProfile[DockerConfig]):
     """Host profile for a docker instance."""
 
     MARKER = 'ansible-test-marker'
@@ -487,7 +670,7 @@ class DockerProfile(ControllerHostProfile[DockerConfig], SshTargetHostProfile[Do
             image=self.config.image,
             name=f'ansible-test-{self.label}',
             ports=[22],
-            publish_ports=not self.controller,  # connections to the controller over SSH are not required
+            publish_ports=self.debugging_enabled or not self.controller,  # SSH to the controller is not required unless remote debugging is enabled
             options=init_config.options,
             cleanup=False,
             cmd=self.build_init_command(init_config, init_probe),
@@ -627,7 +810,7 @@ class DockerProfile(ControllerHostProfile[DockerConfig], SshTargetHostProfile[Do
                 # The host namespace must be used to permit the container to access the cgroup v1 systemd hierarchy created by Podman.
                 '--cgroupns', 'host',
                 # Mask the host cgroup tmpfs mount to avoid exposing the host cgroup v1 hierarchies (or cgroup v2 hybrid) to the container.
-                # Podman will provide a cgroup v1 systemd hiearchy on top of this.
+                # Podman will provide a cgroup v1 systemd hierarchy on top of this.
                 '--tmpfs', '/sys/fs/cgroup',
             ))
 
@@ -1000,6 +1183,9 @@ class DockerProfile(ControllerHostProfile[DockerConfig], SshTargetHostProfile[Do
             docker_logs(self.args, self.container_name)
             raise
 
+        if self.debugging_enabled:
+            self.enable_debugger_forwarding(self.get_ssh_connection_detail(HostType.origin))
+
     def deprovision(self) -> None:
         """Deprovision the host after delegation has completed."""
         super().deprovision()
@@ -1248,13 +1434,18 @@ class OriginProfile(ControllerHostProfile[OriginConfig]):
         return os.getcwd()
 
 
-class PosixRemoteProfile(ControllerHostProfile[PosixRemoteConfig], RemoteProfile[PosixRemoteConfig]):
+class PosixRemoteProfile(ControllerHostProfile[PosixRemoteConfig], RemoteProfile[PosixRemoteConfig], DebuggableProfile[PosixRemoteConfig]):
     """Host profile for a POSIX remote instance."""
 
     def wait(self) -> None:
         """Wait for the instance to be ready. Executed before delegation for the controller and after delegation for targets."""
         self.wait_until_ready()
 
+    def setup(self) -> None:
+        """Perform out-of-band setup before delegation."""
+        if self.debugging_enabled:
+            self.enable_debugger_forwarding(self.get_origin_controller_connection().settings)
+
     def configure(self) -> None:
         """Perform in-band configuration. Executed before delegation for the controller and after delegation for targets."""
         # a target uses a single python version, but a controller may include additional versions for targets running on the controller

ansible_test/_internal/inventory.py

@@ -30,6 +30,7 @@ from .host_profiles import (
     SshTargetHostProfile,
     WindowsInventoryProfile,
     WindowsRemoteProfile,
+    DebuggableProfile,
 )
 
 from .ssh import (
@@ -59,6 +60,9 @@ def get_common_variables(target_profile: HostProfile, controller: bool = False)
         # To compensate for this we'll perform a `cd /` before running any commands after `sudo` succeeds.
         common_variables.update(ansible_sudo_chdir='/')
 
+    if isinstance(target_profile, DebuggableProfile):
+        common_variables.update(target_profile.get_ansiballz_inventory_variables())
+
     return common_variables
 
 

ansible_test/_internal/metadata.py

@@ -1,11 +1,15 @@
 """Test metadata for passing data to delegated tests."""
 
 from __future__ import annotations
+
+import dataclasses
 import typing as t
 
 from .util import (
     display,
     generate_name,
+    ANSIBLE_TEST_ROOT,
+    ANSIBLE_LIB_ROOT,
 )
 
 from .io import (
@@ -22,13 +26,19 @@ from .diff import (
 class Metadata:
     """Metadata object for passing data to delegated tests."""
 
-    def __init__(self) -> None:
+    def __init__(self, debugger_flags: DebuggerFlags) -> None:
         """Initialize metadata."""
         self.changes: dict[str, tuple[tuple[int, int], ...]] = {}
         self.cloud_config: t.Optional[dict[str, dict[str, t.Union[int, str, bool]]]] = None
         self.change_description: t.Optional[ChangeDescription] = None
         self.ci_provider: t.Optional[str] = None
         self.session_id = generate_name()
+        self.ansible_lib_root = ANSIBLE_LIB_ROOT
+        self.ansible_test_root = ANSIBLE_TEST_ROOT
+        self.collection_root: str | None = None
+        self.debugger_flags = debugger_flags
+        self.debugger_settings: DebuggerSettings | None = None
+        self.loaded = False
 
     def populate_changes(self, diff: t.Optional[list[str]]) -> None:
         """Populate the changeset using the given diff."""
@@ -55,8 +65,13 @@ class Metadata:
             changes=self.changes,
             cloud_config=self.cloud_config,
             ci_provider=self.ci_provider,
-            change_description=self.change_description.to_dict(),
+            change_description=self.change_description.to_dict() if self.change_description else None,
             session_id=self.session_id,
+            ansible_lib_root=self.ansible_lib_root,
+            ansible_test_root=self.ansible_test_root,
+            collection_root=self.collection_root,
+            debugger_flags=dataclasses.asdict(self.debugger_flags),
+            debugger_settings=dataclasses.asdict(self.debugger_settings) if self.debugger_settings else None,
         )
 
     def to_file(self, path: str) -> None:
@@ -76,12 +91,20 @@ class Metadata:
     @staticmethod
     def from_dict(data: dict[str, t.Any]) -> Metadata:
         """Return metadata loaded from the specified dictionary."""
-        metadata = Metadata()
+        metadata = Metadata(
+            debugger_flags=DebuggerFlags(**data['debugger_flags']),
+        )
+
         metadata.changes = data['changes']
         metadata.cloud_config = data['cloud_config']
         metadata.ci_provider = data['ci_provider']
-        metadata.change_description = ChangeDescription.from_dict(data['change_description'])
+        metadata.change_description = ChangeDescription.from_dict(data['change_description']) if data['change_description'] else None
         metadata.session_id = data['session_id']
+        metadata.ansible_lib_root = data['ansible_lib_root']
+        metadata.ansible_test_root = data['ansible_test_root']
+        metadata.collection_root = data['collection_root']
+        metadata.debugger_settings = DebuggerSettings(**data['debugger_settings']) if data['debugger_settings'] else None
+        metadata.loaded = True
 
         return metadata
 
@@ -130,3 +153,70 @@ class ChangeDescription:
         changes.no_integration_paths = data['no_integration_paths']
 
         return changes
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class DebuggerSettings:
+    """Settings for remote debugging."""
+
+    module: str | None = None
+    """
+    The Python module to import.
+    This should be pydevd or a derivative.
+    If not provided it will be auto-detected.
+    """
+
+    package: str | None = None
+    """
+    The Python package to install for debugging.
+    If `None` then the package will be auto-detected.
+    If an empty string, then no package will be installed.
+    """
+
+    settrace: dict[str, object] = dataclasses.field(default_factory=dict)
+    """
+    Options to pass to the `{module}.settrace` method.
+    Used for running AnsiballZ modules only.
+    The `host` and `port` options will be provided by ansible-test.
+    The `suspend` option defaults to `False`.
+    """
+
+    args: list[str] = dataclasses.field(default_factory=list)
+    """
+    Arguments to pass to `pydevd` on the command line.
+    Used for running Ansible CLI programs only.
+    The `--client` and `--port` options will be provided by ansible-test.
+    """
+
+    port: int = 5678
+    """
+    The port on the origin host which is listening for incoming connections from pydevd.
+    SSH port forwarding will be automatically configured for non-local hosts to connect to this port as needed.
+    """
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class DebuggerFlags:
+    """Flags for enabling specific debugging features."""
+
+    self: bool = False
+    """Debug ansible-test itself."""
+
+    ansiballz: bool = False
+    """Debug AnsiballZ modules."""
+
+    cli: bool = False
+    """Debug Ansible CLI programs other than ansible-test."""
+
+    on_demand: bool = False
+    """Enable debugging features only when ansible-test is running under a debugger."""
+
+    @property
+    def enable(self) -> bool:
+        """Return `True` if any debugger feature other than on-demand is enabled."""
+        return any(getattr(self, field.name) for field in dataclasses.fields(self) if field.name != 'on_demand')
+
+    @classmethod
+    def all(cls, enabled: bool) -> t.Self:
+        """Return a `DebuggerFlags` instance with all flags enabled or disabled."""
+        return cls(**{field.name: enabled for field in dataclasses.fields(cls)})

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/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/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: