lablink-cli 0.1.0__py3-none-any.whl

lablink_cli/config/schema.py

@@ -0,0 +1,212 @@
+"""Configuration schema for LabLink deployments.
+
+Re-exports the canonical Config dataclass from the allocator package
+and adds CLI-specific helpers (YAML serialization, validation, reference data).
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import fields
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+# Re-export the canonical config dataclasses from the allocator.
+from lablink_allocator_service.validate_config import (
+    get_config_errors,
+)
+from lablink_allocator_service.conf.structured_config import (  # noqa: F401
+    AllocatorConfig,
+    AppConfig,
+    Config,
+    DatabaseConfig,
+    DNSConfig,
+    EIPConfig,
+    MachineConfig,
+    SSLConfig,
+    StartupConfig,
+)
+
+
+def config_to_dict(cfg: Any) -> Any:
+    """Recursively convert a dataclass to a nested dict."""
+    if hasattr(cfg, "__dataclass_fields__"):
+        return {
+            f.name: config_to_dict(getattr(cfg, f.name))
+            for f in fields(cfg)
+        }
+    return cfg
+
+
+def load_config(path: Path) -> Config:
+    """Load a Config from a YAML file."""
+    with open(path) as f:
+        data = yaml.safe_load(f)
+
+    cfg = Config()
+    for key, value in data.items():
+        if hasattr(cfg, key) and isinstance(value, dict):
+            sub = getattr(cfg, key)
+            for k, v in value.items():
+                if isinstance(v, dict):
+                    # Nested sub-config (3-level YAML structure)
+                    nested = getattr(sub, k, None)
+                    if nested and hasattr(nested, "__dataclass_fields__"):
+                        for nk, nv in v.items():
+                            setattr(nested, nk, nv)
+                    else:
+                        setattr(sub, k, v)
+                else:
+                    setattr(sub, k, v)
+        elif hasattr(cfg, key):
+            setattr(cfg, key, value)
+    return cfg
+
+
+def save_config(cfg: Config, path: Path) -> None:
+    """Write a Config to a YAML file."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as f:
+        yaml.dump(
+            config_to_dict(cfg),
+            f,
+            default_flow_style=False,
+            sort_keys=False,
+        )
+
+
+DEPLOYMENT_NAME_RE = re.compile(r"^[a-z][a-z0-9-]*[a-z0-9]$")
+VALID_ENVIRONMENTS = ("dev", "test", "ci-test", "prod")
+
+
+def validate_config(cfg: Config) -> list[str]:
+    """Return a list of validation errors (empty = valid).
+
+    Mirrors the allocator's validate_config_logic but returns a
+    simple list instead of a tuple, suitable for TUI display.
+    """
+    errors: list[str] = []
+    # deployment_name validation
+    if not cfg.deployment_name:
+        errors.append(
+            "deployment_name is required "
+            "(e.g., 'sleap-lablink')"
+        )
+    elif (
+        len(cfg.deployment_name) < 3
+        or len(cfg.deployment_name) > 32
+        or not DEPLOYMENT_NAME_RE.match(cfg.deployment_name)
+    ):
+        errors.append(
+            "deployment_name must be 3-32 characters, "
+            "lowercase kebab-case (e.g., 'sleap-lablink')"
+        )
+    # environment validation
+    if cfg.environment not in VALID_ENVIRONMENTS:
+        errors.append(
+            f"environment must be one of: "
+            f"{', '.join(VALID_ENVIRONMENTS)}"
+        )
+    # DNS/SSL validation — shared with allocator's validate_config
+    errors.extend(get_config_errors(cfg))
+    return errors
+
+
+# AMI IDs by region (Ubuntu 24.04 with Docker + Nvidia GPU Driver)
+AMI_MAP: dict[str, str] = {
+    "us-east-1": "ami-0601752c11b394251",
+    "us-east-2": "ami-0601752c11b394251",
+    "us-west-1": "ami-0601752c11b394251",
+    "us-west-2": "ami-0601752c11b394251",
+}
+
+# Common GPU instance types
+GPU_INSTANCE_TYPES: list[dict[str, str]] = [
+    {
+        "type": "g4dn.xlarge",
+        "gpu": "T4 16GB",
+        "vcpu": "4",
+        "ram": "16 GB",
+        "cost": "~$0.53/hr",
+    },
+    {
+        "type": "g4dn.2xlarge",
+        "gpu": "T4 16GB",
+        "vcpu": "8",
+        "ram": "32 GB",
+        "cost": "~$0.75/hr",
+    },
+    {
+        "type": "g5.xlarge",
+        "gpu": "A10G 24GB",
+        "vcpu": "4",
+        "ram": "16 GB",
+        "cost": "~$1.01/hr",
+    },
+    {
+        "type": "g5.2xlarge",
+        "gpu": "A10G 24GB",
+        "vcpu": "8",
+        "ram": "32 GB",
+        "cost": "~$1.21/hr",
+    },
+    {
+        "type": "p3.2xlarge",
+        "gpu": "V100 16GB",
+        "vcpu": "8",
+        "ram": "61 GB",
+        "cost": "~$3.06/hr",
+    },
+]
+
+# Common CPU instance types (no GPU)
+CPU_INSTANCE_TYPES: list[dict[str, str]] = [
+    {
+        "type": "t3.large",
+        "gpu": "—",
+        "vcpu": "2",
+        "ram": "8 GB",
+        "cost": "~$0.08/hr",
+    },
+    {
+        "type": "t3.xlarge",
+        "gpu": "—",
+        "vcpu": "4",
+        "ram": "16 GB",
+        "cost": "~$0.17/hr",
+    },
+    {
+        "type": "t3.2xlarge",
+        "gpu": "—",
+        "vcpu": "8",
+        "ram": "32 GB",
+        "cost": "~$0.33/hr",
+    },
+    {
+        "type": "m5.xlarge",
+        "gpu": "—",
+        "vcpu": "4",
+        "ram": "16 GB",
+        "cost": "~$0.19/hr",
+    },
+    {
+        "type": "m5.2xlarge",
+        "gpu": "—",
+        "vcpu": "8",
+        "ram": "32 GB",
+        "cost": "~$0.38/hr",
+    },
+]
+
+AWS_REGIONS: list[dict[str, str]] = [
+    {"id": "us-east-1", "name": "US East (N. Virginia)"},
+    {"id": "us-east-2", "name": "US East (Ohio)"},
+    {"id": "us-west-1", "name": "US West (N. California)"},
+    {"id": "us-west-2", "name": "US West (Oregon)"},
+    {"id": "eu-west-1", "name": "Europe (Ireland)"},
+    {"id": "eu-central-1", "name": "Europe (Frankfurt)"},
+    {"id": "ap-northeast-1", "name": "Asia Pacific (Tokyo)"},
+    {"id": "ap-southeast-1", "name": "Asia Pacific (Singapore)"},
+]

