gitgrip 1.5.0__py3-none-any.whl

gr2/python_cli/execops.py

@@ -0,0 +1,372 @@
+from __future__ import annotations
+
+import json
+import subprocess
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+
+from gr2.prototypes import lane_workspace_prototype as lane_proto
+from gr2.python_cli.events import EventType, emit_after_outcome
+
+
+@dataclass
+class ExecResult:
+    repo: str
+    cwd: str
+    status: str
+    returncode: int | None
+    stdout: str
+    stderr: str
+
+    @property
+    def succeeded(self) -> bool:
+        return self.status == "ok"
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "repo": self.repo,
+            "cwd": self.cwd,
+            "status": self.status,
+            "returncode": self.returncode,
+            "stdout": self.stdout,
+            "stderr": self.stderr,
+        }
+
+
+def _exec_one(command: list[str], repo: str, cwd: str) -> ExecResult:
+    cwd_path = Path(cwd)
+    if not cwd_path.exists():
+        return ExecResult(
+            repo=repo, cwd=cwd, status="missing",
+            returncode=None, stdout="",
+            stderr=f"lane repo checkout missing: {cwd}",
+        )
+    proc = subprocess.run(command, cwd=cwd_path, capture_output=True, text=True, check=False)
+    return ExecResult(
+        repo=repo, cwd=cwd,
+        status="ok" if proc.returncode == 0 else "failed",
+        returncode=proc.returncode,
+        stdout=proc.stdout, stderr=proc.stderr,
+    )
+
+
+def run_exec_parallel(
+    command: list[str],
+    repo_rows: list[dict[str, str]],
+    max_workers: int = 4,
+) -> list[ExecResult]:
+    futures_map: dict[int, object] = {}
+    results: list[ExecResult | None] = [None] * len(repo_rows)
+
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        for idx, row in enumerate(repo_rows):
+            future = pool.submit(_exec_one, command, row["repo"], row["cwd"])
+            futures_map[id(future)] = (idx, future)
+
+        for _, (idx, future) in futures_map.items():
+            results[idx] = future.result()
+
+    return [r for r in results if r is not None]
+
+
+def _resolve_lane_name(workspace_root: Path, owner_unit: str, lane_name: str | None) -> str:
+    if lane_name:
+        return lane_name
+    current = lane_proto.require_current_lane(workspace_root, owner_unit)
+    return str(current["lane_name"])
+
+
+def _selected_repos(lane_doc: dict[str, object], repos: str | None) -> list[str]:
+    selected = [str(repo) for repo in lane_doc.get("repos", [])]
+    if repos:
+        requested = set(lane_proto.parse_repo_list(repos))
+        selected = [repo for repo in selected if repo in requested]
+    return selected
+
+
+def _blocked_payload(
+    *,
+    reason: str,
+    lane_doc: dict[str, object],
+    owner_unit: str,
+    extra: dict[str, object] | None = None,
+) -> dict[str, object]:
+    payload = {
+        "status": "blocked",
+        "reason": reason,
+        "lane": str(lane_doc["lane_name"]),
+        "owner_unit": owner_unit,
+    }
+    if extra:
+        payload.update(extra)
+    return payload
+
+
+def exec_status_payload(
+    workspace_root: Path,
+    owner_unit: str,
+    lane_name: str | None,
+    *,
+    repos: str | None = None,
+    actor: str = "agent:exec-status",
+) -> dict[str, object]:
+    owner_unit = str(owner_unit)
+    lane_name = _resolve_lane_name(workspace_root, owner_unit, lane_name)
+    lane_doc = lane_proto.load_lane_doc(workspace_root, owner_unit, lane_name)
+
+    leases = lane_proto.load_lane_leases(workspace_root, owner_unit, lane_name)
+    active_conflicts, stale_conflicts = lane_proto.conflicting_leases(leases, actor, "exec")
+    if active_conflicts:
+        return _blocked_payload(
+            reason="conflicting-active-lease",
+            lane_doc=lane_doc,
+            owner_unit=owner_unit,
+            extra={"requested_mode": "exec", "conflicting_leases": active_conflicts},
+        )
+    if stale_conflicts:
+        return _blocked_payload(
+            reason="stale-conflicting-lease",
+            lane_doc=lane_doc,
+            owner_unit=owner_unit,
+            extra={
+                "requested_mode": "exec",
+                "conflicting_leases": stale_conflicts,
+                "hint": "break stale leases with gr2 lane lease acquire --force or clean them up first",
+            },
+        )
+
+    selected_repos = _selected_repos(lane_doc, repos)
+    rows: list[dict[str, object]] = []
+    for repo in selected_repos:
+        cwd = lane_proto.lane_dir(workspace_root, owner_unit, lane_name) / "repos" / repo
+        rows.append(
+            {
+                "lane": lane_name,
+                "owner_unit": owner_unit,
+                "repo": repo,
+                "branch": dict(lane_doc.get("branch_map", {})).get(repo),
+                "cwd": str(cwd),
+                "exists": cwd.exists(),
+                "shared_context_roots": lane_doc.get("context", {}).get("shared_roots", []),
+                "private_context_roots": lane_doc.get("context", {}).get("private_roots", []),
+                "parallelism": lane_doc["exec_defaults"].get("parallelism"),
+                "fail_fast": bool(lane_doc["exec_defaults"].get("fail_fast", True)),
+                "default_command_family": lane_doc["exec_defaults"].get("default_command_family", []),
+                "commands": lane_doc["exec_defaults"].get("commands", []),
+            }
+        )
+
+    return {
+        "status": "ready",
+        "lane": lane_name,
+        "owner_unit": owner_unit,
+        "lane_type": lane_doc["lane_type"],
+        "rows": rows,
+    }
+
+
+def render_exec_status(payload: dict[str, object]) -> str:
+    if payload["status"] != "ready":
+        lines = [
+            "ExecStatus",
+            f"status = {payload['status']}",
+            f"reason = {payload['reason']}",
+            f"owner_unit = {payload['owner_unit']}",
+            f"lane = {payload['lane']}",
+        ]
+        if "hint" in payload:
+            lines.append(f"hint = {payload['hint']}")
+        return "\n".join(lines)
+
+    lines = [
+        "ExecStatus",
+        f"status = {payload['status']}",
+        f"owner_unit = {payload['owner_unit']}",
+        f"lane = {payload['lane']}",
+        f"lane_type = {payload['lane_type']}",
+        "REPO\tBRANCH\tEXISTS\tCWD",
+    ]
+    for row in payload["rows"]:
+        lines.append(f"{row['repo']}\t{row['branch']}\t{row['exists']}\t{row['cwd']}")
+    return "\n".join(lines)
+
+
+def _emit_lease_event(
+    workspace_root: Path,
+    *,
+    owner_unit: str,
+    lane_name: str,
+    actor: str,
+    event_type: str,
+    ttl_seconds: int | None = None,
+) -> None:
+    lane_doc = lane_proto.load_lane_doc(workspace_root, owner_unit, lane_name)
+    payload = {
+        "type": event_type,
+        "agent": actor,
+        "owner_unit": owner_unit,
+        "lane": lane_name,
+        "lane_type": lane_doc["lane_type"],
+        "repos": lane_doc.get("repos", []),
+        "timestamp": lane_proto.now_utc(),
+    }
+    if ttl_seconds is not None:
+        payload["lease_mode"] = "exec"
+        payload["ttl_seconds"] = ttl_seconds
+    lane_proto.emit_lane_event(workspace_root, payload)
+
+
+def acquire_exec_lease(workspace_root: Path, owner_unit: str, lane_name: str, actor: str, ttl_seconds: int) -> None:
+    def mutator(leases: list[dict]) -> dict:
+        retained = [lease for lease in leases if lease["actor"] != actor]
+        active_conflicts, stale_conflicts = lane_proto.conflicting_leases(retained, actor, "exec")
+        if active_conflicts:
+            return {"status": "blocked", "payload": {"reason": "conflicting-active-lease", "conflicting_leases": active_conflicts}, "write": False}
+        if stale_conflicts:
+            return {"status": "blocked", "payload": {"reason": "stale-conflicting-lease", "conflicting_leases": stale_conflicts}, "write": False}
+        retained.append(lane_proto.build_lease(actor, "exec", ttl_seconds))
+        return {"status": "ok", "leases": retained, "write": True}
+
+    result = lane_proto.mutate_lane_leases(workspace_root, owner_unit, lane_name, mutator)
+    if result["status"] == "blocked":
+        raise SystemExit(json.dumps(result["payload"], indent=2))
+    _emit_lease_event(
+        workspace_root,
+        owner_unit=owner_unit,
+        lane_name=lane_name,
+        actor=actor,
+        event_type="lease_acquire",
+        ttl_seconds=ttl_seconds,
+    )
+
+
+def release_exec_lease(workspace_root: Path, owner_unit: str, lane_name: str, actor: str) -> None:
+    lane_proto.mutate_lane_leases(
+        workspace_root,
+        owner_unit,
+        lane_name,
+        lambda leases: {
+            "status": "ok",
+            "leases": [lease for lease in leases if lease["actor"] != actor],
+            "write": True,
+        },
+    )
+    _emit_lease_event(
+        workspace_root,
+        owner_unit=owner_unit,
+        lane_name=lane_name,
+        actor=actor,
+        event_type="lease_release",
+    )
+
+
+def run_exec(
+    workspace_root: Path,
+    owner_unit: str,
+    lane_name: str | None,
+    *,
+    actor: str,
+    command: list[str],
+    repos: str | None = None,
+    ttl_seconds: int = 900,
+) -> dict[str, object]:
+    status = exec_status_payload(workspace_root, owner_unit, lane_name, repos=repos, actor=actor)
+    if status["status"] != "ready":
+        return status
+
+    resolved_lane = str(status["lane"])
+    rows = list(status["rows"])
+    fail_fast = bool(rows[0]["fail_fast"]) if rows else True
+    parallelism = str(rows[0]["parallelism"]) if rows else "sequential"
+    acquire_exec_lease(workspace_root, owner_unit, resolved_lane, actor, ttl_seconds)
+
+    emit_after_outcome(
+        event_type=EventType.EXEC_STARTED,
+        workspace_root=workspace_root,
+        actor=actor,
+        owner_unit=owner_unit,
+        payload={
+            "lane": resolved_lane,
+            "command": command,
+            "repos": [r["repo"] for r in rows],
+            "parallelism": parallelism,
+        },
+    )
+
+    exec_results: list[ExecResult] = []
+    overall = "success"
+
+    try:
+        if parallelism == "parallel":
+            repo_rows = [{"repo": r["repo"], "cwd": str(r["cwd"])} for r in rows]
+            exec_results = run_exec_parallel(command, repo_rows)
+            if any(not r.succeeded for r in exec_results):
+                overall = "failed"
+        else:
+            for row in rows:
+                r = _exec_one(command, str(row["repo"]), str(row["cwd"]))
+                exec_results.append(r)
+                if not r.succeeded:
+                    overall = "failed"
+                    if fail_fast:
+                        break
+    finally:
+        release_exec_lease(workspace_root, owner_unit, resolved_lane, actor)
+
+    result_dicts = [r.to_dict() for r in exec_results]
+    failed_repos = [r.repo for r in exec_results if not r.succeeded]
+
+    if overall == "success":
+        emit_after_outcome(
+            event_type=EventType.EXEC_COMPLETED,
+            workspace_root=workspace_root,
+            actor=actor,
+            owner_unit=owner_unit,
+            payload={
+                "lane": resolved_lane,
+                "command": command,
+                "overall_status": "success",
+                "repo_count": len(exec_results),
+            },
+        )
+    else:
+        emit_after_outcome(
+            event_type=EventType.EXEC_FAILED,
+            workspace_root=workspace_root,
+            actor=actor,
+            owner_unit=owner_unit,
+            payload={
+                "lane": resolved_lane,
+                "command": command,
+                "overall_status": "failed",
+                "failed_repos": failed_repos,
+                "repo_count": len(exec_results),
+            },
+        )
+
+    return {
+        "status": overall,
+        "owner_unit": owner_unit,
+        "lane": resolved_lane,
+        "command": command,
+        "results": result_dicts,
+    }
+
+
+def render_exec_run(payload: dict[str, object]) -> str:
+    if payload.get("status") == "blocked":
+        return render_exec_status(payload)
+    lines = [
+        "ExecRun",
+        f"status = {payload['status']}",
+        f"owner_unit = {payload['owner_unit']}",
+        f"lane = {payload['lane']}",
+        f"command = {' '.join(payload['command'])}",
+        "REPO\tSTATUS\tRETURNCODE\tCWD",
+    ]
+    for result in payload["results"]:
+        lines.append(
+            f"{result['repo']}\t{result['status']}\t{result['returncode']}\t{result['cwd']}"
+        )
+    return "\n".join(lines)

