clonebox 1.1.20__py3-none-any.whl → 1.1.23__py3-none-any.whl

clonebox/validation/core.py

@@ -0,0 +1,202 @@
+import base64
+import json
+import shutil
+import subprocess
+import time
+import zlib
+from pathlib import Path
+from typing import Dict, Optional
+
+from rich.console import Console
+
+
+class VMValidatorCore:
+    def __init__(
+        self,
+        config: dict,
+        vm_name: str,
+        conn_uri: str,
+        console: Console = None,
+        require_running_apps: bool = False,
+        smoke_test: bool = False,
+    ):
+        self.config = config
+        self.vm_name = vm_name
+        self.conn_uri = conn_uri
+        self.console = console or Console()
+        self.require_running_apps = require_running_apps
+        self.smoke_test = smoke_test
+        self.results = {
+            "mounts": {"passed": 0, "failed": 0, "skipped": 0, "total": 0, "details": []},
+            "packages": {"passed": 0, "failed": 0, "skipped": 0, "total": 0, "details": []},
+            "snap_packages": {
+                "passed": 0,
+                "failed": 0,
+                "skipped": 0,
+                "total": 0,
+                "details": [],
+            },
+            "services": {"passed": 0, "failed": 0, "skipped": 0, "total": 0, "details": []},
+            "disk": {"usage_pct": 0, "avail": "0", "total": "0"},
+            "apps": {"passed": 0, "failed": 0, "skipped": 0, "total": 0, "details": []},
+            "smoke": {"passed": 0, "failed": 0, "skipped": 0, "total": 0, "details": []},
+            "overall": "unknown",
+        }
+
+        self._setup_in_progress_cache: Optional[bool] = None
+        self._exec_transport: str = "qga"  # qga|ssh
+
+    def _get_ssh_key_path(self) -> Optional[Path]:
+        """Return path to the SSH key generated for this VM (if present)."""
+        try:
+            if self.conn_uri.endswith("/session"):
+                images_dir = Path.home() / ".local/share/libvirt/images"
+            else:
+                images_dir = Path("/var/lib/libvirt/images")
+            key_path = images_dir / self.vm_name / "ssh_key"
+            return key_path if key_path.exists() else None
+        except Exception:
+            return None
+
+    def _get_ssh_port(self) -> int:
+        """Deterministic host-side SSH port for passt port forwarding."""
+        return 22000 + (zlib.crc32(self.vm_name.encode("utf-8")) % 1000)
+
+    def _ssh_exec(self, command: str, timeout: int = 10) -> Optional[str]:
+        if shutil.which("ssh") is None:
+            return None
+        key_path = self._get_ssh_key_path()
+        if key_path is None:
+            return None
+
+        ssh_port = self._get_ssh_port()
+        user = (self.config.get("vm") or {}).get("username") or "ubuntu"
+
+        try:
+            result = subprocess.run(
+                [
+                    "ssh",
+                    "-i",
+                    str(key_path),
+                    "-p",
+                    str(ssh_port),
+                    "-o",
+                    "StrictHostKeyChecking=no",
+                    "-o",
+                    "UserKnownHostsFile=/dev/null",
+                    "-o",
+                    "ConnectTimeout=5",
+                    "-o",
+                    "BatchMode=yes",
+                    f"{user}@127.0.0.1",
+                    command,
+                ],
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+            if result.returncode != 0:
+                return None
+            return (result.stdout or "").strip()
+        except Exception:
+            return None
+
+    def _exec_in_vm(self, command: str, timeout: int = 10) -> Optional[str]:
+        """Execute command in VM using QEMU guest agent, with SSH fallback."""
+        if self._exec_transport == "ssh":
+            return self._ssh_exec(command, timeout=timeout)
+
+        try:
+            result = subprocess.run(
+                [
+                    "virsh",
+                    "--connect",
+                    self.conn_uri,
+                    "qemu-agent-command",
+                    self.vm_name,
+                    f'{{"execute":"guest-exec","arguments":{{"path":"/bin/sh","arg":["-c","{command}"],"capture-output":true}}}}',
+                ],
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+
+            if result.returncode != 0:
+                return None
+
+            response = json.loads(result.stdout)
+            if "return" not in response or "pid" not in response["return"]:
+                return None
+
+            pid = response["return"]["pid"]
+
+            deadline = time.time() + timeout
+            while time.time() < deadline:
+                status_result = subprocess.run(
+                    [
+                        "virsh",
+                        "--connect",
+                        self.conn_uri,
+                        "qemu-agent-command",
+                        self.vm_name,
+                        f'{{"execute":"guest-exec-status","arguments":{{"pid":{pid}}}}}',
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+
+                if status_result.returncode != 0:
+                    return None
+
+                status_resp = json.loads(status_result.stdout)
+                if "return" not in status_resp:
+                    return None
+
+                ret = status_resp["return"]
+                if ret.get("exited", False):
+                    if "out-data" in ret:
+                        return base64.b64decode(ret["out-data"]).decode().strip()
+                    return ""
+
+                time.sleep(0.2)
+
+            return None
+
+        except Exception:
+            return None
+
+    def _setup_in_progress(self) -> Optional[bool]:
+        if self._setup_in_progress_cache is not None:
+            return self._setup_in_progress_cache
+
+        out = self._exec_in_vm(
+            "test -f /var/lib/cloud/instance/boot-finished && echo no || echo yes",
+            timeout=10,
+        )
+        if out is None:
+            self._setup_in_progress_cache = None
+            return None
+
+        self._setup_in_progress_cache = out.strip() == "yes"
+        return self._setup_in_progress_cache
+
+    def _check_qga_ready(self) -> bool:
+        """Check if QEMU guest agent is responding."""
+        try:
+            result = subprocess.run(
+                [
+                    "virsh",
+                    "--connect",
+                    self.conn_uri,
+                    "qemu-agent-command",
+                    self.vm_name,
+                    '{"execute":"guest-ping"}',
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            return result.returncode == 0
+        except Exception:
+            return False

clonebox/validation/disk.py

@@ -0,0 +1,149 @@
+from typing import Dict, List, Optional, Tuple
+
+from rich.table import Table
+
+
+class DiskValidationMixin:
+    def validate_disk_space(self) -> Dict:
+        """Validate disk space on root filesystem."""
+        setup_in_progress = self._setup_in_progress() is True
+        self.console.print("\n[bold]💾 Validating Disk Space...[/]")
+
+        df_output = self._exec_in_vm("df -h / --output=pcent,avail,size | tail -n 1", timeout=20)
+        if not df_output:
+            self.console.print("[red]❌ Could not check disk space[/]")
+            return {"status": "error"}
+
+        try:
+            parts = df_output.split()
+            usage_pct = int(parts[0].replace("%", ""))
+            avail = parts[1]
+            total = parts[2]
+
+            self.results["disk"] = {"usage_pct": usage_pct, "avail": avail, "total": total}
+
+            if usage_pct > 90:
+                self.console.print(
+                    f"[red]❌ Disk nearly full: {usage_pct}% used ({avail} available of {total})[/]"
+                )
+                status = "fail"
+            elif usage_pct > 85:
+                self.console.print(
+                    f"[yellow]⚠️  Disk usage high: {usage_pct}% used ({avail} available of {total})[/]"
+                )
+                status = "warning"
+            else:
+                self.console.print(
+                    f"[green]✅ Disk space OK: {usage_pct}% used ({avail} available of {total})[/]"
+                )
+                status = "pass"
+
+            if usage_pct > 80:
+                self._print_disk_usage_breakdown()
+
+            return self.results["disk"]
+        except Exception as e:
+            self.console.print(f"[red]❌ Error parsing df output: {e}[/]")
+            return {"status": "error"}
+
+    def _print_disk_usage_breakdown(self) -> None:
+        def _parse_du_lines(out: Optional[str]) -> List[Tuple[str, str]]:
+            if not out:
+                return []
+            rows: List[Tuple[str, str]] = []
+            for line in out.splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                parts = line.split(maxsplit=1)
+                if len(parts) != 2:
+                    continue
+                size, path = parts
+                rows.append((path, size))
+            return rows
+
+        def _dir_size(path: str, timeout: int = 30) -> Optional[str]:
+            out = self._exec_in_vm(
+                f"du -x -s -h {path} 2>/dev/null | head -n 1 | cut -f1", timeout=timeout
+            )
+            return out.strip() if out else None
+
+        self.console.print("\n[bold]📁 Disk usage breakdown (largest directories)[/]")
+
+        top_level = self._exec_in_vm(
+            "du -x -h --max-depth=1 / 2>/dev/null | sort -hr | head -n 15",
+            timeout=60,
+        )
+        top_rows = _parse_du_lines(top_level)
+
+        if top_rows:
+            table = Table(title="Disk Usage: / (Top 15)", border_style="cyan")
+            table.add_column("Path", style="bold")
+            table.add_column("Size", justify="right")
+            for path, size in top_rows:
+                table.add_row(path, size)
+            self.console.print(table)
+        else:
+            self.console.print("[dim]Could not compute top-level directory sizes (du may be busy)[/]")
+
+        var_sz = _dir_size("/var")
+        home_sz = _dir_size("/home")
+        if var_sz or home_sz:
+            sum_table = Table(title="Disk Usage: Key Directories", border_style="cyan")
+            sum_table.add_column("Path", style="bold")
+            sum_table.add_column("Size", justify="right")
+            for p in [
+                "/var",
+                "/var/lib",
+                "/var/log",
+                "/var/cache",
+                "/var/lib/snapd",
+                "/home",
+                "/home/ubuntu",
+                "/tmp",
+            ]:
+                sz = _dir_size(p, timeout=30)
+                if sz:
+                    sum_table.add_row(p, sz)
+            self.console.print(sum_table)
+
+        var_breakdown = self._exec_in_vm(
+            "du -x -h --max-depth=1 /var 2>/dev/null | sort -hr | head -n 12",
+            timeout=60,
+        )
+        var_rows = _parse_du_lines(var_breakdown)
+        if var_rows:
+            vtable = Table(title="Disk Usage: /var (Top 12)", border_style="cyan")
+            vtable.add_column("Path", style="bold")
+            vtable.add_column("Size", justify="right")
+            for path, size in var_rows:
+                vtable.add_row(path, size)
+            self.console.print(vtable)
+
+        home_breakdown = self._exec_in_vm(
+            "du -x -h --max-depth=2 /home/ubuntu 2>/dev/null | sort -hr | head -n 12",
+            timeout=60,
+        )
+        home_rows = _parse_du_lines(home_breakdown)
+        if home_rows:
+            htable = Table(title="Disk Usage: /home/ubuntu (Top 12)", border_style="cyan")
+            htable.add_column("Path", style="bold")
+            htable.add_column("Size", justify="right")
+            for path, size in home_rows:
+                htable.add_row(path, size)
+            self.console.print(htable)
+
+        copy_paths = self.config.get("copy_paths", None)
+        if not isinstance(copy_paths, dict) or not copy_paths:
+            copy_paths = self.config.get("app_data_paths", {})
+        if copy_paths:
+            ctable = Table(title="Disk Usage: Configured Imported Paths", border_style="cyan")
+            ctable.add_column("Guest Path", style="bold")
+            ctable.add_column("Size", justify="right")
+            for _, guest_path in copy_paths.items():
+                sz = _dir_size(guest_path, timeout=30)
+                if sz:
+                    ctable.add_row(str(guest_path), sz)
+                else:
+                    ctable.add_row(str(guest_path), "—")
+            self.console.print(ctable)

clonebox/validation/mounts.py

@@ -0,0 +1,128 @@
+from typing import Dict
+
+from rich.table import Table
+
+
+class MountValidationMixin:
+    def validate_mounts(self) -> Dict:
+        """Validate all mount points and copied data paths."""
+        setup_in_progress = self._setup_in_progress_cache is True
+        self.console.print("\n[bold]💾 Validating Mounts & Data...[/]")
+
+        paths = self.config.get("paths", {})
+        copy_paths = self.config.get("copy_paths", None)
+        if not isinstance(copy_paths, dict) or not copy_paths:
+            copy_paths = self.config.get("app_data_paths", {})
+
+        if not paths and not copy_paths:
+            self.console.print("[dim]No mounts or data paths configured[/]")
+            return self.results["mounts"]
+
+        mount_output = self._exec_in_vm("mount | grep 9p")
+        mounted_paths = []
+        if mount_output:
+            for line in mount_output.split("\n"):
+                line = line.strip()
+                if not line:
+                    continue
+                parts = line.split()
+                if len(parts) >= 3:
+                    mounted_paths.append(parts[2])
+
+        mount_table = Table(title="Data Validation", border_style="cyan")
+        mount_table.add_column("Guest Path", style="bold")
+        mount_table.add_column("Type", justify="center")
+        mount_table.add_column("Status", justify="center")
+        mount_table.add_column("Files", justify="right")
+
+        for host_path, guest_path in paths.items():
+            self.results["mounts"]["total"] += 1
+
+            is_mounted = any(guest_path in mp for mp in mounted_paths)
+
+            accessible = False
+            file_count = "?"
+
+            if is_mounted:
+                test_result = self._exec_in_vm(f"test -d {guest_path} && echo 'yes' || echo 'no'")
+                accessible = test_result == "yes"
+
+                if accessible:
+                    count_str = self._exec_in_vm(f"ls -A {guest_path} 2>/dev/null | wc -l")
+                    if count_str and count_str.isdigit():
+                        file_count = count_str
+
+            if is_mounted and accessible:
+                status_icon = "[green]✅ Mounted[/]"
+                self.results["mounts"]["passed"] += 1
+                status = "pass"
+            elif is_mounted:
+                status_icon = "[red]❌ Inaccessible[/]"
+                self.results["mounts"]["failed"] += 1
+                status = "mounted_but_inaccessible"
+            elif setup_in_progress:
+                status_icon = "[yellow]⏳ Pending[/]"
+                status = "pending"
+                self.results["mounts"]["skipped"] += 1
+            else:
+                status_icon = "[red]❌ Not Mounted[/]"
+                self.results["mounts"]["failed"] += 1
+                status = "not_mounted"
+
+            mount_table.add_row(guest_path, "Bind Mount", status_icon, str(file_count))
+            self.results["mounts"]["details"].append(
+                {
+                    "path": guest_path,
+                    "type": "mount",
+                    "mounted": is_mounted,
+                    "accessible": accessible,
+                    "files": file_count,
+                    "status": status,
+                }
+            )
+
+        for host_path, guest_path in copy_paths.items():
+            self.results["mounts"]["total"] += 1
+
+            exists = False
+            file_count = "?"
+
+            test_result = self._exec_in_vm(f"test -d {guest_path} && echo 'yes' || echo 'no'")
+            exists = test_result == "yes"
+
+            if exists:
+                count_str = self._exec_in_vm(f"ls -A {guest_path} 2>/dev/null | wc -l")
+                if count_str and count_str.isdigit():
+                    file_count = count_str
+
+            if exists:
+                status_icon = "[green]✅ Copied[/]"
+                self.results["mounts"]["passed"] += 1
+                status = "pass"
+            elif setup_in_progress:
+                status_icon = "[yellow]⏳ Pending[/]"
+                status = "pending"
+                self.results["mounts"]["skipped"] += 1
+            else:
+                status_icon = "[red]❌ Missing[/]"
+                self.results["mounts"]["failed"] += 1
+                status = "missing"
+
+            mount_table.add_row(guest_path, "Imported", status_icon, str(file_count))
+            self.results["mounts"]["details"].append(
+                {
+                    "path": guest_path,
+                    "type": "copy",
+                    "mounted": False,
+                    "accessible": exists,
+                    "files": file_count,
+                    "status": status,
+                }
+            )
+
+        self.console.print(mount_table)
+        self.console.print(
+            f"[dim]{self.results['mounts']['passed']}/{self.results['mounts']['total']} paths valid[/]"
+        )
+
+        return self.results["mounts"]