golem-vm-provider 0.1.0__py3-none-any.whl

provider/utils/port_display.py

@@ -0,0 +1,204 @@
+"""Port verification display utilities."""
+import time
+import sys
+import asyncio
+from typing import Dict, List, Optional
+from ..network.port_verifier import PortVerificationResult
+
+class PortVerificationDisplay:
+    """Display utilities for port verification status."""
+    
+    SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+    
+    def __init__(self, provider_port: int, port_range_start: int, port_range_end: int):
+        """Initialize the display.
+        
+        Args:
+            provider_port: Port used for provider access
+            port_range_start: Start of VM access port range
+            port_range_end: End of VM access port range
+        """
+        self.provider_port = provider_port
+        self.port_range_start = port_range_start
+        self.port_range_end = port_range_end
+        self.spinner_idx = 0
+    
+    def _update_spinner(self):
+        """Update and return the next spinner frame."""
+        frame = self.SPINNER_FRAMES[self.spinner_idx]
+        self.spinner_idx = (self.spinner_idx + 1) % len(self.SPINNER_FRAMES)
+        return frame
+    
+    async def animate_verification(self, text: str, duration: float = 1.0):
+        """Show an animated spinner while verifying.
+        
+        Args:
+            text: Text to show with spinner
+            duration: How long to show the animation
+        """
+        start_time = time.time()
+        while time.time() - start_time < duration:
+            sys.stdout.write(f"\r{self._update_spinner()} {text}")
+            sys.stdout.flush()
+            await asyncio.sleep(0.1)
+        sys.stdout.write("\r" + " " * (len(text) + 2) + "\r")
+        sys.stdout.flush()
+    
+    def print_header(self):
+        """Print the verification status header."""
+        print("\n🌟 Port Verification Status")
+        print("==========================")
+        
+    async def print_discovery_status(self, result: PortVerificationResult):
+        """Print discovery service status with tree structure.
+        
+        Args:
+            result: Verification result for discovery port
+        """
+        print("\n📡 Provider Accessibility (Required)")
+        print("--------------------------------")
+        
+        await self.animate_verification("Checking provider accessibility...")
+        
+        status_badge = "✅ Accessible" if result.accessible else "❌ Not Accessible"
+        print(f"[{status_badge}] Port {self.provider_port}")
+        print(f"└─ Status: {'Accessible' if result.accessible else 'Not Accessible'}")
+        
+        # Show external/internal access
+        if result.accessible:
+            print("└─ Access: External ✓ | Internal ✓")
+            print("└─ Requestors can discover and connect to your provider")
+        else:
+            print("└─ Access: External ✗ | Internal ✗")
+            print("└─ Requestors cannot discover or connect to your provider")
+            
+        # Show verification server if successful
+        if result.verified_by:
+            print(f"└─ Verified By: {result.verified_by}")
+            
+    async def print_ssh_status(self, results: Dict[int, PortVerificationResult]):
+        """Print SSH ports status with progress bar.
+        
+        Args:
+            results: Dictionary mapping ports to their verification results
+        """
+        print("\n🔒 VM Access Ports (Required)")
+        print("-------------------------")
+        
+        await self.animate_verification("Scanning VM access ports...")
+        
+        # Calculate progress
+        total_ports = len(results)
+        accessible_ports = sum(1 for r in results.values() if r.accessible)
+        percentage = (accessible_ports / total_ports) * 100 if total_ports > 0 else 0
+        
+        # Create animated progress bar
+        bar_width = 30
+        for i in range(bar_width + 1):
+            filled = int(i * percentage / 100)
+            bar = "█" * filled + "░" * (bar_width - filled)
+            sys.stdout.write(f"\r[{bar}] {percentage:.1f}%")
+            sys.stdout.flush()
+            time.sleep(0.02)
+        print()
+        
+        # List available ports
+        available = [port for port, result in results.items() if result.accessible]
+        if available:
+            print(f"\nAvailable Ports: {', '.join(map(str, sorted(available)))}")
+        else:
+            print("\nAvailable Ports: None")
+            
+        print(f"Required: At least 1 port in range {self.port_range_start}-{self.port_range_end}")
+        
+    def print_critical_issues(self, discovery_result: PortVerificationResult, 
+                            ssh_results: Dict[int, PortVerificationResult]):
+        """Print critical issues with actionable items.
+        
+        Args:
+            discovery_result: Verification result for discovery port
+            ssh_results: Dictionary mapping SSH ports to their verification results
+        """
+        issues = []
+        
+        # Check discovery port
+        if not discovery_result.accessible:
+            issues.append((f"Port {self.provider_port} is not accessible",
+                         "Requestors cannot discover or connect to your provider",
+                         f"Configure port forwarding for port {self.provider_port}"))
+            
+        # Check SSH ports
+        if not any(r.accessible for r in ssh_results.values()):
+            issues.append(("No VM access ports are accessible",
+                         "Requestors will not be able to access their rented VMs",
+                         f"Configure port forwarding for range {self.port_range_start}-{self.port_range_end}"))
+            
+        if issues:
+            print("\n🚨 Critical Issues")
+            print("---------------")
+            for i, (issue, impact, action) in enumerate(issues, 1):
+                print(f"{i}. {issue}")
+                print(f"   ↳ {impact}")
+                print(f"   ↳ Action: {action}")
+                
+    def print_quick_fix(self, discovery_result: PortVerificationResult,
+                       ssh_results: Dict[int, PortVerificationResult]):
+        """Print quick fix guide only if there are issues.
+        
+        Args:
+            discovery_result: Verification result for discovery port
+            ssh_results: Dictionary mapping SSH ports to their verification results
+        """
+        # Check if we have any issues
+        has_issues = (
+            not discovery_result.accessible or 
+            not any(r.accessible for r in ssh_results.values())
+        )
+        
+        if has_issues:
+            print("\n💡 Quick Fix Guide")
+            print("---------------")
+            
+            print("1. Check your router's port forwarding settings")
+            print(f"   ↳ Forward ports {self.port_range_start}-{self.port_range_end} to this machine")
+            print("   ↳ Tutorial: docs.golem.network/port-forwarding")
+            
+            print("\n2. Verify firewall rules")
+            print("   ↳ Allow incoming TCP connections on ports:")
+            print(f"     • {self.provider_port} (Provider Access)")
+            print(f"     • {self.port_range_start}-{self.port_range_end} (VM Access)")
+            print("   ↳ Tutorial: docs.golem.network/firewall-setup")
+            
+            print("\nNeed help? Visit our troubleshooting guide: docs.golem.network/ports")
+        
+    def print_summary(self, discovery_result: PortVerificationResult,
+                     ssh_results: Dict[int, PortVerificationResult]):
+        """Print a precise, actionable summary of the verification status.
+        
+        Args:
+            discovery_result: Verification result for discovery port
+            ssh_results: Dictionary mapping SSH ports to their verification results
+        """
+        print("\n🎯 Current Status:", end=" ")
+        
+        accessible_ssh_ports = [port for port, result in ssh_results.items() if result.accessible]
+        
+        if not discovery_result.accessible:
+            print("Provider Not Discoverable")
+            print(f"└─ Reason: Port {self.provider_port} is not accessible")
+            print("└─ Impact: Requestors cannot find or connect to your provider")
+            print(f"└─ Fix: Configure port forwarding for port {self.provider_port}")
+            
+        elif not accessible_ssh_ports:
+            print("VMs Not Accessible")
+            print("└─ Reason: No VM access ports are available")
+            print("└─ Impact: Requestors will not be able to access their rented VMs")
+            print(f"└─ Fix: Configure port forwarding for range {self.port_range_start}-{self.port_range_end}")
+            
+        else:
+            status = "Provider Ready" if len(accessible_ssh_ports) > 5 else "Provider Ready with Limited Capacity"
+            print(status)
+            print(f"└─ Available: {len(accessible_ssh_ports)} SSH ports ({', '.join(map(str, sorted(accessible_ssh_ports)[:3]))}{'...' if len(accessible_ssh_ports) > 3 else ''})")
+            print(f"└─ Capacity: Can handle up to {len(accessible_ssh_ports)} concurrent VMs")
+            if len(accessible_ssh_ports) <= 5:
+                print("└─ Recommendation: Open more ports for higher capacity")

