lablink-cli 0.1.0__py3-none-any.whl

lablink_cli/commands/export_metrics.py

@@ -0,0 +1,244 @@
+"""Export deployment metrics to CSV or JSON.
+
+Two metric sources, selectable via flags:
+
+* ``--client``    : per-VM client metrics fetched from the allocator's
+                    ``/api/export-metrics`` endpoint.
+* ``--allocator`` : per-deploy allocator metrics from the local CLI cache
+                    at ``~/.lablink/deployments/`` (issue #317), scoped to
+                    the config's ``deployment_name``.
+
+Default (no flag) exports both. ``--allocator`` alone never touches the
+network — and loads no config, so it exports the cache unscoped — which is
+what makes it work even after ``lablink destroy``.
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+
+from rich.console import Console
+
+from lablink_cli.api import authenticated_json_request
+from lablink_cli.commands.utils import (
+    get_allocator_url,
+    print_admin_credentials_hint,
+    resolve_admin_credentials,
+)
+from lablink_cli.deployment_metrics import load_all_metrics
+
+console = Console()
+
+
+VALID_FORMATS = ("csv", "json")
+
+
+def _suffixed_path(output_path: Path, suffix: str, fmt: str) -> Path:
+    """Return ``output_path`` with ``suffix`` inserted before the extension.
+
+    Used when both ``--client`` and ``--allocator`` are set and the user's
+    ``-o`` value acts as a base name — we write to ``{stem}_client.{fmt}``
+    and ``{stem}_allocator.{fmt}`` so both outputs are symmetrically named.
+    """
+    return output_path.with_name(f"{output_path.stem}{suffix}.{fmt}")
+
+
+def _export_client_metrics(
+    cfg,
+    output_path: Path,
+    fmt: str,
+    include_logs: bool,
+) -> None:
+    """Fetch per-VM metrics from the allocator and write to ``output_path``."""
+    allocator_url = get_allocator_url(cfg)
+    if not allocator_url:
+        console.print("[red]Could not determine allocator URL.[/red]")
+        raise SystemExit(1)
+
+    admin_user, admin_pw = resolve_admin_credentials(cfg)
+
+    logs_param = "true" if include_logs else "false"
+    url = f"{allocator_url}/api/export-metrics?include_logs={logs_param}"
+
+    try:
+        body = authenticated_json_request(
+            url, admin_user, admin_pw, ssl_provider=cfg.ssl.provider
+        )
+    except HTTPError as e:
+        if e.code == 401:
+            console.print(
+                f"[red]The allocator rejected admin user "
+                f"'{admin_user}' (HTTP 401).[/red]"
+            )
+            print_admin_credentials_hint(cfg)
+        else:
+            console.print(f"[red]HTTP {e.code}: {e.reason}[/red]")
+        raise SystemExit(1) from e
+    except URLError as e:
+        console.print(f"[red]Connection error: {e.reason}[/red]")
+        raise SystemExit(1) from e
+    except json.JSONDecodeError as e:
+        console.print(
+            f"[red]Invalid JSON response from allocator: {e}[/red]"
+        )
+        raise SystemExit(1) from e
+
+    vms = body.get("vms", [])
+    if not vms:
+        console.print("[yellow]No VMs found to export.[/yellow]")
+        return
+
+    if fmt == "json":
+        with open(output_path, "w") as f:
+            json.dump(vms, f, indent=2)
+    else:
+        fieldnames = list(vms[0].keys())
+        with open(output_path, "w", newline="") as f:
+            writer = csv.DictWriter(f, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(vms)
+
+    console.print(
+        f"[green]Exported {len(vms)} VMs to {output_path}[/green]"
+    )
+
+
+def _export_allocator_metrics(
+    output_path: Path,
+    fmt: str,
+    deployment_name: str | None = None,
+    provider: str | None = None,
+) -> None:
+    """Read CLI-local allocator deployment cache and write to ``output_path``.
+
+    The cache at ``~/.lablink/deployments/`` is global — one record per deploy
+    attempt for every deployment the operator has ever run — so an unfiltered
+    export puts other deployments' rows in a file named for this one.
+    ``provider`` is part of the scope because a name can be reused across
+    providers, and an AWS record's OpenTofu phase columns say nothing about a
+    compose stack. Records predating that field are AWS ones, hence the
+    ``"aws"`` default.
+
+    Either filter as None means no config was loaded (``--allocator`` alone on
+    a machine that has none, which is what keeps it working after ``lablink
+    destroy``) and exports the whole cache.
+
+    Empty result → print a yellow notice and skip writing the file (don't
+    create a confusing zero-row CSV / empty-list JSON).
+    """
+    records = [
+        r
+        for r in load_all_metrics()
+        if (not deployment_name or r.get("deployment_name") == deployment_name)
+        and (not provider or (r.get("provider") or "aws") == provider)
+    ]
+    if not records:
+        scope = f" for '{deployment_name}'" if deployment_name else ""
+        console.print(
+            f"[yellow]No allocator deployment metrics{scope} in "
+            f"~/.lablink/deployments/. Run `lablink deploy` first.[/yellow]"
+        )
+        return
+
+    if fmt == "json":
+        with open(output_path, "w") as f:
+            json.dump(
+                {"allocator_metrics": records, "count": len(records)},
+                f,
+                indent=2,
+            )
+    else:  # csv
+        # Union of keys across all records → stable header even when records
+        # have different optional fields populated (failed vs successful deploys).
+        fieldnames: list[str] = []
+        seen: set[str] = set()
+        for rec in records:
+            for k in rec:
+                if k not in seen:
+                    seen.add(k)
+                    fieldnames.append(k)
+        with open(output_path, "w", newline="") as f:
+            writer = csv.DictWriter(f, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(records)
+
+    console.print(
+        f"[green]Exported {len(records)} allocator deployment "
+        f"records to {output_path}[/green]"
+    )
+    names = {r.get("deployment_name") for r in records}
+    if deployment_name is None and len(names) > 1:
+        console.print(
+            f"  [dim]Spanning {len(names)} deployments — no config to scope by."
+            f"[/dim]"
+        )
+
+
+def run_export_metrics(
+    cfg,
+    output: str | None = None,
+    include_logs: bool = False,
+    format: str = "csv",
+    client: bool = False,
+    allocator: bool = False,
+) -> None:
+    """Export client and/or allocator metrics.
+
+    Args:
+        cfg: LabLink config (only required for ``client=True``; pass ``None``
+            when only ``allocator=True``).
+        output: Path for the output file(s). With a single flag, this is the
+            literal output path. With both flags, it's a **base** name: the
+            client file gets a ``_client`` suffix and the allocator file gets
+            an ``_allocator`` suffix inserted before the extension. If unset,
+            defaults to ``metrics_client.<fmt>`` and/or
+            ``metrics_allocator.<fmt>`` in the current directory.
+        include_logs: For client metrics, include cloud_init / docker logs.
+        format: ``csv`` or ``json``.
+        client: Export per-VM metrics fetched from the allocator.
+        allocator: Export per-deploy metrics from the CLI-local cache,
+            scoped to ``cfg.deployment_name`` (whole cache when ``cfg`` is
+            None).
+
+    No flags → both (the common "give me everything" case).
+    """
+    if format not in VALID_FORMATS:
+        console.print(
+            f"[red]Invalid format '{format}'. Must be one of: "
+            f"{', '.join(VALID_FORMATS)}[/red]"
+        )
+        raise SystemExit(1)
+
+    # Default: if neither flag is set, export both.
+    if not client and not allocator:
+        client = True
+        allocator = True
+
+    # Path resolution:
+    # - Single flag + no -o     → metrics_{role}.{fmt} in cwd
+    # - Single flag + -o foo.x  → foo.x (literal)
+    # - Both flags  + no -o     → metrics_client.{fmt} + metrics_allocator.{fmt}
+    # - Both flags  + -o foo.x  → foo_client.x + foo_allocator.x (base name)
+    both = client and allocator
+
+    def _path_for(role: str) -> Path:
+        if output is None:
+            return Path(f"metrics_{role}.{format}")
+        p = Path(output)
+        return _suffixed_path(p, f"_{role}", format) if both else p
+
+    if client:
+        _export_client_metrics(
+            cfg, _path_for("client"), format, include_logs
+        )
+
+    if allocator:
+        _export_allocator_metrics(
+            _path_for("allocator"),
+            format,
+            deployment_name=getattr(cfg, "deployment_name", None),
+            provider=getattr(cfg, "provider", None) if cfg else None,
+        )

lablink_cli/commands/launch.py

@@ -0,0 +1,236 @@
+"""Launch and destroy client VMs via the allocator service."""
+
+from __future__ import annotations
+
+import time
+from typing import Callable, NoReturn
+
+import typer
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
+
+from lablink_allocator_service.conf.structured_config import Config
+
+from lablink_cli.api import (
+    AllocatorAPI,
+    AllocatorAuthError,
+    AllocatorError,
+    AllocatorNotFoundError,
+    AllocatorUnavailableError,
+)
+from lablink_cli.commands.utils import (
+    format_duration,
+    get_allocator_url,
+    resolve_admin_credentials,
+    summarize_tofu,
+)
+
+console = Console()
+
+
+def _resolve_api(cfg: Config) -> tuple[AllocatorAPI, str]:
+    """Build an allocator client from config, prompting for credentials if
+    they were never saved.
+
+    Returns ``(api, allocator_url)``; exits 1 if the deployment's URL
+    cannot be determined.
+    """
+    allocator_url = get_allocator_url(cfg)
+    if not allocator_url:
+        console.print(
+            "[red]Could not determine allocator URL.[/red]\n"
+            "Run 'lablink deploy' first or check 'lablink status'."
+        )
+        raise SystemExit(1)
+
+    admin_user, admin_pw = resolve_admin_credentials(cfg)
+    api = AllocatorAPI(allocator_url, admin_user, admin_pw, cfg.ssl.provider)
+    return api, allocator_url
+
+
+def _run_fleet_op(
+    api_call: Callable[..., dict | None],
+    *,
+    description: str,
+) -> tuple[dict | None, float]:
+    """Run a client-fleet operation under a progress bar.
+
+    ``api_call`` is invoked as ``api_call(on_progress=cb)``; the callback
+    updates the bar with the allocator's resource counts. The allocator
+    reports (None, None) if it predates progress reporting, in which case
+    the bar stays indeterminate rather than rendering a literal "None".
+
+    Returns ``(result, elapsed_seconds)``. Exceptions from ``api_call``
+    propagate untouched — callers map them via ``_exit_fleet_error``.
+    """
+    started = time.monotonic()
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        console=console,
+        transient=True,
+    ) as progress:
+        task = progress.add_task(description, total=None)
+
+        def _on_progress(done, total):
+            if done is not None and total is not None:
+                progress.update(
+                    task,
+                    completed=done,
+                    total=total,
+                    description=f"{description} ({done}/{total} resources)",
+                )
+
+        result = api_call(on_progress=_on_progress)
+    return result, time.monotonic() - started
+
+
+def _report(
+    result: dict | None,
+    elapsed: float,
+    *,
+    label: str,
+    verbose: bool,
+) -> None:
+    """Print the success line and OpenTofu's resource summary, plus the
+    raw OpenTofu output under ``verbose``."""
+    output = (result or {}).get("output", "")
+    console.print(
+        f"[green]✓ {label}[/green]  [dim]({format_duration(elapsed)})[/dim]"
+    )
+    summary = summarize_tofu(output)
+    if summary:
+        console.print(f"  {summary}")
+    if verbose and output:
+        console.print()
+        console.print("[bold]OpenTofu output:[/bold]")
+        console.print(output, markup=False)
+    elif output:
+        console.print(
+            "  [dim]Pass --verbose to see full OpenTofu output.[/dim]"
+        )
+
+
+def _exit_fleet_error(e: AllocatorError, *, label: str) -> NoReturn:
+    """Report a failed fleet operation and exit 1.
+
+    Auth and connectivity failures get their own advice because the fix
+    differs. Everything else (409 already-in-progress, 405 unsupported,
+    poll timeout, HTTP 5xx) is reported verbatim under ``label`` — the
+    allocator's own message is more specific than anything we'd invent.
+    """
+    if isinstance(e, AllocatorAuthError):
+        console.print(
+            "[red]Authentication failed.[/red] Check your admin credentials."
+        )
+    elif isinstance(e, AllocatorUnavailableError):
+        console.print(f"[red]Could not connect to allocator:[/red] {e}")
+        console.print(
+            "  Check that the allocator is running with 'lablink status'."
+        )
+    else:
+        console.print(f"[red]{label}:[/red] {e}")
+    raise SystemExit(1)
+
+
+def run_launch(cfg: Config, num_vms: int, *, verbose: bool = False) -> None:
+    """Launch client VMs by calling the allocator /api/launch endpoint."""
+    if cfg.provider == "manual":
+        console.print(
+            "Manual provider has no VMs to launch — each BYO box "
+            "runs `lablink client register` to join the pool. See "
+            "`lablink status` for currently registered clients."
+        )
+        return
+
+    console.print()
+    api, allocator_url = _resolve_api(cfg)
+
+    console.print(f"  [dim]POST {allocator_url}/api/launch[/dim]")
+    console.print()
+
+    try:
+        result, elapsed = _run_fleet_op(
+            lambda on_progress: api.launch_vms(
+                num_vms, on_progress=on_progress
+            ),
+            description=f"[bold]Launching {num_vms} client VM(s)...[/bold]",
+        )
+        _report(result, elapsed, label="Launch successful", verbose=verbose)
+    except AllocatorError as e:
+        _exit_fleet_error(e, label="Launch failed")
+
+    console.print()
+    console.print(
+        "[dim]Run 'lablink status' to see client VMs.[/dim]"
+    )
+
+
+def run_client_destroy(
+    cfg: Config,
+    *,
+    yes: bool = False,
+    verbose: bool = False,
+) -> None:
+    """Destroy every client VM by calling the allocator's /destroy endpoint.
+
+    Args:
+        cfg: Loaded LabLink config.
+        yes: Skip the confirmation prompt.
+        verbose: Print the allocator's full OpenTofu output.
+    """
+    if cfg.provider == "manual":
+        console.print(
+            "Manual provider has no VMs to destroy — each BYO box "
+            "leaves the pool by running `lablink client unregister` "
+            "on that box. See `lablink status` for currently "
+            "registered clients."
+        )
+        return
+
+    console.print()
+    api, allocator_url = _resolve_api(cfg)
+
+    if not yes:
+        console.print(
+            "[bold yellow]This destroys ALL client VMs[/bold yellow] and "
+            "clears the allocator's VM table — inventory, per-VM logs, and "
+            "session history go with them. Any user connected right now "
+            "loses their session."
+        )
+        console.print(
+            "[dim]Export first if you need the numbers: "
+            "lablink export-metrics --allocator[/dim]"
+        )
+        if not typer.confirm("Destroy all client VMs?", default=False):
+            console.print("Aborted.")
+            return
+        console.print()
+
+    console.print(f"  [dim]POST {allocator_url}/destroy[/dim]")
+    console.print()
+
+    try:
+        result, elapsed = _run_fleet_op(
+            lambda on_progress: api.destroy_vms(on_progress=on_progress),
+            description="[bold]Destroying client VMs...[/bold]",
+        )
+        _report(result, elapsed, label="client VMs destroyed", verbose=verbose)
+    except AllocatorNotFoundError:
+        # Nothing was ever launched, so there is nothing to tear down.
+        # Not a failure: the command is idempotent. Must precede the
+        # AllocatorError clause below — it is a subclass.
+        console.print(
+            "[yellow]No client VMs were launched — "
+            "nothing to destroy.[/yellow]"
+        )
+        return
+    except AllocatorError as e:
+        _exit_fleet_error(e, label="Client destroy failed")
+
+    console.print()
+    console.print(
+        "[dim]Run 'lablink client launch --num-vms N' to refill the "
+        "pool.[/dim]"
+    )