lablink-cli 0.1.0__py3-none-any.whl

lablink_cli/tofu_source.py

@@ -0,0 +1,169 @@
+"""Download and cache OpenTofu files from lablink-template releases."""
+
+from __future__ import annotations
+
+import hashlib
+import io
+import shutil
+import tarfile
+import tempfile
+import time
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from urllib.request import urlopen
+
+from rich.console import Console
+
+from lablink_cli import TEMPLATE_REPO, TEMPLATE_SHA256
+
+console = Console()
+
+CACHE_DIR = Path.home() / ".lablink" / "cache" / "terraform"
+
+_ALLOWED_EXTENSIONS = {".tf", ".hcl", ".sh", ".yaml"}
+
+
+def get_tofu_files(
+    version: str,
+    *,
+    bundle_path: str | None = None,
+    skip_checksum: bool = False,
+) -> Path:
+    """Return path to cached OpenTofu files, downloading if needed.
+
+    Args:
+        version: Git tag in the template repo (e.g. "v0.1.0").
+        bundle_path: Path to a local tarball (offline mode). Skips download.
+        skip_checksum: If True, skip SHA-256 verification.
+
+    Returns:
+        Path to directory containing .tf files ready for use.
+    """
+    cache_path = CACHE_DIR / version
+
+    # Cache hit — return immediately
+    if cache_path.exists() and any(cache_path.glob("*.tf")):
+        return cache_path
+
+    # Get tarball bytes
+    if bundle_path:
+        console.print(f"  Using local bundle: {bundle_path}")
+        tarball_data = Path(bundle_path).read_bytes()
+    else:
+        console.print(
+            f"  Downloading infrastructure templates {version}... ",
+            end="",
+        )
+        tarball_data = _download_tarball(version, retries=3)
+        console.print("done.")
+
+    # Verify checksum
+    if not skip_checksum:
+        _verify_checksum(tarball_data, version)
+
+    # Extract to temp dir, then atomic rename to cache
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    tmp_dir = Path(tempfile.mkdtemp(
+        dir=CACHE_DIR.parent, prefix=".terraform-extract-"
+    ))
+    try:
+        _extract_tofu_files(tarball_data, tmp_dir)
+
+        # Atomic move to final cache location
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        if cache_path.exists():
+            # Another process may have created it concurrently
+            return cache_path
+        tmp_dir.rename(cache_path)
+    except Exception:
+        # Clean up temp dir on failure
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+        raise
+
+    return cache_path
+
+
+def _download_tarball(version: str, retries: int = 3) -> bytes:
+    """Download the release tarball from GitHub with retries."""
+    url = (
+        f"https://github.com/{TEMPLATE_REPO}"
+        f"/archive/refs/tags/{version}.tar.gz"
+    )
+
+    last_error: Exception | None = None
+    for attempt in range(retries):
+        try:
+            with urlopen(url, timeout=60) as resp:  # noqa: S310
+                return resp.read()
+        except (HTTPError, URLError, OSError) as e:
+            last_error = e
+            if attempt < retries - 1:
+                time.sleep(2 ** attempt)
+
+    console.print(
+        f"\n\n  [red]Failed to download templates after "
+        f"{retries} attempts.[/red]\n"
+        f"  URL: {url}\n"
+        f"  Error: {last_error}\n\n"
+        f"  [bold]Workarounds:[/bold]\n"
+        f"  1. Check your internet connection\n"
+        f"  2. If behind a proxy, set HTTPS_PROXY\n"
+        f"  3. Download manually and use:\n"
+        f"     lablink deploy --terraform-bundle /path/to/tarball.tar.gz\n"
+    )
+    raise SystemExit(1)
+
+
+def _verify_checksum(data: bytes, version: str) -> None:
+    """Verify SHA-256 checksum of the downloaded tarball."""
+    actual = hashlib.sha256(data).hexdigest()
+    if actual != TEMPLATE_SHA256:
+        console.print(
+            f"\n  [red]Checksum mismatch for {version}![/red]\n"
+            f"  Expected: {TEMPLATE_SHA256}\n"
+            f"  Got:      {actual}\n"
+            f"  The download may be corrupted or tampered with.\n"
+        )
+        raise SystemExit(1)
+
+
+def _extract_tofu_files(data: bytes, dest: Path) -> None:
+    """Extract OpenTofu files from tarball with safety checks."""
+    dest.mkdir(parents=True, exist_ok=True)
+
+    with tarfile.open(fileobj=io.BytesIO(data), mode="r:gz") as tar:
+        for member in tar.getmembers():
+            # Find the lablink-infrastructure/ prefix
+            parts = Path(member.name).parts
+            try:
+                infra_idx = parts.index("lablink-infrastructure")
+            except ValueError:
+                continue
+
+            # Get the relative path within lablink-infrastructure/
+            rel_parts = parts[infra_idx + 1 :]
+            if not rel_parts:
+                continue
+
+            rel_path = Path(*rel_parts)
+
+            # Security: reject path traversal
+            if ".." in rel_parts:
+                continue
+
+            # Security: only allow whitelisted extensions
+            suffix = rel_path.suffix
+            if suffix and suffix not in _ALLOWED_EXTENSIONS:
+                continue
+
+            # Skip directories (we create them as needed)
+            if member.isdir():
+                continue
+
+            # Extract to dest
+            out_path = dest / rel_path
+            out_path.parent.mkdir(parents=True, exist_ok=True)
+
+            fileobj = tar.extractfile(member)
+            if fileobj:
+                out_path.write_bytes(fileobj.read())

