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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: golem-vm-provider
-Version: 0.1.1
+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.1 → golem_vm_provider-0.1.2}/provider/main.py

@@ -18,10 +18,8 @@ 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
+        # Port manager is already initialized and verified in startup_event
+        port_manager = app.state.port_manager
         
         # Create resource tracker
         logger.process("🔄 Initializing resource tracker...")
@@ -108,10 +106,48 @@ async def cleanup_provider() -> None:
 @app.on_event("startup")
 async def startup_event():
     """Handle application startup."""
-    # Display startup animation
-    await startup_animation()
-    # Initialize provider
-    await setup_provider()
+    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():
@@ -163,40 +199,37 @@ def check_requirements():
         
     return True
 
-async def verify_ports():
-    """Verify port accessibility before starting server."""
-    from .vm.port_manager import PortManager
-    from .utils.port_display import PortVerificationDisplay
-    from .config import settings
+async def verify_provider_port(port: int) -> bool:
+    """Verify that the provider port is available for binding.
     
-    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")
+    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
-    
-    logger.success(f"✅ Port verification successful - {len(port_manager.verified_ports)} ports available")
-    return True
 
 def start():
     """Start the provider server."""
     import sys
-    import asyncio
     from pathlib import Path
     from dotenv import load_dotenv
     import uvicorn
@@ -221,10 +254,10 @@ def start():
         if not check_requirements():
             logger.error("Requirements check failed")
             sys.exit(1)
-
-        # Verify ports before starting server
-        if not asyncio.run(verify_ports()):
-            logger.error("Port verification failed")
+            
+        # 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

{golem_vm_provider-0.1.1 → 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.1 → 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.1 → 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.1 → 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.1 → golem_vm_provider-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "golem-vm-provider"
-version = "0.1.1"
+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"