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

provider/main.py

@@ -0,0 +1,125 @@
+import asyncio
+from fastapi import FastAPI
+from typing import Optional
+
+from .config import settings
+from .utils.logging import setup_logger, PROCESS, SUCCESS
+from .utils.ascii_art import startup_animation
+from .discovery.resource_tracker import ResourceTracker
+from .discovery.advertiser import ResourceAdvertiser
+from .vm.multipass import MultipassProvider
+from .vm.port_manager import PortManager
+
+logger = setup_logger(__name__)
+
+app = FastAPI(title="VM on Golem Provider")
+
+async def setup_provider() -> None:
+    """Setup and initialize the provider components."""
+    try:
+        # Initialize port manager (verification already done in run.py)
+        logger.process("🔄 Initializing port manager...")
+        port_manager = PortManager()
+        app.state.port_manager = port_manager
+        
+        # Create resource tracker
+        logger.process("🔄 Initializing resource tracker...")
+        resource_tracker = ResourceTracker()
+        app.state.resource_tracker = resource_tracker
+        
+        # Create provider with resource tracker and port manager
+        logger.process("🔄 Initializing VM provider...")
+        provider = MultipassProvider(resource_tracker, port_manager=port_manager)
+        try:
+            await asyncio.wait_for(provider.initialize(), timeout=30)
+            app.state.provider = provider
+            
+            # Store proxy manager reference for cleanup
+            app.state.proxy_manager = provider.proxy_manager
+            
+        except asyncio.TimeoutError:
+            logger.error("Provider initialization timed out")
+            raise
+        except Exception as e:
+            logger.error(f"Failed to initialize provider: {e}")
+            raise
+        
+        # Create and start advertiser in background
+        logger.process("🔄 Starting resource advertiser...")
+        advertiser = ResourceAdvertiser(
+            resource_tracker=resource_tracker,
+            discovery_url=settings.DISCOVERY_URL,
+            provider_id=settings.PROVIDER_ID
+        )
+        
+        # Start advertiser in background task
+        app.state.advertiser_task = asyncio.create_task(advertiser.start())
+        app.state.advertiser = advertiser
+        
+        logger.success("✨ Provider setup complete and ready to accept requests")
+    except Exception as e:
+        logger.error(f"Failed to setup provider: {e}")
+        # Attempt cleanup of any initialized components
+        await cleanup_provider()
+        raise
+
+async def cleanup_provider() -> None:
+    """Cleanup provider components."""
+    cleanup_errors = []
+    
+    # Stop advertiser
+    if hasattr(app.state, "advertiser"):
+        try:
+            await app.state.advertiser.stop()
+            if hasattr(app.state, "advertiser_task"):
+                app.state.advertiser_task.cancel()
+                try:
+                    await app.state.advertiser_task
+                except asyncio.CancelledError:
+                    pass
+        except Exception as e:
+            cleanup_errors.append(f"Failed to stop advertiser: {e}")
+    
+    # Cleanup proxy manager first to stop all proxy servers
+    if hasattr(app.state, "proxy_manager"):
+        try:
+            await asyncio.wait_for(app.state.proxy_manager.cleanup(), timeout=30)
+        except asyncio.TimeoutError:
+            cleanup_errors.append("Proxy manager cleanup timed out")
+        except Exception as e:
+            cleanup_errors.append(f"Failed to cleanup proxy manager: {e}")
+    
+    # Cleanup provider
+    if hasattr(app.state, "provider"):
+        try:
+            await asyncio.wait_for(app.state.provider.cleanup(), timeout=30)
+        except asyncio.TimeoutError:
+            cleanup_errors.append("Provider cleanup timed out")
+        except Exception as e:
+            cleanup_errors.append(f"Failed to cleanup provider: {e}")
+    
+    if cleanup_errors:
+        error_msg = "\n".join(cleanup_errors)
+        logger.error(f"Errors during cleanup:\n{error_msg}")
+    else:
+        logger.success("✨ Provider cleanup complete")
+
+@app.on_event("startup")
+async def startup_event():
+    """Handle application startup."""
+    # Display startup animation
+    await startup_animation()
+    # Initialize provider
+    await setup_provider()
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Handle application shutdown."""
+    await cleanup_provider()
+
+# Import routes after app creation to avoid circular imports
+from .api import routes
+app.include_router(routes.router, prefix="/api/v1")
+
+# Export app for uvicorn
+__all__ = ["app"]

provider/network/port_verifier.py

@@ -0,0 +1,287 @@
+import socket
+import asyncio
+import aiohttp
+import logging
+from typing import Set, List, Dict, Optional, Tuple
+from dataclasses import dataclass
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ServerAttempt:
+    """Result of a single server's verification attempt."""
+    server: str
+    success: bool
+    error: Optional[str] = None
+
+@dataclass
+class PortVerificationResult:
+    """Result of port verification."""
+    port: int
+    accessible: bool
+    error: str = None
+    verified_by: str = None  # Server that successfully verified the port
+    attempts: List[ServerAttempt] = None  # Track all server attempts
+
+class PortVerifier:
+    """Verifies port accessibility both locally and externally."""
+    
+    def __init__(self, port_check_servers: List[str], discovery_port: int = 7466):
+        """Initialize port verifier.
+        
+        Args:
+            port_check_servers: List of URLs for port checking services
+            discovery_port: Port used for discovery service
+        """
+        self.port_check_servers = port_check_servers
+        self.discovery_port = discovery_port
+    
+    async def verify_local_binding(self, ports: List[int]) -> Set[int]:
+        """Try to bind to ports locally to verify availability.
+        
+        Args:
+            ports: List of ports to verify
+            
+        Returns:
+            Set of ports that were successfully bound
+        """
+        available_ports = set()
+        temp_listeners = []
+        
+        for port in ports:
+            try:
+                # For discovery port, create a temporary TCP listener
+                if port == self.discovery_port:
+                    try:
+                        server = await asyncio.start_server(
+                            lambda r, w: None,  # Empty callback since we just need to listen
+                            '0.0.0.0', 
+                            port
+                        )
+                        temp_listeners.append(server)
+                        available_ports.add(port)
+                        logger.debug(f"Created temporary listener for discovery port {port}")
+                        continue
+                    except Exception as e:
+                        if isinstance(e, OSError) and e.errno == 98:  # Address already in use
+                            # This might be our own server starting up
+                            available_ports.add(port)
+                            logger.debug(f"Port {port} is already in use - this is expected if our server is starting")
+                            continue
+                        logger.debug(f"Failed to create temporary listener for discovery port {port}: {e}")
+                        continue
+                
+                # For other ports, create a TCP listener
+                try:
+                    server = await asyncio.start_server(
+                        lambda r, w: None,  # Empty callback since we just need to listen
+                        '0.0.0.0', 
+                        port
+                    )
+                    temp_listeners.append(server)
+                    available_ports.add(port)
+                    logger.debug(f"Created temporary listener on port {port}")
+                except Exception as e:
+                    if isinstance(e, OSError) and e.errno == 98:  # Address already in use
+                        logger.debug(f"Port {port} is already in use")
+                    else:
+                        logger.debug(f"Failed to bind to port {port}: {e}")
+                    continue
+            except Exception as e:
+                logger.debug(f"Failed to bind to port {port}: {e}")
+                continue
+        
+        try:
+            # Keep all temporary listeners active during verification
+            yield available_ports
+        finally:
+            # Cleanup temporary listeners
+            for server in temp_listeners:
+                server.close()
+                await server.wait_closed()
+            if temp_listeners:
+                logger.debug(f"Closed {len(temp_listeners)} temporary listeners")
+    
+    async def _get_public_ip(self) -> str:
+        """Get public IP address using external service."""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get('https://api.ipify.org') as response:
+                    return await response.text()
+        except Exception as e:
+            # Fallback to non-async request if aiohttp fails
+            return requests.get('https://api.ipify.org').text
+    
+    async def verify_external_access(
+        self, 
+        ports: Set[int]
+    ) -> Dict[int, PortVerificationResult]:
+        """Verify external accessibility using port check servers.
+        
+        Args:
+            ports: Set of ports to verify
+            
+        Returns:
+            Dictionary mapping ports to their verification results
+        """
+        results = {}
+        attempts = []
+        
+        # Try each server
+        for server in self.port_check_servers:
+            try:
+                public_ip = await self._get_public_ip()
+                
+                async with aiohttp.ClientSession() as session:
+                    response = await session.post(
+                        f"{server}/check-ports",
+                        json={
+                            "provider_ip": public_ip,
+                            "ports": list(ports)
+                        },
+                        timeout=30  # 30 second timeout for port checking
+                    )
+                    
+                    if response.status == 200:
+                        data = await response.json()
+                        if data["success"]:
+                            # Convert server results to PortVerificationResult objects
+                            for port_str, result in data["results"].items():
+                                port = int(port_str)
+                                if port not in results or not results[port].accessible:
+                                    # Only update if we haven't found a successful verification yet
+                                    results[port] = PortVerificationResult(
+                                        port=port,
+                                        accessible=result["accessible"],
+                                        error=result.get("error"),
+                                        verified_by=server if result["accessible"] else None,
+                                        attempts=[]  # Will be filled at the end
+                                    )
+                            attempts.append(ServerAttempt(server=server, success=True))
+                            logger.info(f"Port verification completed using {server}")
+                        else:
+                            attempts.append(ServerAttempt(
+                                server=server,
+                                success=False,
+                                error="Server returned unsuccessful response"
+                            ))
+                    else:
+                        attempts.append(ServerAttempt(
+                            server=server,
+                            success=False,
+                            error=f"Server returned status {response.status}"
+                        ))
+            except asyncio.TimeoutError:
+                attempts.append(ServerAttempt(
+                    server=server,
+                    success=False,
+                    error="Connection timed out"
+                ))
+                logger.warning(f"Timeout while verifying ports with {server}")
+            except Exception as e:
+                attempts.append(ServerAttempt(
+                    server=server,
+                    success=False,
+                    error=str(e)
+                ))
+                logger.warning(f"Failed to verify ports with {server}: {e}")
+        
+        # If no successful verifications, mark all ports as inaccessible
+        if not any(result.accessible for result in results.values()):
+            logger.error("Failed to verify ports with any server")
+            results = {
+                port: PortVerificationResult(
+                    port=port,
+                    accessible=False,
+                    error="Failed to verify with any port check server",
+                    attempts=[]  # Will be filled below
+                )
+                for port in ports
+            }
+        
+        # Add attempts to all results
+        for result in results.values():
+            result.attempts = attempts
+        
+        return results
+    
+    async def _create_temp_listener(self, port: int) -> Optional[asyncio.Server]:
+        """Create a temporary TCP listener for port verification."""
+        try:
+            # First check if port is already in use
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(1)
+            result = sock.connect_ex(('127.0.0.1', port))
+            sock.close()
+            
+            if result == 0:
+                logger.debug(f"Port {port} is already in use - this is expected if our server is running")
+                return None
+            
+            try:
+                server = await asyncio.start_server(
+                    lambda r, w: None,  # Empty callback since we just need to listen
+                    '0.0.0.0', 
+                    port
+                )
+                logger.debug(f"Created temporary listener on port {port}")
+                return server
+            except PermissionError:
+                logger.error(f"Permission denied when trying to bind to port {port}")
+                return None
+            except OSError as e:
+                if e.errno == 98:  # Address already in use
+                    logger.debug(f"Port {port} is already in use - this is expected if our server is running")
+                    return None
+                logger.error(f"Failed to create listener on port {port}: {e}")
+                return None
+            except Exception as e:
+                logger.error(f"Unexpected error creating listener on port {port}: {e}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Failed to check port {port} status: {e}")
+            return None
+
+    async def verify_ports(self, ports: List[int]) -> Dict[int, PortVerificationResult]:
+        """Verify ports both locally and externally.
+        
+        Args:
+            ports: List of ports to verify
+            
+        Returns:
+            Dictionary mapping ports to their verification results
+        """
+        # Separate discovery port from other ports
+        other_ports = [p for p in ports if p != self.discovery_port]
+        discovery_port_included = self.discovery_port in ports
+        
+        # First verify ports with local binding
+        logger.info("Checking local port availability...")
+        async for local_available in self.verify_local_binding(ports):
+            if not local_available:
+                logger.error("No ports available for local binding")
+                return {
+                    port: PortVerificationResult(
+                        port=port,
+                        accessible=False,
+                        error="Failed to bind locally"
+                    )
+                    for port in ports
+                }
+            
+            # Verify external access while listeners are active
+            logger.info("Starting external port verification...")
+            results = await self.verify_external_access(local_available)
+            
+            # Log detailed results for discovery port
+            if discovery_port_included and self.discovery_port in results:
+                result = results[self.discovery_port]
+                if result.accessible:
+                    logger.info(f"Discovery port {self.discovery_port} verified successfully by {result.verified_by}")
+                else:
+                    logger.error(f"Discovery port {self.discovery_port} verification failed: {result.error}")
+            
+            return results

