@passioncode-ai/fabric-agent-adapter 0.39.1 → 0.41.0

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric_kit.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""The service kit as a versioned set of modules: build its manifest, install it into a service, report a copy's state.
+
+The kit is not one file. ``kit.json`` beside this script lists every module in dependency order, per language, with
+the kit modules it imports and its sha256, and ``history`` keeps the sha256 of every earlier release, so a copy in a
+service can be told apart: ``current``, ``older`` (with the release it came from), or ``modified``.
+
+    fabric_kit.py install <service-dir> [--lang py|node] [--module NAME ...] [--all] [--dry-run] [--force]
+    fabric_kit.py status <service-dir> [--json]
+    fabric_kit.py build [--check]          # maintainers: refresh kit.json from the sources
+
+``install`` copies the closure of the named modules (default ``fabric_service`` / ``fabric-service``) and nothing else.
+It refuses to overwrite a file it does not recognise (a ``modified`` copy) unless ``--force``. ``status`` also names a
+module a present module imports that is missing from the folder: the copy would fail when that code path runs.
+Standard library only. Exit codes: 0 done or all current, 1 a problem (missing, modified, refused), 2 usage.
+"""
+from __future__ import annotations
+
+import argparse
+import ast
+import hashlib
+import json
+import os
+import re
+import shutil
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+HERE = Path(__file__).resolve().parent
+MANIFEST = HERE / "kit.json"
+LANGS = {"py": "python", "node": "node"}
+DEFAULT_ROOT = {"python": "fabric_service", "node": "fabric-service"}
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def python_imports(path: Path, modules: List[str]) -> List[str]:
+    """The kit modules a Python file imports, at any depth of its code (a lazy import is a dependency too)."""
+    found = set()
+    for node in ast.walk(ast.parse(path.read_text(encoding="utf-8"))):
+        if isinstance(node, ast.Import):
+            found.update(a.name for a in node.names if a.name in modules)
+        elif isinstance(node, ast.ImportFrom) and node.module in modules:
+            found.add(node.module)
+    found.discard(path.stem)
+    return sorted(found)
+
+
+def node_imports(path: Path, modules: List[str]) -> List[str]:
+    """The kit modules an ES module imports (static `from './x.mjs'` and dynamic `import('./x.mjs')`)."""
+    text = path.read_text(encoding="utf-8")
+    found = set(re.findall(r"""(?:from|import\()\s*['"]\./([A-Za-z0-9_-]+)\.mjs['"]""", text)) & set(modules)
+    found.discard(path.stem)
+    return sorted(found)
+
+
+def load_manifest() -> Dict:
+    return json.loads(MANIFEST.read_text(encoding="utf-8"))
+
+
+def build(check: bool = False) -> List[str]:
+    """Refresh every module's imports and sha256 in kit.json, and record this release's digests in its history.
+    Returns what changed (with check=True nothing is written)."""
+    manifest = load_manifest()
+    changed = []
+    for lang, entries in (("python", manifest["python"]), ("node", manifest["node"])):
+        names = [e["module"] for e in entries]
+        for entry in entries:
+            path = HERE / entry["file"]
+            imports = (python_imports if lang == "python" else node_imports)(path, names)
+            digest = _sha256(path)
+            if entry.get("imports") != imports or entry.get("sha256") != digest:
+                changed.append(entry["file"])
+                entry["imports"], entry["sha256"] = imports, digest
+    data = sorted({d for e in manifest["python"] + manifest["node"] for d in e.get("data", [])})
+    digests = {d: _sha256(HERE / d) for d in data}
+    if manifest.get("data") != digests:
+        changed.append("data files")
+        manifest["data"] = digests
+    current = {e["file"]: e["sha256"] for e in manifest["python"] + manifest["node"]}
+    current.update(digests)
+    if manifest.setdefault("history", {}).get(manifest["version"]) != current:
+        manifest["history"][manifest["version"]] = current
+        changed.append("kit.json history %s" % manifest["version"])
+    if changed and not check:
+        MANIFEST.write_text(json.dumps(manifest, indent=1) + "\n", encoding="utf-8")
+    return changed
+
+
+def closure(entries: List[Dict], roots: List[str]) -> List[Dict]:
+    """The named modules and everything they import, in the manifest's (dependency) order."""
+    by_name = {e["module"]: e for e in entries}
+    unknown = [r for r in roots if r not in by_name]
+    if unknown:
+        raise SystemExit("unknown kit module: %s (the manifest lists %s)" % (", ".join(unknown), ", ".join(by_name)))
+    wanted, stack = set(), list(roots)
+    while stack:
+        name = stack.pop()
+        if name not in wanted:
+            wanted.add(name)
+            stack.extend(by_name[name]["imports"])
+    return [e for e in entries if e["module"] in wanted]
+
+
+def state_of(path: Path, manifest: Dict) -> Dict:
+    """`current`, `older` with the release a copy came from, or `modified` (a digest no release had)."""
+    digest = _sha256(path)
+    if any(e["file"] == path.name and e["sha256"] == digest for e in manifest["python"] + manifest["node"]) or \
+            manifest.get("data", {}).get(path.name) == digest:
+        return {"state": "current", "version": manifest["version"]}
+    for version, files in sorted(manifest.get("history", {}).items(), key=lambda kv: [int(x) for x in re.findall(r"[0-9]+", kv[0])], reverse=True):
+        if files.get(path.name) == digest:
+            return {"state": "older", "version": version}
+    return {"state": "modified", "version": None}
+
+
+def status(service_dir: Path) -> Dict:
+    manifest = load_manifest()
+    report = {"kit": manifest["version"], "files": [], "missing": []}
+    for lang in ("python", "node"):
+        entries = manifest[lang]
+        present = [e for e in entries if (service_dir / e["file"]).is_file()]
+        for e in present:
+            report["files"].append({"file": e["file"], **state_of(service_dir / e["file"], manifest)})
+        names = {e["module"] for e in present}
+        by_name = {e["module"]: e for e in entries}
+        def reader(path: Path, modules: List[str]) -> List[str]:
+            try:
+                return (python_imports if lang == "python" else node_imports)(path, modules)
+            except (SyntaxError, ValueError):  # a copy someone broke is already `modified`; its imports are unknown
+                return []
+        # What each copy imports is read from the copy itself (an older release imports other modules than this one);
+        # a module it lacks would be installed at this release, so that module's own imports are followed too.
+        queue = [(e["file"], reader(service_dir / e["file"], list(by_name))) for e in present]
+        reported = set()
+        for e in present:
+            for d in e.get("data", []):
+                if (service_dir / d).is_file():
+                    if d not in [f["file"] for f in report["files"]]:
+                        report["files"].append({"file": d, **state_of(service_dir / d, manifest)})
+                elif d not in reported:
+                    reported.add(d)
+                    report["missing"].append({"file": e["file"], "needs": d})
+        while queue:
+            importer, deps = queue.pop(0)
+            for dep in deps:
+                if dep in names or dep in reported:
+                    continue
+                reported.add(dep)
+                report["missing"].append({"file": importer, "needs": by_name[dep]["file"]})
+                for d in by_name[dep].get("data", []):  # the data a missing module reads at run time
+                    if not (service_dir / d).is_file() and d not in reported:
+                        reported.add(d)
+                        report["missing"].append({"file": by_name[dep]["file"], "needs": d})
+                queue.append((by_name[dep]["file"], by_name[dep]["imports"]))
+    return report
+
+
+def install(service_dir: Path, lang: str, modules: List[str], dry_run: bool = False, force: bool = False) -> Dict:
+    manifest = load_manifest()
+    entries = manifest[lang]
+    roots = modules or [DEFAULT_ROOT[lang]]
+    plan = closure(entries, roots)
+    result = {"kit": manifest["version"], "copied": [], "kept": [], "refused": []}
+    files = []
+    for e in plan:
+        files.append(e["file"])
+        files.extend(d for d in e.get("data", []) if d not in files)
+    for name in files:
+        target = service_dir / name
+        if target.is_file():
+            st = state_of(target, manifest)
+            if st["state"] == "current":
+                result["kept"].append(name)
+                continue
+            if st["state"] == "modified" and not force:
+                result["refused"].append(name)
+                continue
+        result["copied"].append(name)
+    if not dry_run and not result["refused"]:
+        service_dir.mkdir(parents=True, exist_ok=True)
+        for name in result["copied"]:
+            tmp = service_dir / (".%s.tmp" % name)
+            shutil.copyfile(HERE / name, tmp)
+            os.replace(tmp, service_dir / name)
+    return result
+
+
+def main(argv: List[str]) -> int:
+    parser = argparse.ArgumentParser(prog="fabric_kit.py", description=__doc__.split("\n\n")[0])
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    p_install = sub.add_parser("install", help="copy a module's closure into a service")
+    p_install.add_argument("dir", type=Path)
+    p_install.add_argument("--lang", choices=sorted(LANGS), default="py")
+    p_install.add_argument("--module", action="append", default=[])
+    p_install.add_argument("--all", action="store_true", help="every module of the language")
+    p_install.add_argument("--dry-run", action="store_true")
+    p_install.add_argument("--force", action="store_true", help="overwrite a copy the kit does not recognise")
+    p_status = sub.add_parser("status", help="the state of the kit copies in a service")
+    p_status.add_argument("dir", type=Path)
+    p_status.add_argument("--json", action="store_true")
+    p_build = sub.add_parser("build", help="refresh kit.json from the sources (maintainers)")
+    p_build.add_argument("--check", action="store_true")
+    args = parser.parse_args(argv)
+    if args.cmd == "build":
+        changed = build(args.check)
+        print(("kit.json is out of date: " if args.check else "rebuilt: ") + ", ".join(changed) if changed else "kit.json is up to date")
+        return 1 if (changed and args.check) else 0
+    if args.cmd == "status":
+        report = status(args.dir)
+        if args.json:
+            print(json.dumps(report, indent=2))
+        else:
+            for f in report["files"]:
+                print("%-9s %s%s" % (f["state"], f["file"], " (%s)" % f["version"] if f["state"] == "older" else ""))
+            for m in report["missing"]:
+                print("missing   %s, which %s imports" % (m["needs"], m["file"]))
+            if not report["files"]:
+                print("no kit module in %s" % args.dir)
+        bad = not report["files"] or report["missing"] or any(f["state"] != "current" for f in report["files"])
+        return 1 if bad else 0
+    lang = LANGS[args.lang]
+    known = [e["module"] for e in load_manifest()[lang]]
+    modules = known if args.all else args.module
+    unknown = [m for m in modules if m not in known]
+    if unknown:
+        print("no such %s kit module: %s (kit.json lists %s)" % (lang, ", ".join(unknown), ", ".join(known)), file=sys.stderr)
+        return 2
+    result = install(args.dir, lang, modules, args.dry_run, args.force)
+    for name in result["copied"]:
+        print(("would copy " if args.dry_run else "copied     ") + name)
+    for name in result["kept"]:
+        print("current    " + name)
+    for name in result["refused"]:
+        print("refused    %s: the copy there is not one the kit released; --force overwrites it" % name)
+    return 1 if result["refused"] else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric_lock.py

