gitgrip 1.5.0__py3-none-any.whl

gr2/prototypes/cache_materialization_probe.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Prototype cache-backed materialization for gr2 working clones.
+
+This is not a final implementation. It exists to answer a narrower question:
+
+- if `apply` seeds working clones from a local mirror/reference cache, does that
+  materially improve materialization speed while keeping the user-facing model
+  unchanged?
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+
+PLAYGROUND_REPOS = {
+    "app": {
+        "ssh": "git@github.com:synapt-dev/gr2-playground-app.git",
+        "https": "https://github.com/synapt-dev/gr2-playground-app.git",
+    },
+    "api": {
+        "ssh": "git@github.com:synapt-dev/gr2-playground-api.git",
+        "https": "https://github.com/synapt-dev/gr2-playground-api.git",
+    },
+    "web": {
+        "ssh": "git@github.com:synapt-dev/gr2-playground-web.git",
+        "https": "https://github.com/synapt-dev/gr2-playground-web.git",
+    },
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Measure direct clone vs cache-backed clone materialization"
+    )
+    parser.add_argument(
+        "--transport",
+        choices=["ssh", "https"],
+        default="ssh",
+        help="remote transport to test",
+    )
+    parser.add_argument(
+        "--repo",
+        action="append",
+        dest="repos",
+        help="repo(s) to test; defaults to all playground repos",
+    )
+    parser.add_argument(
+        "--workspace-root",
+        type=Path,
+        help="optional persistent temp root; defaults to a temporary directory",
+    )
+    parser.add_argument("--json", action="store_true")
+    return parser.parse_args()
+
+
+def repo_url(repo_name: str, transport: str) -> str:
+    return PLAYGROUND_REPOS[repo_name][transport]
+
+
+def git_env() -> dict[str, str]:
+    env = dict(os.environ)
+    env.setdefault(
+        "GIT_SSH_COMMAND",
+        "ssh -o BatchMode=yes -o ConnectTimeout=5 -o StrictHostKeyChecking=accept-new",
+    )
+    return env
+
+
+def run(argv: list[str], *, cwd: Path | None = None) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        argv,
+        cwd=cwd,
+        text=True,
+        capture_output=True,
+        check=True,
+        env=git_env(),
+    )
+
+
+def timed_clone(argv: list[str], *, cwd: Path | None = None) -> tuple[float, subprocess.CompletedProcess[str]]:
+    start = time.perf_counter()
+    result = run(argv, cwd=cwd)
+    elapsed = time.perf_counter() - start
+    return (elapsed, result)
+
+
+def verify_working_clone(path: Path) -> dict[str, object]:
+    head = run(["git", "-C", str(path), "rev-parse", "--abbrev-ref", "HEAD"]).stdout.strip()
+    status = run(["git", "-C", str(path), "status", "--short"]).stdout.strip()
+    alternates = path / ".git" / "objects" / "info" / "alternates"
+    return {
+        "head": head,
+        "clean": status == "",
+        "uses_alternates": alternates.exists(),
+        "alternates_path": str(alternates) if alternates.exists() else None,
+    }
+
+
+def probe_repo(root: Path, repo_name: str, transport: str) -> dict[str, object]:
+    url = repo_url(repo_name, transport)
+    repo_root = root / repo_name
+    direct_root = repo_root / "direct"
+    cached_root = repo_root / "cached"
+    cache_root = repo_root / "cache"
+    direct_root.mkdir(parents=True, exist_ok=True)
+    cached_root.mkdir(parents=True, exist_ok=True)
+    cache_root.mkdir(parents=True, exist_ok=True)
+
+    direct_target = direct_root / repo_name
+    cache_mirror = cache_root / f"{repo_name}.git"
+    cached_target = cached_root / repo_name
+
+    direct_seconds, _ = timed_clone(["git", "clone", url, str(direct_target)])
+    mirror_seconds, _ = timed_clone(["git", "clone", "--mirror", url, str(cache_mirror)])
+    cached_seconds, _ = timed_clone(
+        [
+            "git",
+            "clone",
+            "--reference-if-able",
+            str(cache_mirror),
+            url,
+            str(cached_target),
+        ]
+    )
+
+    direct_info = verify_working_clone(direct_target)
+    cached_info = verify_working_clone(cached_target)
+
+    return {
+        "repo": repo_name,
+        "transport": transport,
+        "direct_clone_seconds": round(direct_seconds, 3),
+        "mirror_seed_seconds": round(mirror_seconds, 3),
+        "cached_clone_seconds": round(cached_seconds, 3),
+        "delta_seconds": round(direct_seconds - cached_seconds, 3),
+        "direct_clone": direct_info,
+        "cached_clone": cached_info,
+        "mirror_path": str(cache_mirror),
+    }
+
+
+def main() -> int:
+    args = parse_args()
+    repos = args.repos or list(PLAYGROUND_REPOS.keys())
+    unknown = [repo for repo in repos if repo not in PLAYGROUND_REPOS]
+    if unknown:
+        raise SystemExit("unknown repos: " + ", ".join(unknown))
+
+    if args.workspace_root:
+        root = args.workspace_root.resolve()
+        root.mkdir(parents=True, exist_ok=True)
+        cleanup = False
+    else:
+        root = Path(tempfile.mkdtemp(prefix="gr2-cache-probe."))
+        cleanup = True
+
+    try:
+        rows = [probe_repo(root, repo, args.transport) for repo in repos]
+        if args.json:
+            print(json.dumps({"root": str(root), "results": rows}, indent=2))
+        else:
+            print(f"root: {root}")
+            print("REPO\tTRANSPORT\tDIRECT_S\tMIRROR_S\tCACHED_S\tDELTA_S\tALTERNATES")
+            for row in rows:
+                print(
+                    f"{row['repo']}\t{row['transport']}\t{row['direct_clone_seconds']}\t"
+                    f"{row['mirror_seed_seconds']}\t{row['cached_clone_seconds']}\t"
+                    f"{row['delta_seconds']}\t{str(row['cached_clone']['uses_alternates']).lower()}"
+                )
+            print("notes:")
+            print("- direct clone is a normal working clone from remote")
+            print("- mirror seed is the one-time cache population cost")
+            print("- cached clone is a working clone using --reference-if-able from the local mirror")
+        return 0
+    finally:
+        if cleanup:
+            shutil.rmtree(root)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gr2/prototypes/concurrent_event_stress.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Repeated before/after stress harness for event-log sequence integrity."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import multiprocessing
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+SOURCE_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SOURCE_ROOT))
+
+from python_cli.events import EventType, emit  # noqa: E402
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--rounds", type=int, default=30)
+    parser.add_argument("--writers", type=int, default=2)
+    parser.add_argument("--json", action="store_true")
+    return parser.parse_args()
+
+
+def _worker(
+    workspace: str,
+    actor: str,
+    start: object,
+    queue: object,
+    unlocked: bool,
+    expected_source_root: str,
+) -> None:
+    try:
+        import gr2
+
+        module_file = Path(gr2.__file__).resolve() if gr2.__file__ is not None else None
+        source_root = Path(expected_source_root).resolve()
+        if module_file is None or not module_file.is_relative_to(source_root):
+            raise RuntimeError(
+                f"spawned worker imported gr2 outside expected worktree: "
+                f"module={module_file}, expected_root={source_root}"
+            )
+        if unlocked:
+            os.environ["GR2_DISABLE_EVENT_LOCKING"] = "1"
+            os.environ["GR2_EVENT_TEST_DELAY"] = "0.03"
+        if not start.wait(timeout=10):
+            raise TimeoutError("start gate timed out")
+        emit(
+            event_type=EventType.LANE_ENTERED,
+            workspace_root=Path(workspace),
+            actor=actor,
+            owner_unit="event-stress",
+            payload={"round_actor": actor},
+        )
+    except Exception as exc:
+        queue.put({"ok": False, "error": repr(exc)})
+    else:
+        queue.put({"ok": True, "gr2_module": str(module_file)})
+
+
+def _read_rows(outbox: Path) -> tuple[list[dict[str, object]], int]:
+    rows: list[dict[str, object]] = []
+    corruption_count = 0
+    for line in outbox.read_text().splitlines() if outbox.exists() else []:
+        try:
+            row = json.loads(line)
+        except json.JSONDecodeError:
+            corruption_count += 1
+            continue
+        if not isinstance(row, dict):
+            corruption_count += 1
+            continue
+        rows.append(row)
+    return rows, corruption_count
+
+
+def prove_corruption_detector() -> dict[str, object]:
+    """Prove the reported zero can distinguish a known malformed event."""
+    with tempfile.TemporaryDirectory(prefix="gr2-event-corruption-control-") as tmp:
+        outbox = Path(tmp) / "outbox.jsonl"
+        outbox.write_text("{malformed-json\n")
+        _, corruption_count = _read_rows(outbox)
+    return {
+        "proven": corruption_count == 1,
+        "fixture": "malformed-json",
+        "detected_count": corruption_count,
+    }
+
+
+def _run_round(writers: int, unlocked: bool) -> dict[str, object]:
+    ctx = multiprocessing.get_context("spawn")
+    with tempfile.TemporaryDirectory(prefix="gr2-event-stress-") as tmp:
+        workspace = Path(tmp)
+        (workspace / ".grip").mkdir()
+        start = ctx.Event()
+        queue = ctx.Queue()
+        processes = [
+            ctx.Process(
+                target=_worker,
+                args=(
+                    str(workspace),
+                    f"writer:{index}",
+                    start,
+                    queue,
+                    unlocked,
+                    str(SOURCE_ROOT),
+                ),
+            )
+            for index in range(writers)
+        ]
+        for process in processes:
+            process.start()
+        start.set()
+        for process in processes:
+            process.join(timeout=15)
+        outcomes = [queue.get(timeout=2) for _ in processes]
+        rows, corruption_count = _read_rows(workspace / ".grip" / "events" / "outbox.jsonl")
+        seqs = [row.get("seq") for row in rows]
+        return {
+            "all_workers_succeeded": all(outcome["ok"] for outcome in outcomes),
+            "lost_events": len(rows) != writers,
+            "duplicate_seq": len(seqs) != len(set(seqs)),
+            "corruption_count": corruption_count,
+        }
+
+
+def run_phase(*, rounds: int, writers: int, unlocked: bool) -> dict[str, object]:
+    results = [_run_round(writers, unlocked) for _ in range(rounds)]
+    return {
+        "locking": "disabled" if unlocked else "enabled",
+        "rounds": rounds,
+        "writers": writers,
+        "duplicate_seq_rounds": sum(bool(row["duplicate_seq"]) for row in results),
+        "lost_event_rounds": sum(bool(row["lost_events"]) for row in results),
+        "corruption_count": sum(int(row["corruption_count"]) for row in results),
+        "worker_failure_rounds": sum(not bool(row["all_workers_succeeded"]) for row in results),
+    }
+
+
+def sequential_control(writes: int = 8) -> dict[str, object]:
+    with tempfile.TemporaryDirectory(prefix="gr2-event-sequential-control-") as tmp:
+        workspace = Path(tmp)
+        (workspace / ".grip").mkdir()
+        old_disabled = os.environ.get("GR2_DISABLE_EVENT_LOCKING")
+        old_delay = os.environ.get("GR2_EVENT_TEST_DELAY")
+        os.environ["GR2_DISABLE_EVENT_LOCKING"] = "1"
+        os.environ["GR2_EVENT_TEST_DELAY"] = "0"
+        try:
+            for index in range(writes):
+                emit(
+                    event_type=EventType.LANE_ENTERED,
+                    workspace_root=workspace,
+                    actor="sequential-control",
+                    owner_unit="event-stress",
+                    payload={"index": index},
+                )
+        finally:
+            if old_disabled is None:
+                os.environ.pop("GR2_DISABLE_EVENT_LOCKING", None)
+            else:
+                os.environ["GR2_DISABLE_EVENT_LOCKING"] = old_disabled
+            if old_delay is None:
+                os.environ.pop("GR2_EVENT_TEST_DELAY", None)
+            else:
+                os.environ["GR2_EVENT_TEST_DELAY"] = old_delay
+        rows, corruption_count = _read_rows(workspace / ".grip" / "events" / "outbox.jsonl")
+        seqs = [row.get("seq") for row in rows]
+        return {
+            "writes": writes,
+            "strictly_monotonic": seqs == list(range(1, writes + 1)),
+            "corruption_count": corruption_count,
+        }
+
+
+def main() -> int:
+    args = parse_args()
+    payload = {
+        "corruption_detector_control": prove_corruption_detector(),
+        "sequential_control": sequential_control(),
+        "before_locking": run_phase(rounds=args.rounds, writers=args.writers, unlocked=True),
+        "after_locking": run_phase(rounds=args.rounds, writers=args.writers, unlocked=False),
+    }
+    print(json.dumps(payload, indent=2))
+    after = payload["after_locking"]
+    return int(
+        not payload["corruption_detector_control"]["proven"]
+        or not payload["sequential_control"]["strictly_monotonic"]
+        or after["duplicate_seq_rounds"] != 0
+        or after["lost_event_rounds"] != 0
+        or after["corruption_count"] != 0
+        or after["worker_failure_rounds"] != 0
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gr2/prototypes/concurrent_lease_stress.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""Concurrent lease stress harness with before/after locking results."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import multiprocessing
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Run concurrent lease stress before and after file locking"
+    )
+    parser.add_argument("--rounds", type=int, default=50)
+    parser.add_argument("--json", action="store_true")
+    return parser.parse_args()
+
+
+def repo_root() -> Path:
+    return Path(__file__).resolve().parents[2]
+
+
+def lane_proto(root: Path) -> Path:
+    return root / "gr2" / "prototypes" / "lane_workspace_prototype.py"
+
+
+def run(
+    argv: list[str],
+    *,
+    env: dict | None = None,
+    check: bool = True,
+    capture: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(argv, check=check, text=True, capture_output=capture, env=env)
+
+
+def init_workspace(workspace_root: Path) -> None:
+    (workspace_root / ".grip").mkdir(parents=True, exist_ok=True)
+    (workspace_root / "agents").mkdir(exist_ok=True)
+    spec = """schema_version = 1
+workspace_name = "concurrent-lease-stress"
+
+[cache]
+root = ".grip/cache"
+
+[[repos]]
+name = "app"
+path = "repos/app"
+url = "https://example.invalid/app.git"
+
+[[units]]
+name = "atlas"
+path = "agents/atlas"
+agent_id = "atlas-agent"
+repos = ["app"]
+"""
+    (workspace_root / ".grip" / "workspace_spec.toml").write_text(spec)
+
+
+def create_lane(root: Path, workspace_root: Path) -> None:
+    run(
+        [
+            "python3",
+            str(lane_proto(root)),
+            "create-lane",
+            str(workspace_root),
+            "atlas",
+            "feat-race",
+            "--repos",
+            "app",
+            "--branch",
+            "feat/race",
+        ],
+        capture=True,
+    )
+
+
+def worker(workspace_root: str, actor: str, queue, disable_locking: bool) -> None:
+    root = repo_root()
+    env = os.environ.copy()
+    if disable_locking:
+        env["GR2_DISABLE_LEASE_LOCKING"] = "1"
+        env["GR2_LEASE_TEST_DELAY"] = "0.02"
+    proc = run(
+        [
+            "python3",
+            str(lane_proto(root)),
+            "acquire-lane-lease",
+            workspace_root,
+            "atlas",
+            "feat-race",
+            "--actor",
+            actor,
+            "--mode",
+            "edit",
+            "--ttl-seconds",
+            "900",
+        ],
+        env=env,
+        check=False,
+        capture=True,
+    )
+    queue.put(
+        {
+            "actor": actor,
+            "returncode": proc.returncode,
+            "stdout": proc.stdout,
+            "stderr": proc.stderr,
+        }
+    )
+
+
+def read_leases(workspace_root: Path) -> tuple[bool, list[dict] | None]:
+    path = workspace_root / "agents" / "atlas" / "lanes" / "feat-race" / "leases.json"
+    if not path.exists():
+        return True, []
+    try:
+        return True, json.loads(path.read_text())
+    except json.JSONDecodeError:
+        return False, None
+
+
+def prove_corruption_detector() -> dict[str, object]:
+    """Prove the corruption counter's detector with a known-bad lease file."""
+    with tempfile.TemporaryDirectory(prefix="gr2-lease-corruption-control-") as tmp:
+        workspace_root = Path(tmp)
+        lease_path = (
+            workspace_root
+            / "agents"
+            / "atlas"
+            / "lanes"
+            / "feat-race"
+            / "leases.json"
+        )
+        lease_path.parent.mkdir(parents=True)
+        lease_path.write_text("{malformed-json")
+        valid_json, _ = read_leases(workspace_root)
+    return {
+        "proven": not valid_json,
+        "fixture": "malformed-json",
+        "detected_as_corrupt": not valid_json,
+    }
+
+
+def release_all(root: Path, workspace_root: Path, disable_locking: bool) -> None:
+    env = os.environ.copy()
+    if disable_locking:
+        env["GR2_DISABLE_LEASE_LOCKING"] = "1"
+    for actor in ("worker:a", "worker:b"):
+        run(
+            [
+                "python3",
+                str(lane_proto(root)),
+                "release-lane-lease",
+                str(workspace_root),
+                "atlas",
+                "feat-race",
+                "--actor",
+                actor,
+            ],
+            env=env,
+            check=False,
+            capture=True,
+        )
+
+
+def run_phase(disable_locking: bool, rounds: int) -> dict:
+    root = repo_root()
+    with tempfile.TemporaryDirectory(prefix="gr2-concurrent-lease-") as tmp:
+        workspace_root = Path(tmp)
+        init_workspace(workspace_root)
+        create_lane(root, workspace_root)
+
+        corruption_count = 0
+        both_succeeded_count = 0
+        unexpected_lease_count = 0
+
+        for _ in range(rounds):
+            queue = multiprocessing.Queue()
+            p1 = multiprocessing.Process(
+                target=worker,
+                args=(str(workspace_root), "worker:a", queue, disable_locking),
+            )
+            p2 = multiprocessing.Process(
+                target=worker,
+                args=(str(workspace_root), "worker:b", queue, disable_locking),
+            )
+            p1.start()
+            p2.start()
+            p1.join()
+            p2.join()
+
+            results = [queue.get(), queue.get()]
+            success_count = sum(1 for item in results if item["returncode"] == 0)
+            if success_count == 2:
+                both_succeeded_count += 1
+
+            valid_json, leases = read_leases(workspace_root)
+            if not valid_json:
+                corruption_count += 1
+            else:
+                expected = 1 if success_count >= 1 else 0
+                if len(leases or []) != expected:
+                    unexpected_lease_count += 1
+
+            release_all(root, workspace_root, disable_locking)
+
+        return {
+            "locking": "disabled" if disable_locking else "enabled",
+            "rounds": rounds,
+            "corruption_count": corruption_count,
+            "both_succeeded_count": both_succeeded_count,
+            "unexpected_lease_count": unexpected_lease_count,
+        }
+
+
+def main() -> int:
+    args = parse_args()
+    before = run_phase(disable_locking=True, rounds=args.rounds)
+    after = run_phase(disable_locking=False, rounds=args.rounds)
+    payload = {
+        "corruption_detector_control": prove_corruption_detector(),
+        "before_locking": before,
+        "after_locking": after,
+    }
+    if args.json:
+        print(json.dumps(payload, indent=2))
+    else:
+        print("gr2 concurrent lease stress")
+        print(json.dumps(payload, indent=2))
+    return 0 if payload["corruption_detector_control"]["proven"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())