provider/security/ethereum.py

@@ -0,0 +1,41 @@
+"""Ethereum key management for provider identity."""
+import os
+from pathlib import Path
+from eth_account import Account
+import json
+
+class EthereumIdentity:
+    """Manage provider's Ethereum identity."""
+    
+    def __init__(self, key_dir: str = None):
+        if key_dir is None:
+            key_dir = str(Path.home() / ".golem" / "provider" / "keys")
+        self.key_dir = Path(key_dir)
+        self.key_file = self.key_dir / "provider_key.json"
+        
+    def get_or_create_identity(self) -> str:
+        """Get existing provider ID or create new one from Ethereum key."""
+        # Create directory if it doesn't exist
+        self.key_dir.mkdir(parents=True, exist_ok=True)
+        self.key_dir.chmod(0o700)  # Secure permissions
+        
+        # Check for existing key
+        if self.key_file.exists():
+            with open(self.key_file) as f:
+                key_data = json.load(f)
+                return key_data["address"]
+        
+        # Generate new key
+        Account.enable_unaudited_hdwallet_features()
+        acct = Account.create()
+        
+        # Save key securely
+        key_data = {
+            "address": acct.address,
+            "private_key": acct.key.hex()
+        }
+        with open(self.key_file, "w") as f:
+            json.dump(key_data, f)
+        self.key_file.chmod(0o600)  # Secure permissions
+        
+        return acct.address

