| 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283 |
- """Process-wide coordination for the cron tick's worktree prune (``cron.scheduler`` runs in here).
- One process ticks every served profile (``cron/AGENTS.md``), so the per-profile throttle in
- ``cron.scheduler`` legitimately lets each profile decide it is due, and each due profile gets its
- own ``cron-worktree-prune`` thread. Those threads used to fork ``git`` side by side, which starved a
- 338-profile gateway's event loop until the liveness watchdog exited 75 (#143255). Two guards:
- - **One sweep at a time.** The tick is sequential, the sweeps it dispatches are not; serialising
- them (discovery included) keeps the number of concurrent ``git`` children at one regardless of
- profile count. A waiting sweep holds no resources, so the wait is capped rather than unbounded.
- - **One prune per repo per interval.** Served profiles mostly resolve the same repos (the hermes
- checkout at least), and every prune pass ends in a footprint probe of the whole ``.worktrees/``,
- so the second profile to reach a shared repo within the interval has nothing to do.
- """
- import logging
- import os
- import threading
- import time
- from typing import Callable, Iterable, Optional
- logger = logging.getLogger(__name__)
- # Bounded so a wedged sweep cannot park a profile's thread forever; a normal sweep is one git pass
- # over a handful of repos.
- SWEEP_WAIT_SECONDS = 120.0
- _sweep_slot = threading.Semaphore(1)
- _last_worktree_prune_at: dict[str, float] = {} # canonical repo path -> monotonic stamp
- _lock = threading.Lock()
- def claim_sweep_slot(wait_seconds: Optional[float] = None) -> bool:
- """Take the process-wide prune slot, waiting for the sweep ahead of us (bounded)."""
- return _sweep_slot.acquire(timeout=SWEEP_WAIT_SECONDS if wait_seconds is None else wait_seconds)
- def release_sweep_slot() -> None:
- _sweep_slot.release()
- def claim_due_worktree_repos(repos: Iterable[str], interval_s: float) -> list[str]:
- """The subset of *repos* no served profile pruned within *interval_s*, stamped as claimed.
- Keyed on the path ``git`` resolves to, case-folded where the filesystem is (Windows).
- """
- now = time.monotonic()
- due = []
- with _lock:
- for repo in repos:
- key = os.path.normcase(os.path.realpath(repo))
- last = _last_worktree_prune_at.get(key)
- if last is None or now - last >= interval_s:
- _last_worktree_prune_at[key] = now
- due.append(repo)
- return due
- def run_sweep(discover: Callable[[], Iterable[str]], *, interval_seconds: float,
- wait_seconds: Optional[float] = None) -> None:
- """Prune the repos ``discover()`` reports that are due, from the cron tick's daemon thread.
- ``discover`` stays in the caller so a per-profile repo lookup (and anything a test patches) is
- read where it is defined. Errors never propagate: GC is hygiene, not scheduling.
- """
- if not claim_sweep_slot(wait_seconds):
- logger.debug("Cron worktree maintenance skipped: another sweep is still running")
- return
- try:
- repos = claim_due_worktree_repos(discover() or [], interval_seconds)
- if not repos:
- return
- from hermes_cli.worktree_ops import _prune_stale_worktrees
- for repo in repos:
- try:
- _prune_stale_worktrees(repo)
- except Exception:
- logger.debug("Cron worktree maintenance failed for %s", repo, exc_info=True)
- except Exception:
- logger.debug("Cron worktree maintenance skipped", exc_info=True)
- finally:
- release_sweep_slot()
|