provider/utils/retry.py

@@ -0,0 +1,48 @@
+import asyncio
+import logging
+from functools import wraps
+from typing import TypeVar, Callable, Any
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar('T')
+
+def async_retry(
+    retries: int = 3,
+    delay: float = 1.0,
+    backoff: float = 2.0,
+    exceptions: tuple = (Exception,)
+) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    """
+    Retry decorator for async functions with exponential backoff.
+    
+    Args:
+        retries: Maximum number of retries
+        delay: Initial delay between retries in seconds
+        backoff: Multiplier for delay after each retry
+        exceptions: Tuple of exceptions to catch
+    """
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> T:
+            current_delay = delay
+            last_exception = None
+            
+            for attempt in range(retries + 1):
+                try:
+                    return await func(*args, **kwargs)
+                except exceptions as e:
+                    last_exception = e
+                    if attempt == retries:
+                        break
+                    
+                    logger.warning(
+                        f"Attempt {attempt + 1}/{retries} failed for {func.__name__}: {e}. "
+                        f"Retrying in {current_delay:.1f}s..."
+                    )
+                    await asyncio.sleep(current_delay)
+                    current_delay *= backoff
+            
+            raise last_exception
+        return wrapper
+    return decorator

provider/vm/__init__.py

@@ -0,0 +1,31 @@
+from .models import (
+    VMConfig,
+    VMInfo,
+    VMStatus,
+    VMSize,
+    VMResources,
+    SSHKey,
+    VMProvider,
+    VMError,
+    VMCreateError,
+    VMNotFoundError,
+    VMStateError,
+    ResourceError
+)
+from .multipass import MultipassProvider
+
+__all__ = [
+    "VMConfig",
+    "VMInfo",
+    "VMStatus",
+    "VMSize",
+    "VMResources",
+    "SSHKey",
+    "VMProvider",
+    "MultipassProvider",
+    "VMError",
+    "VMCreateError",
+    "VMNotFoundError",
+    "VMStateError",
+    "ResourceError"
+]