provider/utils/ascii_art.py

@@ -0,0 +1,79 @@
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
+from rich.style import Style
+import time
+import asyncio
+
+# Initialize Rich console
+console = Console()
+
+# ASCII Art Logo
+LOGO = """
+[bold cyan] _    ____  __  __[/bold cyan]
+[bold cyan]| |  / /  |/  / /___ _____[/bold cyan]
+[bold cyan]| | / / /|_/ / __/ // / _ \\[/bold cyan]
+[bold cyan]| |/ / /  / / /_/ _  /  __/[/bold cyan]
+[bold cyan]|___/_/  /_/\\__/_//_/\\___/[/bold cyan]
+[bold magenta]   ____  _   __[/bold magenta]   [bold yellow]______[/bold yellow]    [bold green]____  __    ________  ___ [/bold green]
+[bold magenta]  / __ \\/ | / /[/bold magenta]  [bold yellow]/ ____/[/bold yellow]   [bold green]/ __ \\/ /   / ____/  |/  /[/bold green]
+[bold magenta] / / / /  |/ /[/bold magenta]  [bold yellow]/ / __[/bold yellow]    [bold green]/ / / / /   / __/ / /|_/ / [/bold green]
+[bold magenta]/ /_/ / /|  /[/bold magenta]  [bold yellow]/ /_/ /[/bold yellow]   [bold green]/ /_/ / /___/ /___/ /  / /  [/bold green]
+[bold magenta]\\____/_/ |_/[/bold magenta]   [bold yellow]\\____/[/bold yellow]   [bold green]/_____/_____/_____/_/  /_/   [/bold green]
+"""
+
+# Spinner frames (reduced for faster animation)
+SPINNER_FRAMES = ["⠋", "⠙", "⠸", "⠴"]
+
+def display_logo():
+    """Display the VM on Golem logo."""
+    console.print(LOGO)
+    console.print()
+
+async def startup_animation():
+    """Display startup animation."""
+    display_logo()
+    
+    with Live(refresh_per_second=8) as live:
+        # Startup message
+        live.console.print("\n[bold yellow]🚀 Initializing VM on Golem Provider...[/bold yellow]")
+        await asyncio.sleep(0.1)
+        
+        # Components check animation (reduced)
+        components = [
+            "Loading configuration",
+            "Starting provider services",
+            "Connecting to network"
+        ]
+        
+        for component in components:
+            for frame in SPINNER_FRAMES:
+                live.update(f"[bold blue]{frame}[/bold blue] {component}...")
+                await asyncio.sleep(0.1)
+            live.console.print(f"[bold green]✓[/bold green] {component} [dim]complete[/dim]")
+        
+        # Final ready message
+        live.console.print("\n[bold green]✨ VM on Golem Provider is ready![/bold green]")
+        live.console.print("[bold cyan]🌐 Listening for incoming requests on port 7466[/bold cyan]")
+        live.console.print("[dim]Press Ctrl+C to stop the server[/dim]")
+
+async def vm_creation_animation(vm_name: str):
+    """Display VM creation success message.
+    
+    Args:
+        vm_name: Name of the VM being created
+    """
+    console.print(f"[bold green]✨ VM '{vm_name}' is now being rented. Access information has been forwarded to the requestor.[/bold green]")
+
+def vm_status_change(vm_id: str, status: str, details: str = ""):
+    """Display VM status change.
+    
+    Args:
+        vm_id: VM identifier
+        status: New status
+        details: Additional details (optional)
+    """
+    # Only show final status
+    if status.lower() == "running":
+        console.print(f"[green]✓[/green] VM {vm_id} is {status.lower()}")

