transports: use a thread instead of SafeChildWatcher

SafeChildWatcher was removed in 3.14.  We used to use this as a fallback
for when we don't have pidfd support in the kernel (or Python stdlib)
under the assumption that we'd never see Python 3.14 on a system with
such an old kernel, but of course this happens with newer Python
versions in containers running on RHEL 8 hosts.

Let's divorce ourselves from the entire concept of ChildWatchers,
dropping our 'qdata' cache for them.  Instead, we just try to create a
pidfd each time, and if that fails, start up a thread to call waitpid()
and notify the event loop via call_soon_threadsafe().  This approach is
a simplified form of asyncio.ThreadedChildWatcher from the standard
library, which is what gets used anywhere pidfds aren't available.

We had a test that caused pidfd to return ENOSYS that we started
skipping on newer Python versions to avoid trying to use
SafeChildWatcher in what I imagined to be an impossible configuration.
Bring that back unconditionally (and rename it to remove the reference
to "safe watcher").

Author: allisonkarlitskaya

src/cockpit/transports.py

@@ -17,6 +17,7 @@
 import struct
 import subprocess
 import termios
+from threading import Thread
 from typing import Any, ClassVar, Sequence
 
 from .jsonutil import JsonObject, get_int
@@ -33,6 +34,8 @@ def prctl(*args: int) -> None:
 
 
 logger = logging.getLogger(__name__)
+
+
 IOV_MAX = 1024  # man 2 writev
 
 
@@ -305,50 +308,35 @@ def get_stderr(self, *, reset: bool = False) -> str:
             return ''
 
     def watch_exit(self, process: 'subprocess.Popen[bytes]') -> None:
-        def flag_exit() -> None:
+        def child_exited(pid: int, status: int) -> None:
+            assert pid == process.pid
+            try:
+                self._returncode = os.waitstatus_to_exitcode(status)
+            except ValueError:
+                self._returncode = status
+
             assert isinstance(self._protocol, SubprocessProtocol)
             logger.debug('Process exited with status %d', self._returncode)
             if not self._closing:
                 self._protocol.process_exited()
 
         def pidfd_ready() -> None:
-            pid, status = os.waitpid(process.pid, 0)
-            assert pid == process.pid
-            try:
-                self._returncode = os.waitstatus_to_exitcode(status)
-            except ValueError:
-                self._returncode = status
+            pid, status = os.waitpid(process.pid, 0)  # should never block
             self._loop.remove_reader(pidfd)
             os.close(pidfd)
-            flag_exit()
-
-        def child_watch_fired(pid: int, code: int) -> None:
-            assert process.pid == pid
-            self._returncode = code
-            flag_exit()
-
-        # We first try to create a pidfd to track the process manually.  If
-        # that does work, we need to create a SafeChildWatcher, which has been
-        # deprecated and removed in Python 3.14.  This effectively means that
-        # using Python 3.14 requires that we're running on a kernel with pidfd
-        # support, which is fine: the only place we still care about such old
-        # kernels is on RHEL8 and we have Python 3.6 there.
+            child_exited(pid, status)
+
+        def waitpid_thread() -> None:
+            pid, status = os.waitpid(process.pid, 0)  # will block
+            self._loop.call_soon_threadsafe(child_exited, pid, status)
+
+        # We first try to create a pidfd to track the process.  If that doesn't
+        # work, we spawn a thread to do a blocking waitpid().
         try:
             pidfd = os.pidfd_open(process.pid)
             self._loop.add_reader(pidfd, pidfd_ready)
         except (AttributeError, OSError):
-            quark = '_cockpit_transports_child_watcher'
-            watcher = getattr(self._loop, quark, None)
-
-            if watcher is None:
-                try:
-                    watcher = asyncio.SafeChildWatcher()  # type: ignore[attr-defined]
-                except AttributeError as e:
-                    raise RuntimeError('pidfd support required on Python 3.14+') from e
-                watcher.attach_loop(self._loop)
-                setattr(self._loop, quark, watcher)
-
-            watcher.add_child_handler(process.pid, child_watch_fired)
+            Thread(name=f'cockpit-waitpid-{process.pid}', target=waitpid_thread, daemon=True).start()
 
     def __init__(self,
                  loop: asyncio.AbstractEventLoop,

test/pytest/test_transport.py

@@ -9,7 +9,6 @@
 import os
 import signal
 import subprocess
-import sys
 import unittest.mock
 from typing import Any, List, Optional, Tuple
 
@@ -289,13 +288,8 @@ async def test_stderr(self) -> None:
         assert transport.get_stderr(reset=True) == ''
 
     @pytest.mark.asyncio
-    async def test_safe_watcher_ENOSYS(self, monkeypatch: pytest.MonkeyPatch) -> None:
+    async def test_pidfd_ENOSYS(self, monkeypatch: pytest.MonkeyPatch) -> None:
         # this test disables pidfd support in order to force the fallback path
-        # which creates a SafeChildWatcher.  That's deprecated since 3.12 and
-        # removed in 3.14, so skip this test on those versions to avoid issues.
-        if sys.version_info >= (3, 12, 0):
-            pytest.skip()
-
         monkeypatch.setattr(os, 'pidfd_open', unittest.mock.Mock(side_effect=OSError), raising=False)
         protocol, _transport = self.subprocess(['true'])
         await protocol.eof_and_exited_with_code(0)