cot.tmppath 0.2.0__tar.gz → 0.2.1__tar.gz

{cot_tmppath-0.2.0 → cot_tmppath-0.2.1}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 <!-- towncrier release notes start -->
 
+## 0.2.1 (2026-10-07)
+
+### Fixed
+
+- A crashed run whose pid was reused by another process is collected: holder files record the process start time on Linux and Windows. Before, the run counted as alive until that other process ended. macOS still relies on the pid alone.
+
 ## 0.2.0 (2026-10-07)
 
 ### Removed

{cot_tmppath-0.2.0 → cot_tmppath-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cot.tmppath
-Version: 0.2.0
+Version: 0.2.1
 Summary: Hardened, fast management of related temporary folders
 Project-URL: Source, https://github.com/cogs-of-testing/cot.tmppath
 Author-email: Ronny Pfannschmidt <opensource@ronnypfannschmidt.de>

{cot_tmppath-0.2.0 → cot_tmppath-0.2.1}/docs/core.md

@@ -58,13 +58,14 @@ The default root adds two levels above this:
 ## Liveness and retention (G4, G5)
 
 - A process that starts or joins a run writes a holder file with its pid,
-  host and Linux boot id, and removes it when it closes the run. A run is
-  live while any holder may be alive: same host and boot, and the pid
-  exists. A holder from another host always counts as alive, so a run is
+  host, Linux boot id and process start time, and removes it when it closes
+  the run. A run is live while any holder may be alive: same host and boot,
+  the pid exists, and the process with that pid started when the holder
+  says. A holder from another host always counts as alive, so a run is
   never collected on a guess.
-- **Open:** a pid that is reused by an unrelated process keeps a crashed
-  run alive until that process ends. Recording the process start time would
-  close that gap.
+- The start time comes from `/proc` on Linux and `GetProcessTimes` on
+  Windows. **Open:** macOS has neither, so there a pid reused by an
+  unrelated process keeps a crashed run alive until that process ends.
 - Closing a run applies retention to the whole root: the newest
   `keep_runs` runs stay, older ones that are not live go, and so do runs
   older than `max_age`. The run being closed counts as the newest. A

cot_tmppath-0.2.1/src/cot/tmppath/_owner.py

@@ -0,0 +1,141 @@
+"""Who holds a run, and whether they are still alive (G5)."""
+
+from __future__ import annotations
+
+import json
+import os
+import socket
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def _boot_id() -> str:
+    # Linux names each boot; elsewhere a pid alone has to do
+    try:
+        return Path("/proc/sys/kernel/random/boot_id").read_text().strip()
+    except OSError:
+        return ""
+
+
+@dataclass(frozen=True)
+class Owner:
+    """A process: its pid, host, boot and start time, so a pid reused by
+    another process, after a reboot or on another machine is not mistaken
+    for it. ``boot`` and ``started`` are empty where the platform cannot
+    tell (macOS); the pid alone decides there."""
+
+    pid: int
+    host: str
+    boot: str
+    started: str = ""
+
+    @classmethod
+    def current(cls) -> Owner:
+        pid = os.getpid()
+        return cls(pid, socket.gethostname(), _BOOT, _process_start(pid))
+
+    def to_bytes(self) -> bytes:
+        return json.dumps(
+            {
+                "pid": self.pid,
+                "host": self.host,
+                "boot": self.boot,
+                "started": self.started,
+            }
+        ).encode()
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> Owner | None:
+        try:
+            raw = json.loads(data)
+            return cls(
+                int(raw["pid"]),
+                str(raw["host"]),
+                str(raw["boot"]),
+                # holder files written by 0.2.0 have no start time
+                str(raw.get("started", "")),
+            )
+        except (ValueError, KeyError, TypeError, AttributeError):
+            return None
+
+    def is_alive(self) -> bool:
+        """False only when this process is known to be gone.
+
+        An owner on another host cannot be checked from here, so it counts
+        as alive: a run is never collected on a guess.
+        """
+        here = Owner.current()
+        if self.host != here.host:
+            return True
+        if self.boot and here.boot and self.boot != here.boot:
+            return False
+        if not _pid_alive(self.pid):
+            return False
+        if self.started:
+            # a process with this pid exists; is it the one that wrote this?
+            now = _process_start(self.pid)
+            if now and now != self.started:
+                return False
+        return True
+
+
+_BOOT = _boot_id()
+
+if sys.platform == "win32":
+    import ctypes
+
+    _kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    _PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+    _STILL_ACTIVE = 259
+    _ERROR_ACCESS_DENIED = 5
+
+    class _FileTime(ctypes.Structure):
+        _fields_ = (("low", ctypes.c_ulong), ("high", ctypes.c_ulong))
+
+    def _process_start(pid: int) -> str:
+        handle = _kernel32.OpenProcess(_PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
+        if not handle:
+            return ""
+        try:
+            times = [_FileTime() for _ in range(4)]
+            if not _kernel32.GetProcessTimes(
+                handle, *(ctypes.byref(time) for time in times)
+            ):
+                return ""
+            return str(times[0].high << 32 | times[0].low)
+        finally:
+            _kernel32.CloseHandle(handle)
+
+    def _pid_alive(pid: int) -> bool:
+        handle = _kernel32.OpenProcess(_PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
+        if not handle:
+            return bool(ctypes.get_last_error() == _ERROR_ACCESS_DENIED)
+        try:
+            code = ctypes.c_ulong()
+            if not _kernel32.GetExitCodeProcess(handle, ctypes.byref(code)):
+                return True
+            return code.value == _STILL_ACTIVE
+        finally:
+            _kernel32.CloseHandle(handle)
+
+else:
+
+    def _process_start(pid: int) -> str:
+        # Linux: field 22 of /proc/{pid}/stat, in clock ticks since boot;
+        # the name before it can hold spaces and parentheses
+        try:
+            stat = Path(f"/proc/{pid}/stat").read_text()
+        except OSError:
+            return ""
+        fields = stat.rpartition(")")[2].split()
+        return fields[19] if len(fields) > 19 else ""
+
+    def _pid_alive(pid: int) -> bool:
+        try:
+            os.kill(pid, 0)
+        except ProcessLookupError:
+            return False
+        except PermissionError:
+            return True
+        return True

{cot_tmppath-0.2.0 → cot_tmppath-0.2.1}/testing/test_concurrency.py

@@ -11,6 +11,7 @@ import pytest
 
 from conftest import run_python
 from cot.tmppath import Retention, Root
+from cot.tmppath._owner import Owner
 
 
 def test_another_process_can_join_a_run(root_path: Path) -> None:
@@ -87,3 +88,17 @@ def test_place_is_atomic(root_path: Path) -> None:
             staging.write_bytes(b"whole")
     assert destination.read_bytes() == b"whole"
     assert list(destination.parent.iterdir()) == [destination]
+
+
+@pytest.mark.skipif(
+    not Owner.current().started, reason="no process start time on this platform"
+)
+def test_reused_pid_does_not_keep_a_run_alive(root_path: Path) -> None:
+    run = Root(root_path).start_run()
+    # what a crashed holder looks like once its pid went to another process
+    here = Owner.current()
+    reused = Owner(here.pid, here.host, here.boot, started="0")
+    (holder,) = (run.path / ".cot-holders").iterdir()
+    holder.write_bytes(reused.to_bytes())
+    Root(root_path, retention=Retention(keep_runs=0)).prune()
+    assert not run.path.exists()

cot_tmppath-0.2.0/src/cot/tmppath/_owner.py

@@ -1,92 +0,0 @@
-"""Who holds a run, and whether they are still alive (G5)."""
-
-from __future__ import annotations
-
-import json
-import os
-import socket
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-
-
-def _boot_id() -> str:
-    # Linux names each boot; elsewhere a pid alone has to do
-    try:
-        return Path("/proc/sys/kernel/random/boot_id").read_text().strip()
-    except OSError:
-        return ""
-
-
-@dataclass(frozen=True)
-class Owner:
-    """A process: its pid, host and boot, so a reused pid after a reboot
-    or on another machine is not mistaken for it."""
-
-    pid: int
-    host: str
-    boot: str
-
-    @classmethod
-    def current(cls) -> Owner:
-        return cls(os.getpid(), socket.gethostname(), _BOOT)
-
-    def to_bytes(self) -> bytes:
-        return json.dumps(
-            {"pid": self.pid, "host": self.host, "boot": self.boot}
-        ).encode()
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Owner | None:
-        try:
-            raw = json.loads(data)
-            return cls(int(raw["pid"]), str(raw["host"]), str(raw["boot"]))
-        except (ValueError, KeyError, TypeError):
-            return None
-
-    def is_alive(self) -> bool:
-        """False only when this process is known to be gone.
-
-        An owner on another host cannot be checked from here, so it counts
-        as alive: a run is never collected on a guess.
-        """
-        here = Owner.current()
-        if self.host != here.host:
-            return True
-        if self.boot and here.boot and self.boot != here.boot:
-            return False
-        return _pid_alive(self.pid)
-
-
-_BOOT = _boot_id()
-
-if sys.platform == "win32":
-    import ctypes
-
-    _kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
-    _PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
-    _STILL_ACTIVE = 259
-    _ERROR_ACCESS_DENIED = 5
-
-    def _pid_alive(pid: int) -> bool:
-        handle = _kernel32.OpenProcess(_PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
-        if not handle:
-            return bool(ctypes.get_last_error() == _ERROR_ACCESS_DENIED)
-        try:
-            code = ctypes.c_ulong()
-            if not _kernel32.GetExitCodeProcess(handle, ctypes.byref(code)):
-                return True
-            return code.value == _STILL_ACTIVE
-        finally:
-            _kernel32.CloseHandle(handle)
-
-else:
-
-    def _pid_alive(pid: int) -> bool:
-        try:
-            os.kill(pid, 0)
-        except ProcessLookupError:
-            return False
-        except PermissionError:
-            return True
-        return True