fix: Do not fail an action whose subprocess exits immediately

CI surfaced this on macOS 3.12 as a flaky failure in an unrelated wrap test,
and it is the same root cause as the Windows-only flake that has been hitting
one of six Windows jobs per run:

  posix:   os.getpgid(pid) raises ProcessLookupError (ESRCH)
  windows: psutil raises NoSuchProcess ('process PID not found (pid=...)')

Both are reached when a trivial command finishes before the runner has finished
recording it. Both were raised on the run future, so a subprocess that ran to
completion was reported as a failed action, and the session went to
READY_ENDING -- which is why a wrap test asserting READY between tasks failed
intermittently on the second of three back-to-back echo actions.

- _subprocess.run: an already-reaped child has no process group to look up.
  Fall back to its own pid, which is the group we would have found since the
  child is the group leader.
- _windows_process_killer._suspend_process_tree: a process that exits between
  being discovered and being walked has no children to suspend. Mirrors the
  NoSuchProcess handling already present elsewhere in that module.

Tests: the posix guard is pinned by patching os.getpgid to raise (verified
against a mutant that stops catching it); the Windows walk is pinned with a
psutil mock, gated to Windows.

Signed-off-by: David Leong <116610336+leongdl@users.noreply.github.com>

Author: leongdl

src/openjd/sessions/_subprocess.py

@@ -177,13 +177,22 @@ def run(self) -> None:
         # Would use is_posix(), but it doesn't short-circuit mypy which then complains
         # about os.getpgid not being a valid attribute.
         if not sys.platform == "win32":
-            if not self._user or self._user.is_process_user():
-                self._sudo_child_process_group_id = os.getpgid(self._process.pid)
-            else:
-                self._sudo_child_process_group_id = find_sudo_child_process_group_id(
-                    logger=self._logger,
-                    sudo_process=self._process,
-                )
+            # A trivial command can exit before we get here. Looking up the
+            # process group of an already-reaped child raises ProcessLookupError
+            # (ESRCH), which must not fail the action: the child ran, and its
+            # exit code is still collected below. Fall back to its own pid --
+            # the process group we would have found, since the child is the
+            # group leader (start_new_session=True).
+            try:
+                if not self._user or self._user.is_process_user():
+                    self._sudo_child_process_group_id = os.getpgid(self._process.pid)
+                else:
+                    self._sudo_child_process_group_id = find_sudo_child_process_group_id(
+                        logger=self._logger,
+                        sudo_process=self._process,
+                    )
+            except ProcessLookupError:
+                self._sudo_child_process_group_id = self._process.pid
 
         self._logger.info(
             f"Command started as pid: {self._process.pid}",

src/openjd/sessions/_windows_process_killer.py

@@ -60,8 +60,21 @@ def _suspend_process_tree(
     if not suspend_subprocesses:
         return
 
-    # Recursively suspend child processes.
-    for child in process.children():
+    # Recursively suspend child processes. A process that exited between being
+    # discovered and being walked has no children to suspend, and must not fail
+    # the cancel: psutil raises NoSuchProcess ("process PID not found") here, and
+    # this runs on the run future, so the exception would surface as a failed
+    # action for a subprocess that in fact completed.
+    try:
+        children = process.children()
+    except NoSuchProcess:
+        logger.info(
+            f"Process {process.pid} exited before its children could be listed.",
+            extra=LogExtraInfo(openjd_log_content=LogContent.PROCESS_CONTROL),
+        )
+        return
+
+    for child in children:
         _suspend_process_tree(
             logger, child, all_processes, procs_cannot_suspend, suspend_subprocesses
         )

test/openjd/sessions_v0/test_subprocess.py

@@ -18,6 +18,7 @@
 from openjd.sessions._os_checker import is_posix, is_windows
 from openjd.sessions._session_user import PosixSessionUser, WindowsSessionUser
 from openjd.sessions._subprocess import LoggingSubprocess
+from openjd.sessions import _subprocess as subprocess_impl_mod
 
 from .conftest import (
     build_logger,
@@ -1069,3 +1070,61 @@ def end_proc():
             if num_children_running == 0:
                 break
         assert num_children_running == 0
+
+
+class TestFastExitingChild:
+    """A trivial command can exit before the runner finishes recording it.
+
+    Looking up an already-reaped child's process group raises ProcessLookupError
+    on posix, and psutil raises NoSuchProcess when walking it on Windows. Neither
+    may fail the action: the child ran, and its exit code is still collected.
+    """
+
+    @pytest.mark.skipif(not is_posix(), reason="posix-only: process groups")
+    @pytest.mark.usefixtures("message_queue", "queue_handler")
+    def test_getpgid_lookup_failure_does_not_fail_the_action(
+        self,
+        message_queue: SimpleQueue,
+        queue_handler: QueueHandler,
+    ) -> None:
+        # GIVEN: the child is gone by the time its process group is looked up
+        logger = build_logger(queue_handler)
+        callback = MagicMock()
+        subproc = LoggingSubprocess(
+            logger=logger,
+            args=[sys.executable, "-c", "print('DONE')"],
+            callback=callback,
+        )
+
+        with patch.object(
+            subprocess_impl_mod.os, "getpgid", side_effect=ProcessLookupError(3, "No such process")
+        ):
+            # WHEN
+            subproc.run()
+
+        # THEN: the action completed normally
+        assert subproc.exit_code == 0
+        assert subproc.failed_to_start is False
+        messages = collect_queue_messages(message_queue)
+        assert "DONE" in messages
+
+    @pytest.mark.skipif(not is_windows(), reason="Windows-only: psutil process walk")
+    def test_process_tree_walk_tolerates_exited_process(self) -> None:
+        # GIVEN: a process that disappears between discovery and the walk
+        from psutil import NoSuchProcess
+
+        from openjd.sessions._windows_process_killer import _suspend_process_tree
+
+        logger = MagicMock()
+        process = MagicMock()
+        process.pid = 4321
+        process.suspend.side_effect = NoSuchProcess(4321)
+        process.children.side_effect = NoSuchProcess(4321)
+        cannot_suspend: list = []
+        all_processes: list = []
+
+        # WHEN / THEN: no exception escapes
+        _suspend_process_tree(
+            logger, process, all_processes, cannot_suspend, suspend_subprocesses=True
+        )
+        assert process in all_processes