clonebox 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

clonebox/health/models.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Data models for health check system."""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+
+class HealthStatus(Enum):
+    """Health check status."""
+
+    HEALTHY = "healthy"
+    UNHEALTHY = "unhealthy"
+    DEGRADED = "degraded"
+    UNKNOWN = "unknown"
+    TIMEOUT = "timeout"
+
+
+class ProbeType(Enum):
+    """Type of health probe."""
+
+    HTTP = "http"
+    TCP = "tcp"
+    COMMAND = "command"
+    SCRIPT = "script"
+
+
+@dataclass
+class ProbeConfig:
+    """Configuration for a health probe."""
+
+    name: str
+    probe_type: ProbeType
+    enabled: bool = True
+
+    # Timing
+    timeout_seconds: float = 5.0
+    interval_seconds: float = 30.0
+    retries: int = 3
+    retry_delay_seconds: float = 1.0
+
+    # HTTP probe
+    url: Optional[str] = None
+    method: str = "GET"
+    expected_status: int = 200
+    expected_body: Optional[str] = None
+    expected_json: Optional[Dict[str, Any]] = None
+    headers: Dict[str, str] = field(default_factory=dict)
+
+    # TCP probe
+    host: str = "localhost"
+    port: Optional[int] = None
+
+    # Command probe
+    command: Optional[str] = None
+    expected_output: Optional[str] = None
+    expected_exit_code: int = 0
+
+    # Script probe
+    script_path: Optional[str] = None
+
+    # Thresholds
+    failure_threshold: int = 3  # Consecutive failures before unhealthy
+    success_threshold: int = 1  # Consecutive successes before healthy
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "name": self.name,
+            "type": self.probe_type.value,
+            "enabled": self.enabled,
+            "timeout": self.timeout_seconds,
+            "interval": self.interval_seconds,
+            "retries": self.retries,
+            "url": self.url,
+            "method": self.method,
+            "expected_status": self.expected_status,
+            "expected_body": self.expected_body,
+            "expected_json": self.expected_json,
+            "headers": self.headers,
+            "host": self.host,
+            "port": self.port,
+            "command": self.command,
+            "expected_output": self.expected_output,
+            "expected_exit_code": self.expected_exit_code,
+            "script_path": self.script_path,
+            "failure_threshold": self.failure_threshold,
+            "success_threshold": self.success_threshold,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ProbeConfig":
+        """Create from dictionary."""
+        return cls(
+            name=data["name"],
+            probe_type=ProbeType(data.get("type", "command")),
+            enabled=data.get("enabled", True),
+            timeout_seconds=data.get("timeout", 5.0),
+            interval_seconds=data.get("interval", 30.0),
+            retries=data.get("retries", 3),
+            url=data.get("url"),
+            method=data.get("method", "GET"),
+            expected_status=data.get("expected_status", 200),
+            expected_body=data.get("expected_body"),
+            expected_json=data.get("expected_json"),
+            headers=data.get("headers", {}),
+            host=data.get("host", "localhost"),
+            port=data.get("port"),
+            command=data.get("command") or data.get("exec"),
+            expected_output=data.get("expected_output"),
+            expected_exit_code=data.get("expected_exit_code", data.get("exit_code", 0)),
+            script_path=data.get("script_path") or data.get("path"),
+            failure_threshold=data.get("failure_threshold", 3),
+            success_threshold=data.get("success_threshold", 1),
+        )
+
+
+@dataclass
+class HealthCheckResult:
+    """Result of a health check."""
+
+    probe_name: str
+    status: HealthStatus
+    checked_at: datetime
+    duration_ms: float
+
+    message: Optional[str] = None
+    error: Optional[str] = None
+    details: Dict[str, Any] = field(default_factory=dict)
+
+    # Response info (for HTTP)
+    response_code: Optional[int] = None
+    response_body: Optional[str] = None
+
+    # Command info
+    exit_code: Optional[int] = None
+    stdout: Optional[str] = None
+    stderr: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "probe_name": self.probe_name,
+            "status": self.status.value,
+            "checked_at": self.checked_at.isoformat(),
+            "duration_ms": self.duration_ms,
+            "message": self.message,
+            "error": self.error,
+            "details": self.details,
+            "response_code": self.response_code,
+            "exit_code": self.exit_code,
+        }
+
+    @property
+    def is_healthy(self) -> bool:
+        """Check if result indicates healthy status."""
+        return self.status == HealthStatus.HEALTHY
+
+
+@dataclass
+class VMHealthState:
+    """Aggregated health state for a VM."""
+
+    vm_name: str
+    overall_status: HealthStatus
+    last_check: datetime
+    check_results: List[HealthCheckResult] = field(default_factory=list)
+
+    # Counters
+    consecutive_failures: int = 0
+    consecutive_successes: int = 0
+    total_checks: int = 0
+    total_failures: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "vm_name": self.vm_name,
+            "overall_status": self.overall_status.value,
+            "last_check": self.last_check.isoformat(),
+            "check_results": [r.to_dict() for r in self.check_results],
+            "consecutive_failures": self.consecutive_failures,
+            "consecutive_successes": self.consecutive_successes,
+            "total_checks": self.total_checks,
+            "total_failures": self.total_failures,
+        }
+
+    @property
+    def failure_rate(self) -> float:
+        """Calculate failure rate percentage."""
+        if self.total_checks == 0:
+            return 0.0
+        return (self.total_failures / self.total_checks) * 100

clonebox/importer.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+VM Importer - Import VM with path reconfiguration and decryption.
+"""
+
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Optional
+
+from cryptography.fernet import Fernet
+
+try:
+    import libvirt
+except ImportError:
+    libvirt = None
+
+
+class VMImporter:
+    """Import VM with disk path reconfiguration."""
+
+    DEFAULT_DISK_DIR = Path("/var/lib/libvirt/images")
+
+    def __init__(self, conn_uri: str = "qemu:///system"):
+        self.conn_uri = conn_uri
+        self._conn = None
+
+    @property
+    def conn(self):
+        if self._conn is None:
+            if libvirt is None:
+                raise RuntimeError("libvirt-python not installed")
+            self._conn = libvirt.open(self.conn_uri)
+        return self._conn
+
+    def import_vm(
+        self,
+        archive_path: Path,
+        import_user_data: bool = False,
+        import_app_data: bool = False,
+        new_name: Optional[str] = None,
+        disk_dir: Optional[Path] = None,
+    ) -> str:
+        """Import VM from archive with full path reconfiguration."""
+        disk_dir = disk_dir or self.DEFAULT_DISK_DIR
+
+        with tempfile.TemporaryDirectory(prefix="clonebox-import-") as tmp_dir:
+            tmp_path = Path(tmp_dir)
+
+            # Extract archive
+            with tarfile.open(archive_path) as tar:
+                tar.extractall(tmp_path)
+
+            # Find XML file
+            xml_files = list(tmp_path.glob("*.xml"))
+            if not xml_files:
+                raise FileNotFoundError("No XML configuration found in archive")
+            xml_file = xml_files[0]
+            vm_name = xml_file.stem
+
+            # Move disks to libvirt images directory
+            disks_dir = tmp_path / "disks"
+            disk_mapping = {}
+            if disks_dir.exists():
+                for disk_file in disks_dir.iterdir():
+                    dest = disk_dir / disk_file.name
+                    shutil.copy2(disk_file, dest)
+                    disk_mapping[disk_file.name] = dest
+                    print(f"   💾 Copied disk: {dest}")
+
+            # Reconfigure disk paths in XML
+            vm_xml = self._reconfigure_paths(xml_file, disk_mapping, new_name)
+
+            # Define and create VM
+            vm = self.conn.defineXML(vm_xml)
+            final_name = new_name or vm_name
+            print(f"   ✅ VM defined: {final_name}")
+
+            # Import user/app data
+            if import_user_data:
+                self._import_user_data(tmp_path / "user-data")
+            if import_app_data:
+                self._import_app_data(tmp_path / "app-data")
+
+            # Start VM
+            vm.create()
+            print(f"   🚀 VM started: {final_name}")
+
+            return final_name
+
+    def _reconfigure_paths(
+        self,
+        xml_file: Path,
+        disk_mapping: dict,
+        new_name: Optional[str] = None,
+    ) -> str:
+        """Update disk paths and optionally rename VM."""
+        tree = ET.parse(xml_file)
+        root = tree.getroot()
+
+        # Update name if requested
+        if new_name:
+            name_elem = root.find("name")
+            if name_elem is not None:
+                name_elem.text = new_name
+
+        # Update disk paths
+        for disk in root.findall(".//disk[@type='file']"):
+            source = disk.find(".//source")
+            if source is not None:
+                old_path = source.get("file")
+                if old_path:
+                    disk_name = Path(old_path).name
+                    if disk_name in disk_mapping:
+                        source.set("file", str(disk_mapping[disk_name]))
+                        print(f"   🔄 Remapped: {disk_name} → {disk_mapping[disk_name]}")
+
+        return ET.tostring(root, encoding="unicode")
+
+    def _import_user_data(self, user_data_dir: Path) -> None:
+        """Restore user data."""
+        if user_data_dir.exists():
+            for item in user_data_dir.iterdir():
+                dest = Path.home() / item.name
+                if item.is_dir():
+                    shutil.copytree(item, dest, dirs_exist_ok=True)
+                else:
+                    shutil.copy2(item, dest)
+                print(f"   👤 Restored: {dest}")
+
+    def _import_app_data(self, app_data_dir: Path) -> None:
+        """Restore application data."""
+        if app_data_dir.exists():
+            for item in app_data_dir.iterdir():
+                # Map back to original paths
+                dest_map = {
+                    "projects": Path.home() / "projects",
+                    ".docker": Path.home() / ".docker",
+                    "myapp": Path("/opt/myapp"),
+                    "www": Path("/var/www"),
+                    "docker": Path("/srv/docker"),
+                }
+                dest = dest_map.get(item.name, Path.home() / item.name)
+                try:
+                    if item.is_dir():
+                        shutil.copytree(item, dest, dirs_exist_ok=True)
+                    else:
+                        shutil.copy2(item, dest)
+                    print(f"   📁 Restored: {dest}")
+                except PermissionError:
+                    print(f"   ⚠️ Permission denied: {dest}")
+
+    def close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None
+
+
+class SecureImporter:
+    """AES-256 decrypting VM importer."""
+
+    KEY_PATH = Path.home() / ".clonebox.key"
+
+    def __init__(self, conn_uri: str = "qemu:///system"):
+        self.importer = VMImporter(conn_uri)
+
+    @classmethod
+    def load_key(cls) -> Optional[bytes]:
+        """Load decryption key from file."""
+        if cls.KEY_PATH.exists():
+            return cls.KEY_PATH.read_bytes()
+        return None
+
+    def import_decrypted(
+        self,
+        encrypted_path: Path,
+        import_user_data: bool = False,
+        import_app_data: bool = False,
+        new_name: Optional[str] = None,
+    ) -> str:
+        """Import VM with AES-256 decryption."""
+        key = self.load_key()
+        if key is None:
+            raise FileNotFoundError(
+                f"No decryption key found at {self.KEY_PATH}. "
+                "Copy the team key to this location."
+            )
+
+        fernet = Fernet(key)
+
+        # Create temporary decrypted archive
+        with tempfile.NamedTemporaryFile(suffix=".tar.gz", delete=False) as tmp:
+            tmp_path = Path(tmp.name)
+
+        try:
+            # Decrypt
+            encrypted_data = encrypted_path.read_bytes()
+            decrypted = fernet.decrypt(encrypted_data)
+            tmp_path.write_bytes(decrypted)
+
+            # Import
+            vm_name = self.importer.import_vm(
+                archive_path=tmp_path,
+                import_user_data=import_user_data,
+                import_app_data=import_app_data,
+                new_name=new_name,
+            )
+
+        finally:
+            # Cleanup
+            if tmp_path.exists():
+                tmp_path.unlink()
+
+        return vm_name
+
+    def close(self) -> None:
+        self.importer.close()

