golem-vm-provider 0.1.0__tar.gz → 0.1.2__tar.gz

{golem_vm_provider-0.1.0 → golem_vm_provider-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: golem-vm-provider
-Version: 0.1.0
+Version: 0.1.2
 Summary: VM on Golem Provider Node - Run your own provider node to offer VMs on the Golem Network
 Home-page: https://github.com/cryptobench/vm-on-golem
 Keywords: golem,vm,provider,cloud,decentralized

golem_vm_provider-0.1.2/provider/main.py

@@ -0,0 +1,281 @@
+import asyncio
+import os
+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:
+        # Port manager is already initialized and verified in startup_event
+        port_manager = app.state.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."""
+    try:
+        # Display startup animation
+        await startup_animation()
+
+        # Verify ports first
+        from .vm.port_manager import PortManager
+        from .utils.port_display import PortVerificationDisplay
+        from .config import settings
+
+        display = PortVerificationDisplay(
+            provider_port=settings.PORT,
+            port_range_start=settings.PORT_RANGE_START,
+            port_range_end=settings.PORT_RANGE_END
+        )
+        display.print_header()
+
+        # Initialize port manager
+        logger.process("🔄 Verifying port accessibility...")
+        port_manager = PortManager(
+            start_port=settings.PORT_RANGE_START,
+            end_port=settings.PORT_RANGE_END,
+            discovery_port=settings.PORT
+        )
+        if not await port_manager.initialize():
+            logger.error("Port verification failed. Please ensure:")
+            logger.error(f"1. Port {settings.PORT} is accessible for provider access")
+            logger.error(f"2. Some ports in range {settings.PORT_RANGE_START}-{settings.PORT_RANGE_END} are accessible for VM access")
+            logger.error("3. Your firewall/router is properly configured")
+            raise RuntimeError("Port verification failed")
+
+        logger.success(f"✅ Port verification successful - {len(port_manager.verified_ports)} ports available")
+        
+        # Store port manager in app state for later use
+        app.state.port_manager = port_manager
+
+        # Initialize provider
+        await setup_provider()
+    except Exception as e:
+        logger.error(f"Startup failed: {e}")
+        # Ensure proper cleanup
+        await cleanup_provider()
+        raise
+
+@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", "start"]
+
+def check_requirements():
+    """Check if all requirements are met."""
+    import os
+    from pathlib import Path
+    
+    # Check if multipass is installed
+    multipass_path = os.environ.get('GOLEM_PROVIDER_MULTIPASS_BINARY_PATH', '/usr/local/bin/multipass')
+    if not Path(multipass_path).exists():
+        logger.error(f"Multipass binary not found at {multipass_path}")
+        return False
+        
+    # Check required directories
+    vm_data_dir = os.environ.get(
+        'GOLEM_PROVIDER_VM_DATA_DIR',
+        str(Path.home() / '.golem' / 'provider' / 'vms')
+    )
+    ssh_key_dir = os.environ.get(
+        'GOLEM_PROVIDER_SSH_KEY_DIR',
+        str(Path.home() / '.golem' / 'provider' / 'ssh')
+    )
+    proxy_state_dir = os.environ.get(
+        'GOLEM_PROVIDER_PROXY_STATE_DIR',
+        str(Path.home() / '.golem' / 'provider' / 'proxy')
+    )
+    
+    try:
+        # Create and secure directories
+        for directory in [vm_data_dir, ssh_key_dir, proxy_state_dir]:
+            path = Path(directory)
+            path.mkdir(parents=True, exist_ok=True)
+            if directory == ssh_key_dir:
+                path.chmod(0o700)  # Secure permissions for SSH keys
+    except Exception as e:
+        logger.error(f"Failed to create required directories: {e}")
+        return False
+        
+    return True
+
+async def verify_provider_port(port: int) -> bool:
+    """Verify that the provider port is available for binding.
+    
+    Args:
+        port: The port to verify
+        
+    Returns:
+        bool: True if the port is available, False otherwise
+    """
+    try:
+        # Try to create a temporary listener
+        server = await asyncio.start_server(
+            lambda r, w: None,  # Empty callback
+            '0.0.0.0',
+            port
+        )
+        server.close()
+        await server.wait_closed()
+        logger.info(f"✅ Provider port {port} is available")
+        return True
+    except Exception as e:
+        logger.error(f"❌ Provider port {port} is not available: {e}")
+        logger.error("Please ensure:")
+        logger.error(f"1. Port {port} is not in use by another application")
+        logger.error("2. You have permission to bind to this port")
+        logger.error("3. Your firewall allows binding to this port")
+        return False
+
+def start():
+    """Start the provider server."""
+    import sys
+    from pathlib import Path
+    from dotenv import load_dotenv
+    import uvicorn
+    from .utils.logging import setup_logger
+    from .config import settings
+    
+    # Configure logging with debug mode
+    logger = setup_logger(__name__, debug=True)
+    
+    try:
+        # Load environment variables from .env file
+        env_path = Path(__file__).parent.parent / '.env'
+        load_dotenv(dotenv_path=env_path)
+        
+        # Log environment variables
+        logger.info("Environment variables:")
+        for key, value in os.environ.items():
+            if key.startswith('GOLEM_PROVIDER_'):
+                logger.info(f"{key}={value}")
+
+        # Check requirements
+        if not check_requirements():
+            logger.error("Requirements check failed")
+            sys.exit(1)
+            
+        # Verify provider port is available
+        if not asyncio.run(verify_provider_port(settings.PORT)):
+            logger.error(f"Provider port {settings.PORT} is not available")
+            sys.exit(1)
+        
+        # Configure uvicorn logging
+        log_config = uvicorn.config.LOGGING_CONFIG
+        log_config["formatters"]["access"]["fmt"] = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        
+        # Run server
+        logger.process(f"🚀 Starting provider server on {settings.HOST}:{settings.PORT}")
+        uvicorn.run(
+            "provider:app",
+            host=settings.HOST,
+            port=settings.PORT,
+            reload=settings.DEBUG,
+            log_level="info" if not settings.DEBUG else "debug",
+            log_config=log_config,
+            timeout_keep_alive=60,  # Increase keep-alive timeout
+            limit_concurrency=100,  # Limit concurrent connections
+        )
+    except Exception as e:
+        logger.error(f"Failed to start provider server: {e}")
+        sys.exit(1)

{golem_vm_provider-0.1.0 → golem_vm_provider-0.1.2}/provider/network/port_verifier.py

@@ -165,37 +165,53 @@ class PortVerifier:
                             attempts.append(ServerAttempt(
                                 server=server,
                                 success=False,
-                                error="Server returned unsuccessful response"
+                                error=f"Server {server} returned unsuccessful response"
                             ))
                     else:
                         attempts.append(ServerAttempt(
                             server=server,
                             success=False,
-                            error=f"Server returned status {response.status}"
+                            error=f"Server {server} returned status {response.status}"
                         ))
             except asyncio.TimeoutError:
+                error_msg = f"Connection to {server} timed out after 30 seconds"
                 attempts.append(ServerAttempt(
                     server=server,
                     success=False,
-                    error="Connection timed out"
+                    error=error_msg
                 ))
-                logger.warning(f"Timeout while verifying ports with {server}")
+                logger.warning(f"{error_msg}. Please ensure the port check server is running and accessible.")
+            except aiohttp.ClientConnectorError as e:
+                error_msg = f"Could not connect to {server}: Connection refused"
+                attempts.append(ServerAttempt(
+                    server=server,
+                    success=False,
+                    error=error_msg
+                ))
+                logger.warning(f"{error_msg}. Please ensure the port check server is running.")
             except Exception as e:
+                error_msg = f"Failed to verify ports with {server}: {str(e)}"
                 attempts.append(ServerAttempt(
                     server=server,
                     success=False,
-                    error=str(e)
+                    error=error_msg
                 ))
-                logger.warning(f"Failed to verify ports with {server}: {e}")
+                logger.warning(error_msg)
         
         # 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")
+            error_msg = (
+                "Failed to verify ports with any server. Please ensure:\n"
+                "1. At least one port check server is running and accessible\n"
+                "2. Your network connection is stable\n"
+                "3. The server URLs are correct"
+            )
+            logger.error(error_msg)
             results = {
                 port: PortVerificationResult(
                     port=port,
                     accessible=False,
-                    error="Failed to verify with any port check server",
+                    error=error_msg,
                     attempts=[]  # Will be filled below
                 )
                 for port in ports
@@ -254,9 +270,11 @@ class PortVerifier:
         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
+        # Only verify the ports provided - discovery port is handled separately
+        logger.info(f"Verifying {len(ports)} SSH ports...")
+        if not ports:
+            logger.warning("No ports to verify")
+            return {}
         
         # First verify ports with local binding
         logger.info("Checking local port availability...")
@@ -267,7 +285,7 @@ class PortVerifier:
                     port: PortVerificationResult(
                         port=port,
                         accessible=False,
-                        error="Failed to bind locally"
+                        error=f"Port {port} could not be bound locally"
                     )
                     for port in ports
                 }
@@ -276,12 +294,11 @@ class PortVerifier:
             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}")
+            # Log verification results
+            accessible_ports = [port for port, result in results.items() if result.accessible]
+            if accessible_ports:
+                logger.info(f"Successfully verified {len(accessible_ports)} SSH ports: {', '.join(map(str, sorted(accessible_ports)))}")
+            else:
+                logger.warning("No SSH ports were verified as accessible")
             
             return results

{golem_vm_provider-0.1.0 → golem_vm_provider-0.1.2}/provider/utils/port_display.py

@@ -58,23 +58,29 @@ class PortVerificationDisplay:
         print("\n📡 Provider Accessibility (Required)")
         print("--------------------------------")
         
-        await self.animate_verification("Checking provider accessibility...")
+        await self.animate_verification("Verifying provider port status...")
         
-        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")
+        if result.verified_by == "local_verification":
+            print(f"[✅ Ready] Port {self.provider_port}")
+            print("└─ Status: Port available and bound")
+            print("└─ Access: Local binding successful")
+            print("└─ Provider can start and accept connections")
         else:
-            print("└─ Access: External ✗ | Internal ✗")
-            print("└─ Requestors cannot discover or connect to your provider")
+            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 verification server if successful
-        if result.verified_by:
-            print(f"└─ Verified By: {result.verified_by}")
+            # 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.
@@ -171,7 +177,7 @@ class PortVerificationDisplay:
             
             print("\nNeed help? Visit our troubleshooting guide: docs.golem.network/ports")
         
-    def print_summary(self, discovery_result: PortVerificationResult,
+    def print_summary(self, discovery_result: Optional[PortVerificationResult],
                      ssh_results: Dict[int, PortVerificationResult]):
         """Print a precise, actionable summary of the verification status.
         
@@ -181,17 +187,38 @@ class PortVerificationDisplay:
         """
         print("\n🎯 Current Status:", end=" ")
         
+        if discovery_result is None:
+            print("Verification Failed")
+            print(f"└─ Error: Discovery port {self.provider_port} verification failed")
+            print("└─ Impact: Provider cannot start without discovery port access")
+            print(f"└─ Fix: Ensure port {self.provider_port} is available and not in use")
+            return
+            
         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(f"└─ Error: {discovery_result.error or f'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}")
+            if discovery_result.attempts:
+                print("\n📋 Verification Attempts")
+                print("--------------------")
+                for attempt in discovery_result.attempts:
+                    status = "✅" if attempt.success else "❌"
+                    print(f"{status} {attempt.server}")
+                    if not attempt.success and attempt.error:
+                        print(f"   └─ Error: {attempt.error}")
+                print("\n🔍 Troubleshooting Tips")
+                print("-------------------")
+                print("1. Check if port check servers are running")
+                print("2. Verify your network connection")
+                print("3. Ensure no firewall is blocking the connections")
+                print("\nFor detailed setup instructions, visit: docs.golem.network/provider/ports")
             
         elif not accessible_ssh_ports:
             print("VMs Not Accessible")
-            print("└─ Reason: No VM access ports are available")
+            print("└─ Error: 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}")
             
@@ -202,3 +229,5 @@ class PortVerificationDisplay:
             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")
+            if discovery_result.verified_by:
+                print(f"└─ Verified By: {discovery_result.verified_by}")

{golem_vm_provider-0.1.0 → golem_vm_provider-0.1.2}/provider/vm/port_manager.py

@@ -7,7 +7,7 @@ from typing import Optional, Set, List, Dict
 from threading import Lock
 
 from ..config import settings
-from ..network.port_verifier import PortVerifier, PortVerificationResult
+from ..network.port_verifier import PortVerifier, PortVerificationResult, ServerAttempt
 from ..utils.port_display import PortVerificationDisplay
 
 logger = logging.getLogger(__name__)
@@ -40,10 +40,10 @@ class PortManager:
         
         # Initialize port verifier with default servers
         self.port_check_servers = port_check_servers or [
-            # "http://portcheck1.golem.network:7466",
-            # "http://portcheck2.golem.network:7466",
-            # "http://portcheck3.golem.network:7466",
-            "http://localhost:9000"  # Fallback for local development
+            "http://localhost:9000",  # Local development server
+            "http://portcheck1.golem.network:7466",  # Production servers
+            "http://portcheck2.golem.network:7466",
+            "http://portcheck3.golem.network:7466"
         ]
         self.discovery_port = discovery_port or settings.PORT
         self.port_verifier = PortVerifier(
@@ -68,18 +68,43 @@ class PortManager:
         )
         display.print_header()
         
-        # Verify all ports together (discovery port and SSH ports)
-        all_ports = [self.discovery_port] + list(range(self.start_port, self.end_port))
-        logger.info(f"Verifying all ports: discovery port {self.discovery_port} and SSH ports {self.start_port}-{self.end_port}...")
+        # Only verify SSH ports since provider port was already verified
+        ssh_ports = list(range(self.start_port, self.end_port))
+        logger.info(f"Starting port verification...")
+        logger.info(f"SSH ports range: {self.start_port}-{self.end_port}")
+        logger.info(f"Using port check servers: {', '.join(self.port_check_servers)}")
         
-        results = await self.port_verifier.verify_ports(all_ports)
+        results = await self.port_verifier.verify_ports(ssh_ports)
         
+        # Add provider port as verified since we already checked it
+        results[self.discovery_port] = PortVerificationResult(
+            port=self.discovery_port,
+            accessible=True,
+            verified_by="local_verification",
+            attempts=[ServerAttempt(server="local_verification", success=True)]
+        )
+        
+        # Check if discovery port was verified
+        if self.discovery_port not in results:
+            error_msg = f"Port {self.discovery_port} verification failed"
+            logger.error(error_msg)
+            display.print_summary(
+                PortVerificationResult(
+                    port=self.discovery_port,
+                    accessible=False,
+                    error=error_msg
+                ),
+                {}
+            )
+            return False
+
         # Display discovery port status with animation
         discovery_result = results[self.discovery_port]
         await display.print_discovery_status(discovery_result)
         
         if not discovery_result.accessible:
-            logger.error(f"Failed to verify discovery port: {discovery_result.error}")
+            error_msg = discovery_result.error or f"Port {self.discovery_port} is not accessible"
+            logger.error(f"Failed to verify discovery port: {error_msg}")
             # Print summary before returning
             display.print_summary(discovery_result, {})
             return False

{golem_vm_provider-0.1.0 → golem_vm_provider-0.1.2}/provider/vm/proxy_manager.py

@@ -58,8 +58,16 @@ class SSHProxyProtocol(Protocol):
         """Handle connection loss."""
         if exc:
             logger.error(f"Client connection lost with error: {exc}")
-        if self.target_transport and not self.target_transport.is_closing():
-            self.target_transport.close()
+        
+        # Ensure target connection is properly closed
+        if self.target_transport:
+            if not self.target_transport.is_closing():
+                self.target_transport.close()
+            self.target_transport = None
+        
+        # Clear any buffered data
+        if self.buffer:
+            self.buffer.clear()
 
 class SSHTargetProtocol(Protocol):
     """Protocol for handling target SSH connections."""
@@ -82,9 +90,12 @@ class SSHTargetProtocol(Protocol):
         """Handle connection loss."""
         if exc:
             logger.error(f"Target connection lost with error: {exc}")
-        if (self.client_protocol.transport and 
-            not self.client_protocol.transport.is_closing()):
-            self.client_protocol.transport.close()
+        
+        # Ensure client connection is properly closed
+        if self.client_protocol and self.client_protocol.transport:
+            if not self.client_protocol.transport.is_closing():
+                self.client_protocol.transport.close()
+            self.client_protocol.transport = None
 
 class ProxyServer:
     """Manages a single proxy server instance."""
@@ -120,9 +131,15 @@ class ProxyServer:
     async def stop(self) -> None:
         """Stop the proxy server."""
         if self.server:
-            self.server.close()
-            await self.server.wait_closed()
-            logger.info(f"Proxy server on port {self.listen_port} stopped")
+            try:
+                # Close the server
+                self.server.close()
+                await self.server.wait_closed()
+                logger.info(f"Proxy server on port {self.listen_port} stopped")
+            except Exception as e:
+                logger.error(f"Error stopping proxy server on port {self.listen_port}: {e}")
+            finally:
+                self.server = None
 
 class PythonProxyManager:
     """Manages proxy servers for VM SSH access."""
@@ -230,10 +247,25 @@ class PythonProxyManager:
     
     async def cleanup(self) -> None:
         """Remove all proxy configurations."""
-        try:
-            for vm_id in list(self._proxies.keys()):
+        cleanup_errors = []
+        
+        # Stop all proxy servers
+        for vm_id in list(self._proxies.keys()):
+            try:
                 await self.remove_vm(vm_id)
+            except Exception as e:
+                cleanup_errors.append(f"Failed to remove proxy for VM {vm_id}: {e}")
+        
+        try:
             self._save_state()
-            logger.info("Cleaned up all proxy configurations")
         except Exception as e:
-            logger.error(f"Failed to cleanup proxy configurations: {e}")
+            cleanup_errors.append(f"Failed to save state: {e}")
+            
+        if cleanup_errors:
+            error_msg = "\n".join(cleanup_errors)
+            logger.error(f"Errors during proxy cleanup:\n{error_msg}")
+        else:
+            logger.info("Cleaned up all proxy configurations")
+            
+        # Clear internal state
+        self._proxies.clear()

{golem_vm_provider-0.1.0 → golem_vm_provider-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "golem-vm-provider"
-version = "0.1.0"
+version = "0.1.2"
 description = "VM on Golem Provider Node - Run your own provider node to offer VMs on the Golem Network"
 authors = ["Phillip Jensen <phillip+vm-on-golem@golemgrid.com>"]
 readme = "README.md"

golem_vm_provider-0.1.0/provider/main.py

@@ -1,125 +0,0 @@
-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"]