gr2/python_cli/failures.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import json
+import os
+from datetime import UTC, datetime
+from pathlib import Path
+
+from .events import EventType, emit_after_outcome
+
+
+def _now_utc() -> str:
+    return datetime.now(UTC).isoformat()
+
+
+def failures_root(workspace_root: Path) -> Path:
+    return workspace_root / ".grip" / "state" / "failures"
+
+
+def failure_marker_path(workspace_root: Path, operation_id: str) -> Path:
+    return failures_root(workspace_root) / f"{operation_id}.json"
+
+
+def unresolved_lane_failure(workspace_root: Path, owner_unit: str, lane_name: str) -> dict[str, object] | None:
+    root = failures_root(workspace_root)
+    if not root.exists():
+        return None
+    for path in sorted(root.glob("*.json")):
+        doc = json.loads(path.read_text())
+        if doc.get("resolved") is True:
+            continue
+        if doc.get("owner_unit") == owner_unit and doc.get("lane_name") == lane_name:
+            return doc
+    return None
+
+
+def write_failure_marker(
+    workspace_root: Path,
+    *,
+    operation: str,
+    stage: str,
+    hook_name: str,
+    repo: str,
+    owner_unit: str,
+    lane_name: str,
+    partial_state: dict[str, object] | None = None,
+    event_id: str | None = None,
+) -> dict[str, object]:
+    operation_id = f"op_{os.urandom(4).hex()}"
+    marker = {
+        "operation_id": operation_id,
+        "operation": operation,
+        "stage": stage,
+        "hook_name": hook_name,
+        "repo": repo,
+        "owner_unit": owner_unit,
+        "lane_name": lane_name,
+        "failed_at": _now_utc(),
+        "event_id": event_id,
+        "partial_state": partial_state or {},
+        "resolved": False,
+    }
+    path = failure_marker_path(workspace_root, operation_id)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(marker, indent=2) + "\n")
+    return marker
+
+
+def resolve_failure_marker(
+    workspace_root: Path,
+    *,
+    operation_id: str,
+    resolved_by: str,
+    resolution: str,
+    owner_unit: str,
+) -> dict[str, object]:
+    path = failure_marker_path(workspace_root, operation_id)
+    if not path.exists():
+        raise SystemExit(f"failure marker not found: {operation_id}")
+    marker = json.loads(path.read_text())
+    path.unlink()
+    emit_after_outcome(
+        event_type=EventType.FAILURE_RESOLVED,
+        workspace_root=workspace_root,
+        actor=resolved_by,
+        owner_unit=owner_unit,
+        payload={
+            "operation_id": operation_id,
+            "resolved_by": resolved_by,
+            "resolution": resolution,
+            "lane_name": marker.get("lane_name", ""),
+        },
+    )
+    return {
+        "operation_id": operation_id,
+        "resolved_by": resolved_by,
+        "resolution": resolution,
+        "lane_name": marker.get("lane_name", ""),
+    }