lablink_cli/deployment_metrics.py

@@ -0,0 +1,94 @@
+"""CLI-local cache for allocator deployment metrics (issue #317).
+
+Stored on the operator's machine under ``~/.lablink/deployments/`` so that
+metrics for failed deploys (or for already-destroyed allocators) survive.
+
+Records start life with ``status="in_progress"`` and are promoted to
+``success`` / ``failed`` by :func:`~lablink_cli.commands.deploy.run_deploy`.
+Plan-confirmation cancels and Ctrl-C leave the file in ``in_progress``
+indefinitely — use ``lablink cache-clear --deployments --stale`` to prune
+just those, or ``--deployments`` to wipe the whole cache.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from contextlib import contextmanager
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Iterator, Optional
+
+DEPLOYMENTS_DIR = Path.home() / ".lablink" / "deployments"
+
+
+@dataclass
+class DeploymentMetrics:
+    deployment_name: str
+    # Which deploy path produced this record. deployment_name alone does not
+    # identify it: an operator can reuse one name across providers (observed:
+    # a `sleap-lablink` config switched from aws to manual), and the AWS
+    # OpenTofu timings below are meaningless for a compose deploy. Records
+    # written before this field existed are all AWS ones, which is why
+    # readers default a missing value to "aws" rather than to None.
+    provider: Optional[str] = None
+    region: Optional[str] = None
+    template_version: Optional[str] = None
+    ssl_enabled: Optional[bool] = None
+    allocator_deploy_start_time: Optional[str] = None
+    allocator_deploy_end_time: Optional[str] = None
+    allocator_tofu_init_duration_seconds: Optional[float] = None
+    allocator_tofu_plan_duration_seconds: Optional[float] = None
+    allocator_tofu_apply_duration_seconds: Optional[float] = None
+    # The manual provider's equivalent of the three OpenTofu phases above:
+    # one `docker compose up -d`, image pull included. Kept as its own field
+    # rather than reusing the apply timing, which would make a compose deploy
+    # look like an OpenTofu one in the exported CSV.
+    allocator_compose_up_duration_seconds: Optional[float] = None
+    allocator_health_check_duration_seconds: Optional[float] = None
+    allocator_total_deployment_duration_seconds: Optional[float] = None
+    status: str = "in_progress"
+    error: Optional[str] = None
+
+
+def _slugify_timestamp(dt: datetime) -> str:
+    return dt.isoformat().replace(":", "-")
+
+
+def cache_path_for(deployment_name: str, start_time: datetime) -> Path:
+    return DEPLOYMENTS_DIR / f"{deployment_name}-{_slugify_timestamp(start_time)}.json"
+
+
+def write_metrics(path: Path, metrics: DeploymentMetrics) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(asdict(metrics), indent=2, sort_keys=True))
+    tmp.replace(path)
+
+
+def load_all_metrics() -> list[dict]:
+    if not DEPLOYMENTS_DIR.exists():
+        return []
+    out = []
+    for p in sorted(DEPLOYMENTS_DIR.glob("*.json")):
+        try:
+            out.append(json.loads(p.read_text()))
+        except json.JSONDecodeError:
+            continue
+    return out
+
+
+@contextmanager
+def phase_timer(
+    metrics: DeploymentMetrics,
+    field_name: str,
+    path: Path,
+) -> Iterator[None]:
+    """Time a code block with monotonic clock; persist on exit (even on error)."""
+    start = time.monotonic()
+    try:
+        yield
+    finally:
+        setattr(metrics, field_name, round(time.monotonic() - start, 3))
+        write_metrics(path, metrics)