provider/utils/logging.py

@@ -0,0 +1,82 @@
+import logging
+import colorlog
+import sys
+from typing import Optional
+
+# Import standard logging levels
+from logging import DEBUG, INFO, WARNING, ERROR, CRITICAL
+
+# Custom log levels
+PROCESS = 25  # Between INFO and WARNING
+SUCCESS = 35  # Between WARNING and ERROR
+
+# Add custom levels to logging
+logging.addLevelName(PROCESS, 'PROCESS')
+logging.addLevelName(SUCCESS, 'SUCCESS')
+
+def process(self, message, *args, **kwargs):
+    """Log 'msg % args' with severity 'PROCESS'."""
+    if self.isEnabledFor(PROCESS):
+        self._log(PROCESS, message, args, **kwargs)
+
+def success(self, message, *args, **kwargs):
+    """Log 'msg % args' with severity 'SUCCESS'."""
+    if self.isEnabledFor(SUCCESS):
+        self._log(SUCCESS, message, args, **kwargs)
+
+# Add methods to Logger class
+logging.Logger.process = process
+logging.Logger.success = success
+
+def setup_logger(name: Optional[str] = None, debug: bool = False) -> logging.Logger:
+    """Setup and return a colored logger.
+    
+    Args:
+        name: Logger name (optional)
+        debug: Whether to show debug logs (optional)
+        
+    Returns:
+        Configured logger instance
+    """
+    logger = logging.getLogger(name or __name__)
+    logger.handlers = []  # Clear existing handlers
+    
+    # Fancy handler for important logs
+    fancy_handler = colorlog.StreamHandler(sys.stdout)
+    fancy_formatter = colorlog.ColoredFormatter(
+        "%(log_color)s[%(asctime)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        reset=True,
+        log_colors={
+            'INFO': 'green',
+            'PROCESS': 'yellow',
+            'WARNING': 'yellow',
+            'SUCCESS': 'green,bold',
+            'ERROR': 'red',
+            'CRITICAL': 'red,bold',
+        },
+        secondary_log_colors={},
+        style='%'
+    )
+    fancy_handler.setFormatter(fancy_formatter)
+    fancy_handler.addFilter(lambda record: record.levelno in [INFO, PROCESS, SUCCESS, WARNING, ERROR, CRITICAL])
+    logger.addHandler(fancy_handler)
+    
+    if debug:
+        # Debug handler for detailed logs
+        debug_handler = logging.StreamHandler(sys.stdout)
+        debug_formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            datefmt="%Y-%m-%d %H:%M:%S"
+        )
+        debug_handler.setFormatter(debug_formatter)
+        debug_handler.addFilter(lambda record: record.levelno == DEBUG)
+        logger.addHandler(debug_handler)
+        logger.setLevel(logging.DEBUG)
+    else:
+        logger.setLevel(logging.INFO)
+    
+    return logger
+
+# Create default logger
+logger = setup_logger()