rig-cli 1.0.0__py3-none-any.whl

rig/commands/down/runner.py

@@ -0,0 +1,136 @@
+"""Checkout-specific teardown and service stopping."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+from rig.commands.common import (
+    _consumers_of,
+    _merged_depends_on,
+    _resolve_manifest_context,
+    _stop_record,
+    reverse_dependency_order,
+)
+from rig.core.constants import EXIT_OK, EXIT_OP_FAILED, EXIT_REFUSED
+from rig.core.errors import RigError, format_human_error, print_json_envelope
+from rig.core.locks import exclusive_lock
+from rig.core.state import read_state, write_state
+from rig.core.terminal import get_theme
+from rig.net.ports import wait_for_port_release
+
+
+def _stop_service_checkout(
+    name: str, state: dict[str, Any], ctx: tuple[Path, Path]
+) -> tuple[bool, str | None]:
+    root_path, state_path = ctx
+    if not (rec := state.get("services", {}).get(name)):
+        return False, None
+    outcome = _stop_record(rec, root_path)
+    if outcome in ("terminated", "killed", "stale"):
+        port = rec.get("port")
+        state["services"].pop(name, None)
+        write_state(state_path, state)
+        held = bool(port and not wait_for_port_release(int(port)))
+        return True, f"{name}: port {port} still held" if held else None
+    return False, f"{name}: {outcome}"
+
+
+def _stop_target_step(
+    name: str,
+    state: dict[str, Any],
+    ctx: tuple[Any, tuple[Path, Path], tuple[list[str], list[str], set[str]]],
+) -> None:
+    manifest, paths, tracking = ctx
+    root_path, state_path = paths
+    stopped, failures, failed_svcs = tracking
+    services = state.get("services", {})
+    if name not in services:
+        return
+    deps = [d for d in _consumers_of(name, services, manifest) if d in failed_svcs or d in services]
+    if deps:
+        failures.append(f"{name}: preserved because dependent(s) {', '.join(deps)} are active")
+        return
+    ok, err = _stop_service_checkout(name, state, (root_path, state_path))
+    if ok:
+        stopped.append(name)
+    else:
+        failed_svcs.add(name)
+    if err:
+        failures.append(err)
+
+
+def _teardown_targets(
+    targets: list[str], state: dict[str, Any], ctx: tuple[Any, Path, Path]
+) -> tuple[list[str], list[str]]:
+    manifest, root_path, state_path = ctx
+    stopped, failures, failed_svcs = [], [], set()
+    step_ctx = (manifest, (root_path, state_path), (stopped, failures, failed_svcs))
+    for name in targets:
+        _stop_target_step(name, state, step_ctx)
+    return stopped, failures
+
+
+def _teardown_scope(
+    manifest: Any, state: dict[str, Any], scope: str
+) -> tuple[list[str], list[str]]:
+    services = state.get("services", {})
+    td_spec = {
+        n: {"depends_on": sorted(_merged_depends_on(n, services.get(n, {}), manifest))}
+        for n in manifest.teardown_scope(scope)
+    }
+    targets = reverse_dependency_order(td_spec)
+    blocked = [
+        f"{n} is still needed by running service {d}"
+        for n in targets
+        for d in _consumers_of(n, services, manifest)
+        if d in services and d not in targets
+    ]
+    return targets, blocked
+
+
+def _handle_blocked(blocked: list[str], as_json: bool) -> int:
+    msg = "; ".join(blocked)
+    hint = "stop dependent first or use --scope full"
+    if as_json:
+        raise RigError(msg, code="E_REFUSED", exit_code=EXIT_REFUSED, hint=hint)
+    err = RigError(
+        msg,
+        code="E_REFUSED",
+        exit_code=EXIT_REFUSED,
+        headline="Cannot stop service because other active services depend on it",
+        context="\n".join(f"Blocked: {b}" for b in blocked),
+        hint="Stop dependents first, or run 'rig down --scope full'",
+    )
+    th = get_theme()
+    print(format_human_error(err, th), end="", file=sys.stderr)
+    return EXIT_REFUSED
+
+
+def _finish_down_output(info: tuple[str, str, list[str], list[str]], as_json: bool) -> int:
+    inst, proj, stopped, failures = info
+    if as_json:
+        data = {"instance": inst, "project": proj, "stopped": stopped, "failures": failures}
+        print_json_envelope("down", data, ok=not failures)
+    elif stopped:
+        th = get_theme()
+        print(f"\n  {th.green}✓ Stack stopped.{th.r} Stopped {len(stopped)} service(s).\n")
+    return EXIT_OP_FAILED if failures else EXIT_OK
+
+
+def down_checkout(root: Path, manifest_path: Path, *args: Any, **kwargs: Any) -> int:
+    argv = list(args)
+    scope = kwargs.get("scope") or (argv.pop(0) if argv else "full")
+    as_json = bool(kwargs.get("as_json") or (argv.pop(0) if argv else False))
+    raw_m, root_path, inst, state_path, lock_path = _resolve_manifest_context(root, manifest_path)
+    with exclusive_lock(lock_path):
+        state = read_state(state_path)
+        manifest = raw_m.for_mode(state.get("mode")) if raw_m.modes else raw_m
+        targets, blocked = _teardown_scope(manifest, state, scope)
+        if blocked:
+            return _handle_blocked(blocked, as_json)
+        stopped, failures = _teardown_targets(targets, state, (manifest, root_path, state_path))
+        state["generation"] = int(state.get("generation", 0)) + 1
+        write_state(state_path, state)
+    return _finish_down_output((inst, manifest.project, stopped, failures), as_json)

rig/commands/init.py

@@ -0,0 +1,148 @@
+"""Auto-detection and project scaffolding command."""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import re
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from rig.commands.up import cmd_up
+from rig.core.constants import EXIT_OK, EXIT_USAGE
+from rig.core.errors import RigError, print_json_envelope
+from rig.manifest.detector import (
+    _extract_compose_services,
+    classify_compose_service,
+    detect_backend,
+    detect_frontend,
+)
+
+DEFAULT_COMPOSE_SERVICES = {
+    "postgres": (5432, "PostgreSQL database container"),
+    "redis": (6379, "Redis cache container"),
+}
+
+
+def _add_compose_service(base: dict[str, Any], detected: str, item: tuple[str, Any]) -> None:
+    svc, blk = item
+    if (kind := classify_compose_service(svc, blk)) and kind not in base:
+        port, desc = DEFAULT_COMPOSE_SERVICES[kind]
+        base[kind] = {
+            "type": "compose",
+            "compose_file": detected,
+            "compose_service": svc,
+            "compose_port": port,
+            "description": desc,
+        }
+
+
+def _detect_compose(root: Path, base_services: dict[str, Any]) -> str | None:
+    cands = ("docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml")
+    if not (detected := next((c for c in cands if (root / c).is_file()), None)):
+        return None
+    try:
+        for item in _extract_compose_services((root / detected).read_text()).items():
+            _add_compose_service(base_services, detected, item)
+    except OSError:
+        pass
+    return detected
+
+
+def _write_temp_manifest(target: Path, content: str, root: Path) -> None:
+    tmp: str | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w", dir=root, delete=False, prefix=".rig.json.tmp."
+        ) as h:
+            tmp = h.name
+            h.write(content)
+            h.flush()
+            os.fsync(h.fileno())
+        os.chmod(tmp, 0o644)
+        os.replace(tmp, target)
+    except BaseException:
+        if tmp is not None:
+            with contextlib.suppress(OSError):
+                os.unlink(tmp)
+        raise
+
+
+def _write_manifest_file(target: Path, content: str, opts: tuple[bool, Path]) -> None:
+    force, root = opts
+    if force:
+        _write_temp_manifest(target, content, root)
+        return
+    try:
+        flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0)
+        with os.fdopen(os.open(str(target), flags, 0o644), "w") as f:
+            f.write(content)
+    except FileExistsError:
+        msg = f"'{target}' already exists. Pass --force to overwrite."
+        raise RigError(msg, code="E_USAGE", exit_code=EXIT_USAGE) from None
+
+
+def _build_init_manifest(root: Path) -> dict[str, Any]:
+    proj = re.sub(r"[^a-zA-Z0-9]+", "-", root.name.lower()).strip("-") or "app"
+    base_services, native_services = {}, {}
+    _detect_compose(root, base_services)
+    has_backend = detect_backend(root, native_services, base_services)
+    detect_frontend(root, native_services, has_backend)
+
+    if not base_services and not native_services:
+        native_services["web"] = {
+            "type": "port",
+            "cwd": ".",
+            "command": [sys.executable, "-m", "http.server", "--bind", "127.0.0.1", "{port}"],
+            "healthcheck_path": "/",
+            "description": "Local HTTP static file server",
+        }
+
+    data: dict[str, Any] = {
+        "$schema": "https://raw.githubusercontent.com/evgesha9400/rig/main/rig.schema.json",
+        "project": proj,
+    }
+    if base_services:
+        data["services"] = base_services
+    if native_services:
+        data["default_mode"], data["modes"] = "native", {"native": {"services": native_services}}
+    return data
+
+
+def _finish_init(target: Path, data: dict[str, Any], opts: tuple[bool, bool, Path]) -> int:
+    up, as_json, root = opts
+    if up:
+        return cmd_up(root, target, as_json=as_json)
+    payload = {"manifest": data, "path": str(target), "created": True}
+    print_json_envelope("init", payload) if as_json else print(f"Created {target}")
+    return EXIT_OK
+
+
+def _unpack_init_flags(args: tuple[Any, ...], kwargs: dict[str, Any]) -> tuple[bool, ...]:
+    argv = list(args)
+    keys = ("dry_run", "force", "up", "as_json")
+    return tuple(bool(kwargs.get(k) or (argv.pop(0) if argv else False)) for k in keys)
+
+
+def cmd_init(root: Path, *args: Any, **kwargs: Any) -> int:
+    dry_run, force, up, as_json = _unpack_init_flags(args, kwargs)
+    resolved_root = Path(root).resolve()
+    target = resolved_root / "rig.json"
+    if (target.is_symlink() or target.exists()) and not (force or dry_run):
+        msg = f"'{target}' already exists. Pass --force to overwrite."
+        hint = "pass --force to overwrite the existing manifest"
+        raise RigError(msg, code="E_USAGE", exit_code=EXIT_USAGE, hint=hint)
+
+    data = _build_init_manifest(resolved_root)
+    content = json.dumps(data, indent=2) + "\n"
+    if dry_run:
+        print_json_envelope("init", {"manifest": data, "dry_run": True}) if as_json else print(
+            content, end=""
+        )
+        return EXIT_OK
+
+    _write_manifest_file(target, content, (force, resolved_root))
+    return _finish_init(target, data, (up, as_json, resolved_root))

rig/commands/logs.py

@@ -0,0 +1,146 @@
+"""Process log inspection and tailing command."""
+
+from __future__ import annotations
+
+import collections
+import sys
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from rig.commands.common import _resolve_manifest_context, record_status
+from rig.compose.client import run_compose
+from rig.core.constants import EXIT_NOT_FOUND, EXIT_OK
+from rig.core.errors import RigError, print_json_envelope
+from rig.core.identity import get_instances_dir
+from rig.core.state import read_state
+from rig.core.terminal import get_theme, highlight_log_line
+from rig.manifest.models import Service
+
+
+def _tail_log_file(path: Path, n: int) -> list[str]:
+    if not path.is_file():
+        return []
+    with open(path, encoding="utf-8", errors="replace") as f:
+        return list(collections.deque(f, maxlen=n))
+
+
+def _fetch_compose_logs(
+    target: tuple[Mapping[str, Any], Service],
+    env_ctx: tuple[Path, str, int],
+) -> list[str]:
+    rec, svc = target
+    root, inst, n = env_ctx
+    cfile = Path(rec.get("compose_file") or (root / str(svc.compose_file)))
+    c_svc = str(rec.get("compose_service") or svc.compose_service)
+    cmd = ["logs", f"--tail={n}", c_svc]
+    res = run_compose(inst, root, cfile, cmd, context=rec.get("docker_context"))
+    return res.stdout.splitlines(keepends=True) if res.stdout else []
+
+
+def _resolve_target_service(service_name: str | None, manifest_services: Mapping[str, Any]) -> str:
+    if service_name and service_name in manifest_services:
+        return service_name
+    avail = ", ".join(sorted(manifest_services.keys())) or "none"
+    if not service_name:
+        if len(manifest_services) == 1:
+            return next(iter(manifest_services.keys()))
+        raise RigError(
+            f"service name is required when multiple services exist (available: {avail})",
+            code="E_USAGE",
+            hint=f"Specify one of: {avail}",
+        )
+    raise RigError(
+        f"service '{service_name}' not found in manifest",
+        code="E_SERVICE_NOT_FOUND",
+        hint=f"Available services: {avail}",
+    )
+
+
+def _print_logs_formatted(
+    target_info: tuple[str, str, str | None, str],
+    path_display: str,
+    lines: list[str],
+) -> None:
+    th = get_theme()
+    project, service, mode, st = target_info
+    st_badge = f"{th.green}● running{th.r}" if st == "running" else f"{th.red}○ {st}{th.r}"
+    mode_tag = f" {th.cyan}[{mode}]{th.r}" if mode else ""
+    hdr_left = f"  {th.b}{project}{th.r}{mode_tag}  {th.d}·{th.r}  {th.b}{service}{th.r}"
+    print(f"\n{hdr_left}  {th.d}·{th.r}  {st_badge}  {th.d}(last {len(lines)} lines){th.r}")
+    print(f"  {th.d}➜{th.r} {path_display}\n")
+    for raw in lines:
+        cleaned = raw.rstrip("\r\n")
+        print(f"  {th.cyan}│{th.r} {highlight_log_line(cleaned, th)}")
+    print()
+
+
+def _render_logs(
+    target_info: tuple[str, str, str | None, str],
+    path_display: str,
+    ctx: tuple[list[str], bool],
+) -> int:
+    lines, as_json = ctx
+    project, service, mode, st = target_info
+    if as_json:
+        data = {
+            "project": project,
+            "service": service,
+            "mode": mode,
+            "status": st,
+            "path": path_display,
+            "count": len(lines),
+            "lines": [line.rstrip("\r\n") for line in lines],
+        }
+        print_json_envelope("logs", data)
+        return EXIT_OK
+    th = get_theme()
+    if not th.r:
+        for line in lines:
+            sys.stdout.write(line if line.endswith("\n") else line + "\n")
+        return EXIT_OK
+    _print_logs_formatted(target_info, path_display, lines)
+    return EXIT_OK
+
+
+def _read_service_log(
+    service_def: Service,
+    ctx: tuple[Mapping[str, Any], Path, str],
+    tail: int,
+) -> tuple[list[str], str]:
+    rec, root, inst = ctx
+    if service_def.type == "compose":
+        lines = _fetch_compose_logs((rec, service_def), (root, inst, tail))
+        svc_target = rec.get("compose_service") or service_def.compose_service
+        return lines, f"docker://{svc_target!s}"
+    inst_dir = get_instances_dir() / inst
+    log_file = Path(rec.get("log") or (inst_dir / "logs" / f"{service_def.name}.log"))
+    if not log_file.is_file():
+        raise RigError(
+            f"no log file found for service '{service_def.name}' at {log_file}",
+            code="E_LOG_NOT_FOUND",
+            exit_code=EXIT_NOT_FOUND,
+            hint=f"Run 'rig up {service_def.name}' first to start the service",
+        )
+    return _tail_log_file(log_file, tail), f"file://{log_file.resolve()}"
+
+
+def cmd_logs(root: Path, manifest_path: Path, *args: Any, **kwargs: Any) -> int:
+    """Inspect and tail logs for a single service in the current rig checkout."""
+    argv = list(args)
+    service = kwargs.get("service") or (argv.pop(0) if argv else None)
+    tail = int(kwargs.get("tail") or (argv.pop(0) if argv else 50))
+    mode = kwargs.get("mode") or (argv.pop(0) if argv else None)
+    as_json = bool(kwargs.get("as_json") or (argv.pop(0) if argv else False))
+
+    mf, res_root, inst_id, st_path, _ = _resolve_manifest_context(root, manifest_path)
+    if mode:
+        mf = mf.with_mode(mode)
+    sname = _resolve_target_service(service, mf.services)
+    state = read_state(st_path) if st_path.is_file() else {}
+    srec = state.get("services", {}).get(sname, {})
+    svc_def = mf.services[sname]
+    st = record_status(srec, res_root) if srec else "stopped"
+
+    lines, path_display = _read_service_log(svc_def, (srec, res_root, inst_id), tail)
+    return _render_logs((mf.project, sname, mf.active_mode, st), path_display, (lines, as_json))

rig/commands/prune.py

@@ -0,0 +1,142 @@
+"""Dead and orphaned instance registry cleanup command."""
+
+from __future__ import annotations
+
+import contextlib
+import fcntl
+import os
+import shutil
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from rig.commands.common import (
+    _consumers_of,
+    _stop_record,
+    compose_record_status,
+    reverse_dependency_order,
+)
+from rig.core.constants import (
+    EXIT_OK,
+    EXIT_OP_FAILED,
+    FILE_MODE_PRIVATE,
+    LOCK_FILE_NAME,
+    STATE_FILE_NAME,
+)
+from rig.core.errors import print_json_envelope
+from rig.core.identity import get_instances_dir
+from rig.core.state import read_state, write_state
+from rig.proc.process import identity_matches, pid_alive
+from rig.proc.teardown import pgid_alive
+
+
+def _is_service_live(record: Mapping[str, Any], root: Path) -> bool:
+    if record.get("type") == "compose":
+        return compose_record_status(record, root) != "absent"
+    pid, pgid = record.get("pid"), record.get("pgid")
+    ok_pid = isinstance(pid, int) and pid_alive(pid) and identity_matches(record)
+    return ok_pid or (isinstance(pgid, int) and pgid_alive(pgid))
+
+
+def _instance_live_services(
+    services: Mapping[str, Mapping[str, Any]], root: Path
+) -> dict[str, Mapping[str, Any]]:
+    return {n: r for n, r in services.items() if _is_service_live(r, root)}
+
+
+def _stop_instance_service(
+    name: str, services: dict[str, Any], ctx: tuple[Path, set[str]]
+) -> str | None:
+    root, failed = ctx
+    if not (rec := services.get(name)):
+        return None
+    if any(dep in failed for dep in _consumers_of(name, services)):
+        failed.add(name)
+        return f"{name}: preserved because dependent is still running"
+    outcome = _stop_record(rec, root, remove=True)
+    if outcome not in ("terminated", "killed", "stale"):
+        failed.add(name)
+        return f"{name}: {outcome}"
+    services.pop(name, None)
+    return None
+
+
+def _force_stop_instance(state: dict[str, Any], state_file: Path, root: Path) -> list[str]:
+    services = state.get("services", {})
+    failures, failed_services = [], set()
+    ctx = (root, failed_services)
+    for name in reverse_dependency_order(services):
+        if (err := _stop_instance_service(name, services, ctx)) is not None:
+            failures.append(err)
+    state["generation"] = int(state.get("generation", 0)) + 1
+    write_state(state_file, state)
+    return failures
+
+
+def _clear_instance_dir(inst_dir: Path) -> bool:
+    items = [i for i in inst_dir.iterdir() if i.name != LOCK_FILE_NAME]
+    for item in items:
+        if item.is_dir() and not item.is_symlink():
+            shutil.rmtree(item, ignore_errors=True)
+        else:
+            with contextlib.suppress(OSError):
+                item.unlink()
+    return bool(items)
+
+
+def _try_lock_fd(lock_file: Path) -> int | None:
+    try:
+        flags = os.O_RDWR | os.O_CREAT | getattr(os, "O_NOFOLLOW", 0)
+        fd = os.open(str(lock_file), flags, FILE_MODE_PRIVATE)
+        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except (BlockingIOError, OSError):
+        return None
+    else:
+        return fd
+
+
+def _inspect_and_prune(inst_dir: Path, force: bool) -> tuple[str | None, dict[str, Any] | None]:
+    state_file = inst_dir / STATE_FILE_NAME
+    state = read_state(state_file) if state_file.is_file() else {}
+    services, root_str = state.get("services", {}), state.get("root")
+    root_exists = bool(root_str and Path(root_str).is_dir())
+    ref_root = Path(root_str) if root_exists else inst_dir
+
+    live = _instance_live_services(services, ref_root)
+    if live and not force:
+        return None, None
+    if live:
+        if errs := _force_stop_instance(state, state_file, ref_root):
+            return None, {"instance": inst_dir.name, "failed": errs}
+        services = state.get("services", {})
+
+    can_prune = force or not root_exists or len(services) == 0
+    return (inst_dir.name, None) if can_prune and _clear_instance_dir(inst_dir) else (None, None)
+
+
+def _prune_instance(inst_dir: Path, force: bool) -> tuple[str | None, dict[str, Any] | None]:
+    if (lock_fd := _try_lock_fd(inst_dir / LOCK_FILE_NAME)) is None:
+        return None, None
+    try:
+        return _inspect_and_prune(inst_dir, force)
+    finally:
+        with contextlib.suppress(OSError):
+            os.close(lock_fd)
+
+
+def _collect_prune_results(
+    instances_dir: Path, force: bool
+) -> tuple[list[str], list[dict[str, Any]]]:
+    dirs = [directory for directory in sorted(instances_dir.iterdir()) if directory.is_dir()]
+    results = [_prune_instance(directory, force) for directory in dirs]
+    return [pruned for pruned, _ in results if pruned], [failed for _, failed in results if failed]
+
+
+def cmd_prune(force: bool = False, as_json: bool = False) -> int:
+    instances_dir = get_instances_dir()
+    pruned, failed = (
+        _collect_prune_results(instances_dir, force) if instances_dir.is_dir() else ([], [])
+    )
+    if as_json:
+        print_json_envelope("prune", {"pruned": pruned, "failed": failed}, ok=not failed)
+    return EXIT_OP_FAILED if failed else EXIT_OK