clonebox 1.1.3__tar.gz → 1.1.4__tar.gz

{clonebox-1.1.3/src/clonebox.egg-info → clonebox-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 1.1.3
+Version: 1.1.4
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0

{clonebox-1.1.3 → clonebox-1.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "clonebox"
-version = "1.1.3"
+version = "1.1.4"
 description = "Clone your workstation environment to an isolated VM with selective apps, paths and services"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{clonebox-1.1.3 → clonebox-1.1.4}/src/clonebox/cli.py

@@ -30,6 +30,7 @@ from clonebox.models import ContainerConfig
 from clonebox.profiles import merge_with_profile
 from clonebox.exporter import SecureExporter, VMExporter
 from clonebox.importer import SecureImporter, VMImporter
+from clonebox.monitor import ResourceMonitor, format_bytes
 from clonebox.p2p import P2PManager
 
 # Custom questionary style
@@ -2638,6 +2639,118 @@ def cmd_detect(args):
         console.print(table)
 
 
+def cmd_monitor(args) -> None:
+    """Real-time resource monitoring for VMs and containers."""
+    conn_uri = "qemu:///session" if getattr(args, "user", False) else "qemu:///system"
+    refresh = getattr(args, "refresh", 2.0)
+    once = getattr(args, "once", False)
+
+    monitor = ResourceMonitor(conn_uri)
+
+    try:
+        while True:
+            # Clear screen for live update
+            if not once:
+                console.clear()
+
+            console.print("[bold cyan]📊 CloneBox Resource Monitor[/]")
+            console.print()
+
+            # VM Stats
+            vm_stats = monitor.get_all_vm_stats()
+            if vm_stats:
+                table = Table(title="🖥️ Virtual Machines", border_style="cyan")
+                table.add_column("Name", style="bold")
+                table.add_column("State")
+                table.add_column("CPU %")
+                table.add_column("Memory")
+                table.add_column("Disk")
+                table.add_column("Network I/O")
+
+                for vm in vm_stats:
+                    state_color = "green" if vm.state == "running" else "yellow"
+                    cpu_color = "red" if vm.cpu_percent > 80 else "green"
+                    mem_pct = (vm.memory_used_mb / vm.memory_total_mb * 100) if vm.memory_total_mb > 0 else 0
+                    mem_color = "red" if mem_pct > 80 else "green"
+
+                    table.add_row(
+                        vm.name,
+                        f"[{state_color}]{vm.state}[/]",
+                        f"[{cpu_color}]{vm.cpu_percent:.1f}%[/]",
+                        f"[{mem_color}]{vm.memory_used_mb}/{vm.memory_total_mb} MB[/]",
+                        f"{vm.disk_used_gb:.1f}/{vm.disk_total_gb:.1f} GB",
+                        f"↓{format_bytes(vm.network_rx_bytes)} ↑{format_bytes(vm.network_tx_bytes)}",
+                    )
+                console.print(table)
+            else:
+                console.print("[dim]No VMs found.[/]")
+
+            console.print()
+
+            # Container Stats
+            container_stats = monitor.get_container_stats()
+            if container_stats:
+                table = Table(title="🐳 Containers", border_style="blue")
+                table.add_column("Name", style="bold")
+                table.add_column("State")
+                table.add_column("CPU %")
+                table.add_column("Memory")
+                table.add_column("Network I/O")
+                table.add_column("PIDs")
+
+                for c in container_stats:
+                    cpu_color = "red" if c.cpu_percent > 80 else "green"
+                    mem_pct = (c.memory_used_mb / c.memory_limit_mb * 100) if c.memory_limit_mb > 0 else 0
+                    mem_color = "red" if mem_pct > 80 else "green"
+
+                    table.add_row(
+                        c.name,
+                        f"[green]{c.state}[/]",
+                        f"[{cpu_color}]{c.cpu_percent:.1f}%[/]",
+                        f"[{mem_color}]{c.memory_used_mb}/{c.memory_limit_mb} MB[/]",
+                        f"↓{format_bytes(c.network_rx_bytes)} ↑{format_bytes(c.network_tx_bytes)}",
+                        str(c.pids),
+                    )
+                console.print(table)
+            else:
+                console.print("[dim]No containers running.[/]")
+
+            if once:
+                break
+
+            console.print(f"\n[dim]Refreshing every {refresh}s. Press Ctrl+C to exit.[/]")
+            time.sleep(refresh)
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Monitoring stopped.[/]")
+    finally:
+        monitor.close()
+
+
+def cmd_exec(args) -> None:
+    """Execute command in VM via QEMU Guest Agent."""
+    vm_name, config_file = _resolve_vm_name_and_config_file(args.name)
+    conn_uri = "qemu:///session" if getattr(args, "user", False) else "qemu:///system"
+    command = args.command
+    timeout = getattr(args, "timeout", 30)
+
+    if not _qga_ping(vm_name, conn_uri):
+        console.print(f"[red]❌ Cannot connect to VM '{vm_name}' via QEMU Guest Agent[/]")
+        console.print("[dim]Make sure the VM is running and qemu-guest-agent is installed.[/]")
+        return
+
+    console.print(f"[cyan]▶ Executing in {vm_name}:[/] {command}")
+
+    result = _qga_exec(vm_name, conn_uri, command, timeout=timeout)
+
+    if result is None:
+        console.print("[red]❌ Command execution failed or timed out[/]")
+    elif result == "":
+        console.print("[dim](no output)[/]")
+    else:
+        console.print(result)
+
+
 def cmd_keygen(args) -> None:
     """Generate encryption key for secure P2P transfers."""
     key_path = SecureExporter.generate_key()
@@ -3198,6 +3311,35 @@ def main():
     )
     test_parser.set_defaults(func=cmd_test)
 
+    # Monitor command - real-time resource monitoring
+    monitor_parser = subparsers.add_parser("monitor", help="Real-time resource monitoring")
+    monitor_parser.add_argument(
+        "-u", "--user", action="store_true", help="Use user session (qemu:///session)"
+    )
+    monitor_parser.add_argument(
+        "--refresh", "-r", type=float, default=2.0, help="Refresh interval in seconds (default: 2)"
+    )
+    monitor_parser.add_argument(
+        "--once", action="store_true", help="Show stats once and exit"
+    )
+    monitor_parser.set_defaults(func=cmd_monitor)
+
+    # Exec command - execute command in VM
+    exec_parser = subparsers.add_parser("exec", help="Execute command in VM via QEMU Guest Agent")
+    exec_parser.add_argument(
+        "name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml"
+    )
+    exec_parser.add_argument(
+        "command", help="Command to execute in VM"
+    )
+    exec_parser.add_argument(
+        "-u", "--user", action="store_true", help="Use user session (qemu:///session)"
+    )
+    exec_parser.add_argument(
+        "--timeout", "-t", type=int, default=30, help="Command timeout in seconds (default: 30)"
+    )
+    exec_parser.set_defaults(func=cmd_exec)
+
     # === P2P Secure Transfer Commands ===
 
     # Keygen command - generate encryption key

clonebox-1.1.4/src/clonebox/health/__init__.py

@@ -0,0 +1,16 @@
+"""Health check system for CloneBox VMs."""
+
+from .models import HealthCheckResult, HealthStatus, ProbeConfig
+from .probes import HTTPProbe, TCPProbe, CommandProbe, ScriptProbe
+from .manager import HealthCheckManager
+
+__all__ = [
+    "HealthCheckResult",
+    "HealthStatus",
+    "ProbeConfig",
+    "HTTPProbe",
+    "TCPProbe",
+    "CommandProbe",
+    "ScriptProbe",
+    "HealthCheckManager",
+]

clonebox-1.1.4/src/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-1.1.4/src/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"

clonebox-1.1.4/src/clonebox/snapshots/__init__.py

@@ -0,0 +1,12 @@
+"""Snapshot management for CloneBox VMs."""
+
+from .models import Snapshot, SnapshotType, SnapshotState, SnapshotPolicy
+from .manager import SnapshotManager
+
+__all__ = [
+    "Snapshot",
+    "SnapshotType",
+    "SnapshotState",
+    "SnapshotPolicy",
+    "SnapshotManager",
+]