provider/vm/cloud_init.py

@@ -0,0 +1,67 @@
+import yaml
+import tempfile
+from pathlib import Path
+from typing import Dict, Optional
+
+def generate_cloud_init(
+    hostname: str,
+    ssh_key: str,
+    packages: Optional[list[str]] = None,
+    runcmd: Optional[list[str]] = None
+) -> str:
+    """Generate cloud-init configuration.
+    
+    Args:
+        hostname: VM hostname
+        ssh_key: SSH public key to add to authorized_keys
+        packages: List of packages to install
+        runcmd: List of commands to run on first boot
+    
+    Returns:
+        Path to cloud-init configuration file
+    """
+    config = {
+        "hostname": hostname,
+        "package_update": True,
+        "package_upgrade": True,
+        "ssh_authorized_keys": [ssh_key],
+        "users": [{
+            "name": "root",
+            "ssh_authorized_keys": [ssh_key]
+        }],
+        "write_files": [
+            {
+                "path": "/etc/ssh/sshd_config.d/allow_root.conf",
+                "content": "PermitRootLogin prohibit-password\n",
+                "owner": "root:root",
+                "permissions": "0644"
+            }
+        ],
+        "runcmd": [
+            "systemctl restart ssh"
+        ]
+    }
+
+    if packages:
+        config["packages"] = packages
+
+    if runcmd:
+        config["runcmd"].extend(runcmd)
+
+    # Create temporary file
+    temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False)
+    yaml.safe_dump(config, temp_file)
+    temp_file.close()
+
+    return temp_file.name
+
+def cleanup_cloud_init(path: str) -> None:
+    """Clean up cloud-init configuration file.
+    
+    Args:
+        path: Path to cloud-init configuration file
+    """
+    try:
+        Path(path).unlink()
+    except Exception:
+        pass

provider/vm/models.py

