| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475 |
- """The hourly scratch prune runs in a detached child process, not in the process that is due it.
- A pass can take seconds to minutes (the idle scan of a large tree, the ``rmtree`` of a multi-GB
- entry). Inline, it held every process start; on a daemon thread it died with every short-lived
- ``hermes`` command, the hourly stamp already spent. A detached child outlives the command that
- launched it, so each due pass runs to the end, with the same rules as an inline one.
- """
- from __future__ import annotations
- import logging
- import os
- import subprocess
- import sys
- from pathlib import Path
- import hermes_constants_scratch as rules
- logger = logging.getLogger(__name__)
- # ``-I``: neither the launcher's cwd (a project ``utils/`` would shadow ours) nor PYTHON* env vars
- # decide what the child imports; it gets the launcher's own ``sys.path`` (repo root, PM/venv
- # site-packages), not ``hermes_bootstrap``, whose boot hook would schedule another prune.
- _CHILD = ("import sys; sys.path[:] = sys.argv[3:]; "
- "import hermes_constants_scratch_detach as d; d.run(*sys.argv[1:3])")
- def spawn_prune(scratch: Path) -> None:
- """Start one detached prune of *scratch*, the path the caller resolved (a child never
- re-resolves the profile home). A failed spawn is logged and dropped: the stamp is already
- spent, so the next pass is the next process past the hourly mark.
- This process's ancestry is captured here, before the spawn: once this command and its
- parents exit, the child can no longer see that the user's shell was the caller's."""
- argv = [sys.executable, "-I"]
- if sys.dont_write_bytecode:
- argv.append("-B")
- if sys.pycache_prefix: # a sealed payload must never get __pycache__ writes
- argv += ["-X", f"pycache_prefix={sys.pycache_prefix}"]
- argv += ["-c", _CHILD, os.fspath(scratch), _encode_lineage(rules.lineage_with_start_times()), *sys.path]
- from hermes_cli._subprocess_compat import windows_detach_flags_without_breakaway, windows_detach_popen_kwargs
- stdio = {"stdin": subprocess.DEVNULL, "stdout": subprocess.DEVNULL, "stderr": subprocess.DEVNULL}
- try:
- try:
- subprocess.Popen(argv, close_fds=True, **stdio, **windows_detach_popen_kwargs())
- except PermissionError:
- if sys.platform != "win32":
- raise
- # A job object without BREAKAWAY_OK rejects CREATE_BREAKAWAY_FROM_JOB.
- subprocess.Popen(argv, close_fds=True, **stdio, creationflags=windows_detach_flags_without_breakaway())
- except (OSError, RuntimeError) as exc:
- logger.debug("scratch prune: could not start the detached pass for %s: %s", scratch, exc)
- def _encode_lineage(chain: list[tuple[int, float]] | None) -> str:
- # repr() round-trips a float exactly; "-" is "could not compute" (the child fails closed).
- return "-" if chain is None else ",".join(f"{pid}:{started!r}" for pid, started in chain)
- def run(scratch: str, lineage: str) -> None:
- """Child entry: one prune of *scratch*, sparing the launcher's ancestry. Any failure is one
- line in ``scratch-prune.log``; nothing is raised (no one reads this process's stderr)."""
- try:
- from hermes_constants import prune_scratch_dir
- rules._launcher_lineage = None if lineage == "-" else frozenset(
- (int(pid), float(started)) for pid, started in (item.split(":") for item in lineage.split(",")))
- prune_scratch_dir(Path(scratch))
- # health: allow BLE001 -- the detached child's top level: its stderr is /dev/null, so the audit log is the record
- except Exception as exc:
- audit = rules._open_prune_log(Path(scratch).parent.parent / "logs" / "scratch-prune.log")
- audit.info("scratch prune: detached pass failed (%s: %r)", type(exc).__name__, str(exc))
- if audit is not rules.logger:
- for handler in audit.handlers:
- handler.close()
|