@@ -0,0 +1,308 @@
+"""One copy of a service, locked before any side effect (LC-01, DEC-0057): the instance lock, the supervisor marker
+in both its forms, and the wait budget under a supervisor. Part of the service kit (FAA-65, layer L3)."""
+from __future__ import annotations
+
+import errno
+import hashlib
+import ntpath
+import os
+import posixpath
+import re
+import socket
+import sys
+import time
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Sequence
+
+import sys as _sys  # noqa: E402
+from pathlib import Path as _Path  # noqa: E402
+if str(_Path(__file__).resolve().parent) not in _sys.path:  # the kit loads from any working directory (FAA-65)
+    _sys.path.insert(0, str(_Path(__file__).resolve().parent))
+from fabric_base import (
+    SUPERVISOR_ENV,
+    ServiceError,
+    WINDOWS,
+    _O_BINARY,
+)
+from fabric_platform import (
+    _close_handle,
+    _create_first_pipe,
+    _pipe_exists,
+)
+from fabric_paths import (
+    ensure_private_dir,
+)
+
+
+EXIT_ALREADY_RUNNING = 75
+
+
+LOCK_WAIT_SUPERVISED_SECONDS = 300.0
+
+
+LOCK_BACKOFF_FIRST_SECONDS = 0.5
+
+
+LOCK_BACKOFF_MAX_SECONDS = 30.0
+
+
+class AlreadyRunning(ServiceError):
+    def __init__(self, holder_pid: Optional[int], lock_path: Path):
+        self.holder_pid = holder_pid
+        self.lock_path = lock_path
+        # FAC-SEM-078: a copy that cannot learn the holder's pid says the holder is unknown.
+        who = "process %d" % holder_pid if holder_pid else "an unknown process"
+        super().__init__("Another copy is already running (%s holds %s)." % (who, lock_path))
+
+
+class InstanceLock:
+    """Exclusive flock on <data>/service.lock, taken BEFORE any side effect.
+
+    Binding a port is not a lock: a second copy that resumes jobs before its
+    bind fails has already done damage. The lock is released by the kernel when
+    the process dies, so a crash never leaves it stale.
+    """
+
+    def __init__(self, data_dir: Path):
+        self.path = Path(data_dir) / "service.lock"
+        self._fd: Optional[int] = None
+        self._name: Any = None
+
+    #: Windows locks a byte range, not the file: one byte far past the pid the file holds, so the
+    #: holder may rewrite the pid and another process may still read it (locking past the end of
+    #: a file is allowed there).
+    WINDOWS_LOCK_OFFSET = 1 << 30
+
+    def acquire(self) -> "InstanceLock":
+        ensure_private_dir(self.path.parent)
+        fd = os.open(str(self.path), os.O_RDWR | os.O_CREAT | _O_BINARY, 0o600)
+        try:
+            if WINDOWS:
+                import msvcrt
+
+                os.lseek(fd, self.WINDOWS_LOCK_OFFSET, os.SEEK_SET)
+                msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+                os.lseek(fd, 0, os.SEEK_SET)
+            else:
+                import fcntl
+
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError as exc:
+            os.close(fd)
+            if exc.errno in (errno.EWOULDBLOCK, errno.EAGAIN, errno.EACCES, getattr(errno, "EDEADLOCK", -1)):
+                raise AlreadyRunning(_read_pid(self.path), self.path) from None
+            raise
+        try:
+            self._name = _hold_lock_name(self.path)
+        except BaseException:
+            os.close(fd)
+            raise
+        os.ftruncate(fd, 0)
+        os.write(fd, str(os.getpid()).encode())
+        os.fsync(fd)
+        self._fd = fd
+        return self
+
+    def release(self) -> None:
+        if self._fd is not None:
+            os.close(self._fd)
+            self._fd = None
+        if self._name is not None:
+            _drop_lock_name(self._name)
+            self._name = None
+
+
+def lock_name(lock_path: Path, platform: str = sys.platform) -> Optional[str]:
+    """The name the Node kit holds for this lock file; None where it holds none (macOS: O_EXLOCK)."""
+    if platform.startswith("linux"):
+        digest = hashlib.sha256(posixpath.abspath(str(lock_path)).encode()).hexdigest()[:32]
+        return "\0fabric-service-" + digest
+    if platform == "win32":
+        # Windows paths compare without case: C:\Users and c:\users are one lock.
+        digest = hashlib.sha256(ntpath.normcase(ntpath.abspath(str(lock_path))).encode()).hexdigest()[:32]
+        return "\\\\.\\pipe\\fabric-service-" + digest
+    return None
+
+
+def _hold_lock_name(lock_path: Path) -> Any:
+    name = lock_name(lock_path)
+    if name is None:
+        return None
+    if WINDOWS:
+        handle = _create_first_pipe(name)
+        if handle is None:
+            raise AlreadyRunning(_read_pid(lock_path), lock_path)
+        return handle
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    try:
+        sock.bind(name)
+    except OSError as exc:
+        sock.close()
+        if exc.errno == errno.EADDRINUSE:
+            raise AlreadyRunning(_read_pid(lock_path), lock_path) from None
+        raise
+    # Held by its descriptor, like the file lock: a socket object would close when collected.
+    return sock.detach()
+
+
+def _drop_lock_name(held: Any) -> None:
+    if WINDOWS:
+        _close_handle(held)
+    else:
+        os.close(held)
+
+
+def lock_name_held(lock_path: Path) -> Optional[bool]:
+    """True when some process holds the lock's name (a running service of either kit); None where there is no name
+    to hold. It only looks — /proc/net/unix on Linux, WaitNamedPipeW on Windows — and never takes the name, so a
+    probe cannot make a service that is starting at that moment fail."""
+    name = lock_name(lock_path)
+    if name is None:
+        return None
+    if WINDOWS:
+        return _pipe_exists(name)
+    try:
+        with open("/proc/net/unix", encoding="utf-8", errors="replace") as table:
+            return any(line.rstrip("\n").endswith(" @" + name[1:]) for line in table)
+    except OSError:
+        return None
+
+
+def _read_pid(path: Path) -> Optional[int]:
+    try:
+        text = path.read_text().strip()
+        return int(text) if re.fullmatch(r"[0-9]{1,10}", text, re.ASCII) else None
+    except OSError:
+        return None
+
+
+#: The managers a supervisor marker may name (DEC-0057): the three systems' supervisors and Project Observatory's node.
+SUPERVISORS = ("launchd", "systemd", "task-scheduler", "node")
+
+
+#: The argument form of the marker, for a supervisor whose start carries no environment (a Scheduled Task's action).
+SUPERVISOR_ARG = "--fabric-supervisor"
+
+
+def _marker_arguments(argv: Sequence[Any]) -> List[str]:
+    """The marker values an argument vector carries after the executable and before ``--``. A bare
+    ``--fabric-supervisor`` followed by nothing, by ``--`` or by another ``--…`` flag is a marker with an empty value
+    and consumes nothing."""
+    values: List[str] = []
+    index = 1
+    while index < len(argv):
+        item = argv[index]
+        if item == "--":
+            break
+        if item == SUPERVISOR_ARG:
+            following = argv[index + 1] if index + 1 < len(argv) else None
+            if isinstance(following, str) and not following.startswith("--"):
+                values.append(following)
+                index += 1
+            else:
+                values.append("")
+        elif isinstance(item, str) and item.startswith(SUPERVISOR_ARG + "="):
+            values.append(item[len(SUPERVISOR_ARG) + 1:])
+        index += 1
+    return values
+
+
+def supervisor_marker(env: Optional[Dict[str, str]] = None, argv: Optional[Sequence[str]] = None) -> Dict[str, Any]:
+    """How this copy was started (DEC-0057), from ``FABRIC_SERVICE_SUPERVISOR=<manager>`` and
+    ``--fabric-supervisor <manager>`` / ``--fabric-supervisor=<manager>`` (``env`` and ``argv`` default to this process's):
+
+    - ``{"kind": "supervised", "manager", "forms"}`` — every marker present names the same manager of SUPERVISORS;
+    - ``{"kind": "conflict", "values", "forms"}`` — the markers disagree: the copy is unsupervised and exits 75 at once,
+      before it takes the lock (an empty or bare argument beside a variable disagrees with it);
+    - ``{"kind": "manual", "forms", "unreadable"?}`` — no marker (only an empty variable counts as none), or one that
+      names no manager.
+
+    A copy never infers supervision from its parent process. The contract's ``supervisorMarker``."""
+    env = os.environ if env is None else env
+    argv = sys.argv if argv is None else argv
+    variable = env.get(SUPERVISOR_ENV) if isinstance(env, dict) or hasattr(env, "get") else None
+    from_env = [variable] if isinstance(variable, str) and variable != "" else []
+    from_args = _marker_arguments(list(argv) if isinstance(argv, (list, tuple)) else [])
+    forms = (["environment"] if from_env else []) + (["argument"] if from_args else [])
+    values: List[str] = []
+    for value in from_env + from_args:
+        if value not in values:
+            values.append(value)
+    if len(values) > 1:
+        return {"kind": "conflict", "values": values, "forms": forms}
+    if not values:
+        return {"kind": "manual", "forms": forms}
+    if values[0] in SUPERVISORS:
+        return {"kind": "supervised", "manager": values[0], "forms": forms}
+    return {"kind": "manual", "unreadable": values[0], "forms": forms}
+
+
+def lock_wait_budget_seconds(marker: Dict[str, Any]) -> float:
+    """How long a copy started so may wait for the lock: 300 s when supervised, else not at all."""
+    return LOCK_WAIT_SUPERVISED_SECONDS if marker.get("kind") == "supervised" else 0.0
+
+
+def marker_conflict_message(marker: Dict[str, Any]) -> str:
+    """The one sentence a copy whose markers disagree exits with, naming the markers present."""
+    shown = ", ".join(repr(v) for v in marker["values"])
+    if marker["forms"] == ["environment", "argument"]:
+        return "%s and %s disagree (%s); not starting unsupervised." % (SUPERVISOR_ENV, SUPERVISOR_ARG, shown)
+    return "%s is given with different values (%s); not starting unsupervised." % (SUPERVISOR_ARG, shown)
+
+
+def supervised(env: Optional[Dict[str, str]] = None, argv: Optional[Sequence[str]] = None) -> bool:
+    """True when a supervisor that restarts on exit started this process and said so with the marker
+    (``launchd_plist`` and ``systemd_unit`` set the variable, ``task_xml`` writes the argument, a node sets either)."""
+    return supervisor_marker(env, argv)["kind"] == "supervised"
+
+
+def supervised_by_launchd(env: Optional[Dict[str, str]] = None, argv: Optional[Sequence[str]] = None) -> bool:
+    """True when launchd started this process from a plist written by ``launchd_plist``.
+
+    The plist says so explicitly (``FABRIC_SERVICE_SUPERVISOR=launchd``); the parent process or
+    ``XPC_SERVICE_NAME`` is not evidence — a terminal inside an app carries one too."""
+    return supervisor_marker(env, argv).get("manager") == "launchd"
+
+
+def add_supervisor_argument(parser: Any) -> Any:
+    """Let a service's own argparse parser accept the marker in both spellings, and a bare one, and ignore it
+    (DEC-0057: argparse exits 2 on an unknown flag). The kit reads the marker from ``sys.argv`` itself."""
+    import argparse
+    parser.add_argument(SUPERVISOR_ARG, nargs="?", const="", default=None, help=argparse.SUPPRESS)
+    return parser
+
+
+def hold_single_instance(data_dir: Path, wait_seconds: Optional[float] = None, *,
+                         sleep: Callable[[float], None] = time.sleep,
+                         clock: Callable[[], float] = time.monotonic,
+                         env: Optional[Dict[str, str]] = None, argv: Optional[Sequence[str]] = None) -> InstanceLock:
+    """Take the lock or exit 75 with one sentence naming the holder (DEC-0057, FAC-SEM-078).
+
+    Markers that disagree exit 75 at once, before the lock, naming them. Started by hand (no
+    marker), a held lock exits 75 at once. Under a supervisor that restarts on exit an immediate
+    exit is a respawn every few seconds, forever; so a supervised copy first backs off in-process
+    (0.5 s doubling to 30 s, ``LOCK_WAIT_SUPERVISED_SECONDS`` in all), takes over if the holder
+    leaves, and exits 75 only when the wait runs out. Nothing has been touched while it waits.
+    ``wait_seconds`` overrides the choice (0 = never wait); ``env`` and ``argv`` default to this process's."""
+    marker = supervisor_marker(env, argv)
+    if marker["kind"] == "conflict":
+        print(marker_conflict_message(marker), file=sys.stderr)
+        raise SystemExit(EXIT_ALREADY_RUNNING)
+    if wait_seconds is None:
+        wait_seconds = lock_wait_budget_seconds(marker)
+    deadline = clock() + max(0.0, wait_seconds)
+    delay = LOCK_BACKOFF_FIRST_SECONDS
+    announced = False
+    while True:
+        try:
+            return InstanceLock(data_dir).acquire()
+        except AlreadyRunning as exc:
+            remaining = deadline - clock()
+            if remaining <= 0:
+                print(str(exc), file=sys.stderr)
+                raise SystemExit(EXIT_ALREADY_RUNNING)
+            if not announced:
+                print("%s Waiting up to %.0f s for it to exit." % (exc, remaining), file=sys.stderr, flush=True)
+                announced = True
+            sleep(min(delay, remaining))
+            delay = min(delay * 2, LOCK_BACKOFF_MAX_SECONDS)