clonebox 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

clonebox/interfaces/process.py

@@ -0,0 +1,46 @@
+"""Abstract interface for process execution."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+@dataclass
+class ProcessResult:
+    """Result of process execution."""
+
+    returncode: int
+    stdout: str
+    stderr: str
+
+    @property
+    def success(self) -> bool:
+        return self.returncode == 0
+
+
+class ProcessRunner(ABC):
+    """Abstract interface for process execution."""
+
+    @abstractmethod
+    def run(
+        self,
+        command: List[str],
+        capture_output: bool = True,
+        timeout: Optional[int] = None,
+        check: bool = True,
+        cwd: Optional[Path] = None,
+        env: Optional[Dict[str, str]] = None,
+    ) -> ProcessResult:
+        """Run a command."""
+        pass
+
+    @abstractmethod
+    def run_shell(
+        self,
+        command: str,
+        capture_output: bool = True,
+        timeout: Optional[int] = None,
+    ) -> ProcessResult:
+        """Run a shell command."""
+        pass

clonebox/logging.py

@@ -0,0 +1,125 @@
+"""
+Structured logging for CloneBox using structlog.
+"""
+
+import logging
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import structlog
+
+
+def configure_logging(
+    level: str = "INFO",
+    json_output: bool = False,
+    log_file: Optional[Path] = None,
+    console_output: bool = True,
+) -> None:
+    """
+    Configure structured logging for CloneBox.
+
+    Args:
+        level: Log level (DEBUG, INFO, WARNING, ERROR)
+        json_output: If True, output JSON format (good for log aggregation)
+        log_file: Optional file path for log output
+        console_output: If True, also output to console
+    """
+
+    # Shared processors for all outputs
+    shared_processors = [
+        structlog.contextvars.merge_contextvars,
+        structlog.processors.add_log_level,
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.UnicodeDecoder(),
+    ]
+
+    if json_output:
+        # JSON output for production/aggregation
+        renderer = structlog.processors.JSONRenderer()
+    else:
+        # Human-readable output for development
+        renderer = structlog.dev.ConsoleRenderer(
+            colors=True,
+            exception_formatter=structlog.dev.plain_traceback,
+        )
+
+    structlog.configure(
+        processors=shared_processors
+        + [
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        wrapper_class=structlog.stdlib.BoundLogger,
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+    # Configure standard logging
+    handlers = []
+
+    if console_output:
+        console_handler = logging.StreamHandler(sys.stderr)
+        console_handler.setFormatter(
+            structlog.stdlib.ProcessorFormatter(
+                processor=renderer,
+                foreign_pre_chain=shared_processors,
+            )
+        )
+        handlers.append(console_handler)
+
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(
+            structlog.stdlib.ProcessorFormatter(
+                processor=structlog.processors.JSONRenderer(),  # Always JSON for files
+                foreign_pre_chain=shared_processors,
+            )
+        )
+        handlers.append(file_handler)
+
+    logging.basicConfig(
+        format="%(message)s",
+        level=getattr(logging, level.upper()),
+        handlers=handlers,
+    )
+
+
+def get_logger(name: str = "clonebox") -> structlog.stdlib.BoundLogger:
+    """Get a structured logger instance."""
+    return structlog.get_logger(name)
+
+
+# Context managers for operation tracking
+from contextlib import contextmanager
+
+
+@contextmanager
+def log_operation(logger: structlog.stdlib.BoundLogger, operation: str, **kwargs):
+    """
+    Context manager for logging operation start/end.
+
+    Usage:
+        with log_operation(log, "create_vm", vm_name="my-vm"):
+            # do stuff
+    """
+    log = logger.bind(operation=operation, **kwargs)
+    start_time = datetime.now()
+    log.info(f"{operation}.started")
+
+    try:
+        yield log
+        duration_ms = (datetime.now() - start_time).total_seconds() * 1000
+        log.info(f"{operation}.completed", duration_ms=round(duration_ms, 2))
+    except Exception as e:
+        duration_ms = (datetime.now() - start_time).total_seconds() * 1000
+        log.error(
+            f"{operation}.failed",
+            error=str(e),
+            error_type=type(e).__name__,
+            duration_ms=round(duration_ms, 2),
+        )
+        raise

clonebox/monitor.py

@@ -0,0 +1,267 @@
+#!/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/p2p.py

@@ -14,8 +14,10 @@ class P2PManager:
 
     def __init__(self, ssh_options: Optional[list] = None):
         self.ssh_options = ssh_options or [
-            "-o", "StrictHostKeyChecking=no",
-            "-o", "UserKnownHostsFile=/dev/null",
+            "-o",
+            "StrictHostKeyChecking=no",
+            "-o",
+            "UserKnownHostsFile=/dev/null",
         ]
 
     def _run_ssh(self, host: str, command: str) -> subprocess.CompletedProcess:

clonebox/resource_monitor.py

@@ -0,0 +1,162 @@
+"""Resource monitoring system for CloneBox."""
+
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+try:
+    import libvirt
+except ImportError:
+    libvirt = None
+
+
+@dataclass
+class ResourceUsage:
+    """Current resource usage of a VM."""
+
+    timestamp: datetime
+    cpu_time_ns: int
+    cpu_percent: float
+    memory_used_bytes: int
+    memory_total_bytes: int
+    memory_percent: float
+    swap_used_bytes: int
+    disk_read_bytes: int
+    disk_write_bytes: int
+    disk_read_requests: int
+    disk_write_requests: int
+    net_rx_bytes: int
+    net_tx_bytes: int
+    net_rx_packets: int
+    net_tx_packets: int
+
+
+class ResourceMonitor:
+    """Monitor VM resource usage using libvirt."""
+
+    def __init__(self, conn: Optional[Any] = None):
+        self.conn = conn
+        self._prev_stats: Dict[str, Dict] = {}
+
+    def get_usage(self, vm_name: str) -> ResourceUsage:
+        """Get current resource usage for a VM."""
+        if not self.conn:
+            raise RuntimeError("libvirt connection not available")
+
+        domain = self.conn.lookupByName(vm_name)
+        if not domain.isActive():
+            raise RuntimeError(f"VM '{vm_name}' is not running")
+
+        # CPU stats
+        cpu_stats = domain.getCPUStats(True)[0]
+        cpu_time = cpu_stats.get("cpu_time", 0)
+        cpu_percent = self._calculate_cpu_percent(vm_name, cpu_time)
+
+        # Memory stats
+        # Need to ensure memory balloon driver is active for accurate stats
+        mem_stats = domain.memoryStats()
+        memory_used = mem_stats.get("rss", 0) * 1024  # RSS is often most accurate for host view
+        memory_total = mem_stats.get("actual", 1) * 1024
+        if "unused" in mem_stats:
+            memory_used = (mem_stats["actual"] - mem_stats["unused"]) * 1024
+        
+        memory_percent = (memory_used / memory_total * 100) if memory_total else 0
+        swap_used = mem_stats.get("swap_in", 0) * 1024
+
+        # Block and Network stats
+        disk_stats = self._get_disk_stats(domain)
+        net_stats = self._get_network_stats(domain)
+
+        return ResourceUsage(
+            timestamp=datetime.now(),
+            cpu_time_ns=cpu_time,
+            cpu_percent=cpu_percent,
+            memory_used_bytes=memory_used,
+            memory_total_bytes=memory_total,
+            memory_percent=memory_percent,
+            swap_used_bytes=swap_used,
+            **disk_stats,
+            **net_stats,
+        )
+
+    def _calculate_cpu_percent(self, vm_name: str, cpu_time: int) -> float:
+        """Calculate CPU percentage from time delta."""
+        import time
+
+        now = time.time()
+        prev = self._prev_stats.get(vm_name, {})
+        prev_time = prev.get("cpu_time", cpu_time)
+        prev_timestamp = prev.get("timestamp", now)
+
+        # Update stored stats
+        self._prev_stats[vm_name] = {
+            "cpu_time": cpu_time,
+            "timestamp": now,
+        }
+
+        time_delta = now - prev_timestamp
+        if time_delta <= 0:
+            return 0.0
+
+        cpu_delta = cpu_time - prev_time
+        # cpu_time is in nanoseconds, time_delta in seconds
+        # (delta_ns / (delta_sec * 1e9)) * 100
+        return (cpu_delta / (time_delta * 1e9)) * 100
+
+    def _get_disk_stats(self, domain) -> Dict[str, int]:
+        """Get aggregated disk stats."""
+        stats = {
+            "disk_read_bytes": 0,
+            "disk_write_bytes": 0,
+            "disk_read_requests": 0,
+            "disk_write_requests": 0,
+        }
+
+        xml = domain.XMLDesc()
+        tree = ET.fromstring(xml)
+
+        for disk in tree.findall(".//disk"):
+            target = disk.find("target")
+            if target is not None:
+                dev = target.get("dev")
+                try:
+                    # blockStats returns: (read_req, read_bytes, write_req, write_bytes, errs)
+                    ds = domain.blockStats(dev)
+                    stats["disk_read_requests"] += ds[0]
+                    stats["disk_read_bytes"] += ds[1]
+                    stats["disk_write_requests"] += ds[2]
+                    stats["disk_write_bytes"] += ds[3]
+                except Exception:
+                    continue
+
+        return stats
+
+    def _get_network_stats(self, domain) -> Dict[str, int]:
+        """Get aggregated network stats."""
+        stats = {
+            "net_rx_bytes": 0,
+            "net_tx_bytes": 0,
+            "net_rx_packets": 0,
+            "net_tx_packets": 0,
+        }
+
+        xml = domain.XMLDesc()
+        tree = ET.fromstring(xml)
+
+        for iface in tree.findall(".//interface"):
+            target = iface.find("target")
+            if target is not None:
+                dev = target.get("dev")
+                try:
+                    # interfaceStats returns: (rx_bytes, rx_packets, rx_errs, rx_drop, 
+                    #                          tx_bytes, tx_packets, tx_errs, tx_drop)
+                    ns = domain.interfaceStats(dev)
+                    stats["net_rx_bytes"] += ns[0]
+                    stats["net_rx_packets"] += ns[1]
+                    stats["net_tx_bytes"] += ns[4]
+                    stats["net_tx_packets"] += ns[5]
+                except Exception:
+                    continue
+
+        return stats