lablink_cli/tui/logs_viewer.py

@@ -0,0 +1,413 @@
+"""Textual TUI for viewing LabLink VM logs."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from textual import work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.timer import Timer
+from textual.widgets import (
+    Footer,
+    Header,
+    Label,
+    ListItem,
+    ListView,
+    RichLog,
+    Static,
+)
+
+from lablink_allocator_service.conf.structured_config import Config
+
+# Self-clocking; see _schedule_next_fetch.
+_AUTO_REFRESH_SECONDS = 5
+
+
+class VMListItem(ListItem):
+    """A list item representing a VM."""
+
+    def __init__(self, vm: dict) -> None:
+        self.vm = vm
+        vm_type = vm["vm_type"]
+        name = vm["name"]
+        state = vm["state"]
+        label = f"[{'cyan' if vm_type == 'allocator' else 'green'}]{vm_type}[/] {name}"
+        if state != "running":
+            label += f" [dim]({state})[/dim]"
+        super().__init__(Label(label, markup=True))
+
+
+class LogsApp(App):
+    """Interactive log viewer for LabLink VMs."""
+
+    TITLE = "LabLink Log Viewer"
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("r", "refresh", "Refresh"),
+        Binding("a", "toggle_auto", "Auto-fetch"),
+        Binding("1", "show_cloud_init", "Cloud-Init"),
+        Binding("2", "show_docker", "Docker"),
+    ]
+
+    CSS = """
+    #main-container {
+        height: 1fr;
+    }
+
+    #vm-list-panel {
+        width: 35;
+        min-width: 25;
+        border-right: solid $primary-lighten-2;
+    }
+
+    #vm-list-panel Label {
+        padding: 0 1;
+        color: $text-muted;
+    }
+
+    #vm-list {
+        height: 1fr;
+    }
+
+    #log-panel {
+        width: 1fr;
+    }
+
+    #vm-info {
+        padding: 0 1;
+    }
+
+    #tab-bar {
+        height: 1;
+        padding: 0 1;
+    }
+
+    .tab {
+        width: auto;
+        margin-right: 2;
+    }
+
+    .tab-active {
+        color: $accent;
+        text-style: bold underline;
+    }
+
+    .tab-inactive {
+        color: $text;
+    }
+
+    #log-output {
+        height: 1fr;
+        border-top: solid $primary-lighten-3;
+    }
+
+    /* height must cover the border AND a content row: Textual sizes with
+       border-box, so `height: 1` here spent its only row on border-top and
+       left the text zero rows to render in. */
+    #status-bar {
+        height: 2;
+        width: 1fr;
+        padding: 0 1;
+        color: $text-muted;
+        border-top: solid $primary-lighten-3;
+    }
+    """
+
+    def __init__(
+        self,
+        cfg: Config,
+        vms: list[dict],
+        allocator_url: str,
+        admin_user: str,
+        admin_pw: str,
+        deploy_dir: Path,
+        manual: bool = False,
+    ) -> None:
+        super().__init__()
+        self._cfg = cfg
+        self._vms = vms
+        self._allocator_url = allocator_url
+        self._admin_user = admin_user
+        self._admin_pw = admin_pw
+        self._deploy_dir = deploy_dir
+        self._manual = manual
+        self._selected_vm: dict | None = None
+        # Manual provider has no cloud-init concept (BYO hosts boot
+        # themselves); default to docker and skip the cloud-init tab UI.
+        self._current_tab = "docker" if manual else "cloud_init"
+        self._cached_logs: dict | None = None
+        self._auto = True
+        self._auto_timer: Timer | None = None
+        self._last_fetched: str | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Horizontal(id="main-container"):
+            with Vertical(id="vm-list-panel"):
+                yield Label(
+                    f"[bold]{self._cfg.deployment_name}[/bold] "
+                    f"({self._cfg.environment})"
+                )
+                yield ListView(
+                    *[VMListItem(vm) for vm in self._vms],
+                    id="vm-list",
+                )
+            with Vertical(id="log-panel"):
+                yield Label("Select a VM to view logs", id="vm-info")
+                with Horizontal(id="tab-bar"):
+                    if not self._manual:
+                        yield Static(
+                            "[bold]Cloud-Init[/bold]",
+                            id="tab-cloud-init",
+                            classes="tab tab-active",
+                            markup=True,
+                        )
+                        yield Static(
+                            "Docker",
+                            id="tab-docker",
+                            classes="tab tab-inactive",
+                            markup=True,
+                        )
+                    else:
+                        # Manual provider: only docker logs exist.
+                        yield Static(
+                            "[bold]Docker[/bold]",
+                            id="tab-docker",
+                            classes="tab tab-active",
+                            markup=True,
+                        )
+                yield RichLog(
+                    id="log-output",
+                    auto_scroll=True,
+                    wrap=True,
+                    markup=True,
+                )
+                yield Label("", id="status-bar")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Show initial hint in the log panel."""
+        log_output = self.query_one("#log-output", RichLog)
+        log_output.write(
+            "[dim]Select a VM from the list to view its logs.[/dim]"
+        )
+        # Show cadence before the first tick.
+        self._refresh_status()
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        """Handle VM selection."""
+        item = event.item
+        if isinstance(item, VMListItem):
+            self._selected_vm = item.vm
+            self._cached_logs = None
+            # Drop the tick queued for the previous VM; the fetch below
+            # re-arms the timer against the new selection.
+            self._cancel_auto_timer()
+            self._update_vm_info()
+            # Clear log panel immediately and show loading state
+            log_output = self.query_one("#log-output", RichLog)
+            log_output.clear()
+            log_output.write("[dim]Fetching logs...[/dim]")
+            self._set_status("Fetching logs...")
+            self._fetch_logs()
+
+    def _update_vm_info(self) -> None:
+        """Update the VM info label."""
+        vm = self._selected_vm
+        if not vm:
+            return
+        info = self.query_one("#vm-info", Label)
+        ip_display = vm.get("public_ip", "—")
+        info.update(
+            f"[bold]{vm['name']}[/bold]  "
+            f"({vm['type']})  "
+            f"IP: {ip_display}"
+        )
+
+    def _update_tab_styles(self) -> None:
+        """Update tab visual state."""
+        if self._manual:
+            # Manual mode renders only the docker tab; nothing to swap.
+            return
+        cloud_init_tab = self.query_one("#tab-cloud-init", Static)
+        docker_tab = self.query_one("#tab-docker", Static)
+        if self._current_tab == "cloud_init":
+            cloud_init_tab.update("[bold]Cloud-Init[/bold]")
+            cloud_init_tab.set_classes("tab tab-active")
+            docker_tab.update("Docker")
+            docker_tab.set_classes("tab tab-inactive")
+        else:
+            cloud_init_tab.update("Cloud-Init")
+            cloud_init_tab.set_classes("tab tab-inactive")
+            docker_tab.update("[bold]Docker[/bold]")
+            docker_tab.set_classes("tab tab-active")
+
+    _MAX_LOG_LINES = 5000
+
+    def _display_logs(self) -> None:
+        """Display logs from cache for the current tab."""
+        log_output = self.query_one("#log-output", RichLog)
+        log_output.clear()
+
+        if self._cached_logs is None:
+            log_output.write("[dim]No logs loaded. Select a VM.[/dim]")
+            return
+
+        error = self._cached_logs.get("error")
+        if error:
+            log_output.write(f"[red]{error}[/red]")
+            return
+
+        if self._current_tab == "cloud_init":
+            content = self._cached_logs.get("cloud_init_logs")
+        else:
+            content = self._cached_logs.get("docker_logs")
+
+        if content:
+            lines = content.splitlines()
+            if len(lines) > self._MAX_LOG_LINES:
+                skipped = len(lines) - self._MAX_LOG_LINES
+                log_output.write(
+                    f"[dim]... {skipped} earlier lines truncated ...[/dim]"
+                )
+                lines = lines[-self._MAX_LOG_LINES :]
+            for line in lines:
+                log_output.write(line)
+        else:
+            tab_name = (
+                "Cloud-Init" if self._current_tab == "cloud_init" else "Docker"
+            )
+            log_output.write(
+                f"[dim]No {tab_name} logs available for this VM.[/dim]"
+            )
+
+    @work(thread=True, exclusive=True)
+    def _fetch_logs(self) -> None:
+        """Fetch logs in a background thread."""
+        vm = self._selected_vm
+        if not vm:
+            return
+
+        try:
+            if vm["vm_type"] == "client":
+                if not self._allocator_url:
+                    logs = {
+                        "cloud_init_logs": None,
+                        "docker_logs": None,
+                        "error": (
+                            "Allocator URL not available. "
+                            "Cannot fetch client logs."
+                        ),
+                    }
+                else:
+                    from lablink_cli.commands.logs import fetch_client_logs
+
+                    logs = fetch_client_logs(
+                        allocator_url=self._allocator_url,
+                        hostname=vm["name"],
+                        admin_user=self._admin_user,
+                        admin_pw=self._admin_pw,
+                        ssl_provider=self._cfg.ssl.provider,
+                    )
+            else:
+                # Manual provider's allocator is a local docker container, not
+                # an EC2 instance — bypass SSH and read `docker logs` directly.
+                if self._manual:
+                    from lablink_cli.commands.logs import (
+                        fetch_manual_allocator_logs,
+                    )
+
+                    logs = fetch_manual_allocator_logs()
+                else:
+                    from lablink_cli.commands.logs import fetch_allocator_logs
+
+                    logs = fetch_allocator_logs(
+                        instance_id=vm["instance_id"],
+                        public_ip=vm.get("public_ip", "—"),
+                        region=self._cfg.app.region,
+                        deploy_dir=self._deploy_dir,
+                    )
+
+            # Guard: discard results if user selected a different VM while
+            # fetching
+            if self._selected_vm is not vm:
+                return
+
+            # Repaint only on change. _display_logs clears and rewrites the
+            # RichLog, and auto_scroll drags the view to the bottom — so an
+            # unconditional repaint every tick would yank you off whatever you
+            # had scrolled up to read. Most ticks find nothing new.
+            unchanged = logs == self._cached_logs
+            self._cached_logs = logs
+            self._last_fetched = datetime.now().strftime("%H:%M:%S")
+            if not unchanged:
+                self.call_from_thread(self._display_logs)
+            self.call_from_thread(self._refresh_status)
+        finally:
+            # Re-arm even if the fetch raised, or one transient error would
+            # kill auto-fetch for the rest of the session.
+            self.call_from_thread(self._schedule_next_fetch)
+
+    def _cancel_auto_timer(self) -> None:
+        """Drop any queued auto-fetch tick."""
+        if self._auto_timer is not None:
+            self._auto_timer.stop()
+            self._auto_timer = None
+
+    def _schedule_next_fetch(self) -> None:
+        """Arm the next tick. Cancels first, so at most one is outstanding.
+
+        Self-clocking rather than ``set_interval``: armed only once the
+        previous fetch settles, so fetches cannot overlap and a slow SSH
+        round-trip backs the cadence off instead of stacking up.
+        """
+        self._cancel_auto_timer()
+        if self._auto and self._selected_vm:
+            self._auto_timer = self.set_timer(
+                _AUTO_REFRESH_SECONDS, self._fetch_logs
+            )
+
+    def _set_status(self, text: str) -> None:
+        """Update the status bar."""
+        status = self.query_one("#status-bar", Label)
+        status.update(f"[dim]{text}[/dim]")
+
+    def _refresh_status(self) -> None:
+        """Redraw the status bar. State leads so truncation eats the clock."""
+        auto = f"auto {_AUTO_REFRESH_SECONDS}s" if self._auto else "auto off"
+        self._set_status(f"{auto} · last fetched {self._last_fetched or '—'}")
+
+    def action_refresh(self) -> None:
+        """Refresh logs for the selected VM."""
+        if self._selected_vm:
+            self._fetch_logs()
+
+    def action_toggle_auto(self) -> None:
+        """Turn auto-fetch on or off."""
+        self._auto = not self._auto
+        if self._auto:
+            # Fetch now; completing that fetch arms the timer.
+            self._fetch_logs()
+        else:
+            self._cancel_auto_timer()
+        self._refresh_status()
+
+    def action_show_cloud_init(self) -> None:
+        """Switch to cloud-init log tab."""
+        if self._manual:
+            # No cloud-init for manual provider; binding is a no-op.
+            return
+        self._current_tab = "cloud_init"
+        self._update_tab_styles()
+        self._display_logs()
+
+    def action_show_docker(self) -> None:
+        """Switch to docker log tab."""
+        self._current_tab = "docker"
+        self._update_tab_styles()
+        self._display_logs()
+