@@ -0,0 +1,205 @@
+from enum import Enum
+from pydantic import BaseModel, Field, validator
+from typing import Dict, Optional
+from datetime import datetime
+
+
+class VMStatus(str, Enum):
+    """VM status enum."""
+    CREATING = "creating"
+    RUNNING = "running"
+    STOPPING = "stopping"
+    STOPPED = "stopped"
+    ERROR = "error"
+    DELETED = "deleted"
+
+
+class VMSize(str, Enum):
+    """Predefined VM sizes."""
+    SMALL = "small"      # 1 CPU, 1GB RAM, 10GB storage
+    MEDIUM = "medium"    # 2 CPU, 4GB RAM, 20GB storage
+    LARGE = "large"      # 4 CPU, 8GB RAM, 40GB storage
+    XLARGE = "xlarge"    # 8 CPU, 16GB RAM, 80GB storage
+
+
+class VMResources(BaseModel):
+    """VM resource configuration."""
+    cpu: int = Field(..., ge=1, description="Number of CPU cores")
+    memory: int = Field(..., ge=1, description="Memory in GB")
+    storage: int = Field(..., ge=10, description="Storage in GB")
+
+    @validator("cpu")
+    def validate_cpu(cls, v: int) -> int:
+        """Validate CPU cores."""
+        if v not in [1, 2, 4, 8, 16]:
+            raise ValueError("CPU cores must be 1, 2, 4, 8, or 16")
+        return v
+
+    @validator("memory")
+    def validate_memory(cls, v: int) -> int:
+        """Validate memory."""
+        if v not in [1, 2, 4, 8, 16, 32, 64]:
+            raise ValueError("Memory must be 1, 2, 4, 8, 16, 32, or 64 GB")
+        return v
+
+    @classmethod
+    def from_size(cls, size: VMSize) -> "VMResources":
+        """Create resources from predefined size."""
+        sizes = {
+            VMSize.SMALL: {"cpu": 1, "memory": 1, "storage": 10},
+            VMSize.MEDIUM: {"cpu": 2, "memory": 4, "storage": 20},
+            VMSize.LARGE: {"cpu": 4, "memory": 8, "storage": 40},
+            VMSize.XLARGE: {"cpu": 8, "memory": 16, "storage": 80}
+        }
+        return cls(**sizes[size])
+
+
+class VMCreateRequest(BaseModel):
+    """Request to create a new VM."""
+    name: str = Field(..., min_length=3, max_length=64,
+                      regex="^[a-z0-9][a-z0-9-]*[a-z0-9]$")
+    size: Optional[VMSize] = None
+    cpu_cores: Optional[int] = None
+    memory_gb: Optional[int] = None
+    storage_gb: Optional[int] = None
+    image: Optional[str] = Field(default="24.04")  # Ubuntu 24.04 LTS
+    ssh_key: str = Field(..., regex="^(ssh-rsa|ssh-ed25519) ",
+                         description="SSH public key for VM access")
+
+    @validator("name")
+    def validate_name(cls, v: str) -> str:
+        """Validate VM name."""
+        if "--" in v:
+            raise ValueError("VM name cannot contain consecutive hyphens")
+        return v
+
+    @validator("cpu_cores")
+    def validate_cpu(cls, v: Optional[int]) -> Optional[int]:
+        """Validate CPU cores."""
+        if v is not None and v not in [1, 2, 4, 8, 16]:
+            raise ValueError("CPU cores must be 1, 2, 4, 8, or 16")
+        return v
+
+    @validator("memory_gb")
+    def validate_memory(cls, v: Optional[int]) -> Optional[int]:
+        """Validate memory."""
+        if v is not None and v not in [1, 2, 4, 8, 16, 32, 64]:
+            raise ValueError("Memory must be 1, 2, 4, 8, 16, 32, or 64 GB")
+        return v
+
+
+class VMConfig(BaseModel):
+    """VM configuration."""
+    name: str = Field(..., min_length=3, max_length=64,
+                      regex="^[a-z0-9][a-z0-9-]*[a-z0-9]$")
+    resources: VMResources
+    image: str = Field(default="24.04")  # Ubuntu 24.04 LTS
+    size: Optional[VMSize] = None
+    ssh_key: str = Field(..., regex="^(ssh-rsa|ssh-ed25519) ",
+                         description="SSH public key for VM access")
+
+    @validator("name")
+    def validate_name(cls, v: str) -> str:
+        """Validate VM name."""
+        if "--" in v:
+            raise ValueError("VM name cannot contain consecutive hyphens")
+        return v
+
+
+class VMInfo(BaseModel):
+    """VM information."""
+    id: str
+    name: str
+    status: VMStatus
+    resources: VMResources
+    ip_address: Optional[str] = None
+    ssh_port: Optional[int] = None
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+    error_message: Optional[str] = None
+
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+
+
+class SSHKey(BaseModel):
+    """SSH key information."""
+    name: str = Field(..., min_length=1, max_length=64)
+    public_key: str = Field(..., regex="^(ssh-rsa|ssh-ed25519) ")
+    fingerprint: Optional[str] = None
+
+
+class VMAccessInfo(BaseModel):
+    """VM access information."""
+    ssh_host: str
+    ssh_port: int
+    vm_id: str = Field(..., description="Requestor's VM name")
+    multipass_name: str = Field(...,
+                                description="Full multipass VM name with timestamp")
+
+
+class VMProvider:
+    """Base interface for VM providers."""
+
+    async def initialize(self) -> None:
+        """Initialize the provider."""
+        raise NotImplementedError()
+
+    async def cleanup(self) -> None:
+        """Cleanup provider resources."""
+        raise NotImplementedError()
+
+    async def create_vm(self, config: VMConfig) -> VMInfo:
+        """Create a new VM."""
+        raise NotImplementedError()
+
+    async def delete_vm(self, vm_id: str) -> None:
+        """Delete a VM."""
+        raise NotImplementedError()
+
+    async def start_vm(self, vm_id: str) -> VMInfo:
+        """Start a VM."""
+        raise NotImplementedError()
+
+    async def stop_vm(self, vm_id: str) -> VMInfo:
+        """Stop a VM."""
+        raise NotImplementedError()
+
+    async def get_vm_status(self, vm_id: str) -> VMInfo:
+        """Get VM status."""
+        raise NotImplementedError()
+
+    async def add_ssh_key(self, vm_id: str, key: SSHKey) -> None:
+        """Add SSH key to VM."""
+        raise NotImplementedError()
+
+
+class VMError(Exception):
+    """Base class for VM errors."""
+
+    def __init__(self, message: str, vm_id: Optional[str] = None):
+        self.message = message
+        self.vm_id = vm_id
+        super().__init__(message)
+
+
+class VMCreateError(VMError):
+    """Error creating VM."""
+    pass
+
+
+class VMNotFoundError(VMError):
+    """VM not found."""
+    pass
+
+
+class VMStateError(VMError):
+    """Invalid VM state for operation."""
+    pass
+
+
+class ResourceError(VMError):
+    """Resource allocation error."""
+    pass