clonebox/monitor.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+Real-time resource monitoring for CloneBox VMs and containers.
+"""
+
+import json
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+try:
+    import libvirt
+except ImportError:
+    libvirt = None
+
+
+@dataclass
+class VMStats:
+    """VM resource statistics."""
+
+    name: str
+    state: str
+    cpu_percent: float
+    memory_used_mb: int
+    memory_total_mb: int
+    disk_used_gb: float
+    disk_total_gb: float
+    network_rx_bytes: int
+    network_tx_bytes: int
+    uptime_seconds: int
+
+
+@dataclass
+class ContainerStats:
+    """Container resource statistics."""
+
+    name: str
+    state: str
+    cpu_percent: float
+    memory_used_mb: int
+    memory_limit_mb: int
+    network_rx_bytes: int
+    network_tx_bytes: int
+    pids: int
+
+
+class ResourceMonitor:
+    """Monitor VM and container resources in real-time."""
+
+    def __init__(self, conn_uri: str = "qemu:///session"):
+        self.conn_uri = conn_uri
+        self._conn = None
+        self._prev_cpu: Dict[str, tuple] = {}
+
+    @property
+    def conn(self):
+        if self._conn is None:
+            if libvirt is None:
+                raise RuntimeError("libvirt-python not installed")
+            self._conn = libvirt.open(self.conn_uri)
+        return self._conn
+
+    def get_vm_stats(self, vm_name: str) -> Optional[VMStats]:
+        """Get resource statistics for a VM."""
+        try:
+            dom = self.conn.lookupByName(vm_name)
+            info = dom.info()
+
+            state_map = {
+                libvirt.VIR_DOMAIN_RUNNING: "running",
+                libvirt.VIR_DOMAIN_PAUSED: "paused",
+                libvirt.VIR_DOMAIN_SHUTDOWN: "shutdown",
+                libvirt.VIR_DOMAIN_SHUTOFF: "shutoff",
+                libvirt.VIR_DOMAIN_CRASHED: "crashed",
+            }
+            state = state_map.get(info[0], "unknown")
+
+            # Memory
+            memory_total_mb = info[1] // 1024
+            memory_used_mb = info[2] // 1024 if info[2] > 0 else memory_total_mb
+
+            # CPU percentage (requires two samples)
+            cpu_time = info[4]
+            now = time.time()
+            cpu_percent = 0.0
+
+            if vm_name in self._prev_cpu:
+                prev_time, prev_cpu = self._prev_cpu[vm_name]
+                time_delta = now - prev_time
+                if time_delta > 0:
+                    cpu_delta = cpu_time - prev_cpu
+                    # CPU time is in nanoseconds
+                    cpu_percent = (cpu_delta / (time_delta * 1e9)) * 100
+                    cpu_percent = min(cpu_percent, 100.0 * info[3])  # Cap at vcpus * 100%
+
+            self._prev_cpu[vm_name] = (now, cpu_time)
+
+            # Disk stats (from block devices)
+            disk_used_gb = 0.0
+            disk_total_gb = 0.0
+            try:
+                xml = dom.XMLDesc()
+                import xml.etree.ElementTree as ET
+
+                root = ET.fromstring(xml)
+                for disk in root.findall(".//disk[@type='file']"):
+                    source = disk.find(".//source")
+                    if source is not None and source.get("file"):
+                        disk_path = Path(source.get("file"))
+                        if disk_path.exists():
+                            size_bytes = disk_path.stat().st_size
+                            disk_total_gb += size_bytes / (1024**3)
+                            # Actual usage requires qemu-img info
+                            disk_used_gb += size_bytes / (1024**3)
+            except Exception:
+                pass
+
+            # Network stats
+            network_rx = 0
+            network_tx = 0
+            try:
+                for iface in dom.interfaceAddresses(
+                    libvirt.VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT
+                ).keys():
+                    stats = dom.interfaceStats(iface)
+                    network_rx += stats[0]
+                    network_tx += stats[4]
+            except Exception:
+                pass
+
+            return VMStats(
+                name=vm_name,
+                state=state,
+                cpu_percent=cpu_percent,
+                memory_used_mb=memory_used_mb,
+                memory_total_mb=memory_total_mb,
+                disk_used_gb=disk_used_gb,
+                disk_total_gb=disk_total_gb,
+                network_rx_bytes=network_rx,
+                network_tx_bytes=network_tx,
+                uptime_seconds=0,  # Would need guest agent for accurate uptime
+            )
+
+        except Exception:
+            return None
+
+    def get_all_vm_stats(self) -> List[VMStats]:
+        """Get stats for all VMs."""
+        stats = []
+        try:
+            for dom in self.conn.listAllDomains():
+                vm_stats = self.get_vm_stats(dom.name())
+                if vm_stats:
+                    stats.append(vm_stats)
+        except Exception:
+            pass
+        return stats
+
+    def get_container_stats(self, engine: str = "auto") -> List[ContainerStats]:
+        """Get resource statistics for containers."""
+        if engine == "auto":
+            engine = "podman" if self._check_engine("podman") else "docker"
+
+        try:
+            result = subprocess.run(
+                [engine, "stats", "--no-stream", "--format", "json"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode != 0:
+                return []
+
+            containers = json.loads(result.stdout) if result.stdout.strip() else []
+            stats = []
+
+            for c in containers:
+                # Parse CPU percentage
+                cpu_str = c.get("CPUPerc", "0%").replace("%", "")
+                try:
+                    cpu_percent = float(cpu_str)
+                except ValueError:
+                    cpu_percent = 0.0
+
+                # Parse memory
+                mem_usage = c.get("MemUsage", "0MiB / 0MiB")
+                mem_parts = mem_usage.split("/")
+                mem_used = self._parse_memory(mem_parts[0].strip()) if len(mem_parts) > 0 else 0
+                mem_limit = self._parse_memory(mem_parts[1].strip()) if len(mem_parts) > 1 else 0
+
+                # Parse network
+                net_io = c.get("NetIO", "0B / 0B")
+                net_parts = net_io.split("/")
+                net_rx = self._parse_bytes(net_parts[0].strip()) if len(net_parts) > 0 else 0
+                net_tx = self._parse_bytes(net_parts[1].strip()) if len(net_parts) > 1 else 0
+
+                stats.append(
+                    ContainerStats(
+                        name=c.get("Name", c.get("Names", "unknown")),
+                        state="running",
+                        cpu_percent=cpu_percent,
+                        memory_used_mb=mem_used,
+                        memory_limit_mb=mem_limit,
+                        network_rx_bytes=net_rx,
+                        network_tx_bytes=net_tx,
+                        pids=int(c.get("PIDs", 0)),
+                    )
+                )
+
+            return stats
+
+        except Exception:
+            return []
+
+    def _check_engine(self, engine: str) -> bool:
+        """Check if container engine is available."""
+        try:
+            result = subprocess.run(
+                [engine, "--version"], capture_output=True, timeout=5
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+    def _parse_memory(self, mem_str: str) -> int:
+        """Parse memory string like '100MiB' to MB."""
+        mem_str = mem_str.upper()
+        try:
+            if "GIB" in mem_str or "GB" in mem_str:
+                return int(float(mem_str.replace("GIB", "").replace("GB", "").strip()) * 1024)
+            elif "MIB" in mem_str or "MB" in mem_str:
+                return int(float(mem_str.replace("MIB", "").replace("MB", "").strip()))
+            elif "KIB" in mem_str or "KB" in mem_str:
+                return int(float(mem_str.replace("KIB", "").replace("KB", "").strip()) / 1024)
+            else:
+                return int(float(mem_str.replace("B", "").strip()) / (1024 * 1024))
+        except ValueError:
+            return 0
+
+    def _parse_bytes(self, bytes_str: str) -> int:
+        """Parse byte string like '1.5GB' to bytes."""
+        bytes_str = bytes_str.upper()
+        try:
+            if "GB" in bytes_str:
+                return int(float(bytes_str.replace("GB", "").strip()) * 1024**3)
+            elif "MB" in bytes_str:
+                return int(float(bytes_str.replace("MB", "").strip()) * 1024**2)
+            elif "KB" in bytes_str:
+                return int(float(bytes_str.replace("KB", "").strip()) * 1024)
+            else:
+                return int(float(bytes_str.replace("B", "").strip()))
+        except ValueError:
+            return 0
+
+    def close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None
+
+
+def format_bytes(num_bytes: int) -> str:
+    """Format bytes to human-readable string."""
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if abs(num_bytes) < 1024.0:
+            return f"{num_bytes:.1f}{unit}"
+        num_bytes /= 1024.0
+    return f"{num_bytes:.1f}PB"