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

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

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.1
+Version: 0.1.7
 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
 Author: Phillip Jensen
 Author-email: phillip+vm-on-golem@golemgrid.com
@@ -33,6 +32,7 @@ Requires-Dist: requests (>=2.31.0,<3.0.0)
 Requires-Dist: rich (>=13.7.0,<14.0.0)
 Requires-Dist: setuptools (>=69.0.3,<70.0.0)
 Requires-Dist: uvicorn (>=0.15.0,<0.16.0)
+Project-URL: Homepage, https://github.com/cryptobench/vm-on-golem
 Project-URL: Repository, https://github.com/cryptobench/vm-on-golem
 Description-Content-Type: text/markdown
 

{golem_vm_provider-0.1.1 → golem_vm_provider-0.1.7}/provider/api/routes.py

@@ -1,7 +1,7 @@
 import json
 from typing import List
 from pathlib import Path
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Request
 
 from ..config import settings
 from ..utils.logging import setup_logger, PROCESS, SUCCESS
@@ -9,19 +9,12 @@ from ..utils.ascii_art import vm_creation_animation, vm_status_change
 from ..vm.models import VMInfo, VMStatus, VMAccessInfo, VMConfig, VMResources
 from .models import CreateVMRequest
 from ..vm.multipass import MultipassProvider, MultipassError
-from ..discovery.resource_tracker import ResourceTracker
-from ..vm.port_manager import PortManager
 
 logger = setup_logger(__name__)
 router = APIRouter()
 
-# Initialize components
-resource_tracker = ResourceTracker()
-port_manager = PortManager()
-provider = MultipassProvider(resource_tracker, port_manager)
-
 @router.post("/vms", response_model=VMInfo)
-async def create_vm(request: CreateVMRequest) -> VMInfo:
+async def create_vm(request: CreateVMRequest, req: Request) -> VMInfo:
     """Create a new VM."""
     try:
         logger.info(f"📥 Received VM creation request for '{request.name}'")
@@ -47,7 +40,7 @@ async def create_vm(request: CreateVMRequest) -> VMInfo:
 
         # Check and allocate resources
         logger.process("🔄 Allocating resources")
-        if not await resource_tracker.allocate(resources):
+        if not await req.app.state.resource_tracker.allocate(resources):
             logger.error("❌ Insufficient resources available")
             raise HTTPException(400, "Insufficient resources available on provider")
         
@@ -62,7 +55,7 @@ async def create_vm(request: CreateVMRequest) -> VMInfo:
             
             # Create VM
             logger.process(f"🔄 Creating VM with config: {config}")
-            vm_info = await provider.create_vm(config)
+            vm_info = await req.app.state.provider.create_vm(config)
 
             # Show success message
             await vm_creation_animation(request.name)
@@ -70,7 +63,7 @@ async def create_vm(request: CreateVMRequest) -> VMInfo:
         except Exception as e:
             # If VM creation fails, deallocate resources
             logger.warning("⚠️ VM creation failed, deallocating resources")
-            await resource_tracker.deallocate(resources)
+            await req.app.state.resource_tracker.deallocate(resources)
             raise
         
     except MultipassError as e:
@@ -78,13 +71,13 @@ async def create_vm(request: CreateVMRequest) -> VMInfo:
         raise HTTPException(500, str(e))
 
 @router.get("/vms", response_model=List[VMInfo])
-async def list_vms() -> List[VMInfo]:
+async def list_vms(req: Request) -> List[VMInfo]:
     """List all VMs."""
     try:
         logger.info("📋 Listing all VMs")
         vms = []
-        for vm_id in resource_tracker.get_allocated_vms():
-            vm_info = await provider.get_vm_status(vm_id)
+        for vm_id in req.app.state.resource_tracker.get_allocated_vms():
+            vm_info = await req.app.state.provider.get_vm_status(vm_id)
             vms.append(vm_info)
         return vms
     except MultipassError as e:
@@ -92,11 +85,11 @@ async def list_vms() -> List[VMInfo]:
         raise HTTPException(500, str(e))
 
 @router.get("/vms/{requestor_name}", response_model=VMInfo)
-async def get_vm_status(requestor_name: str) -> VMInfo:
+async def get_vm_status(requestor_name: str, req: Request) -> VMInfo:
     """Get VM status."""
     try:
         logger.info(f"🔍 Getting status for VM '{requestor_name}'")
-        status = await provider.get_vm_status(requestor_name)
+        status = await req.app.state.provider.get_vm_status(requestor_name)
         vm_status_change(requestor_name, status.status.value)
         return status
     except MultipassError as e:
@@ -104,16 +97,16 @@ async def get_vm_status(requestor_name: str) -> VMInfo:
         raise HTTPException(500, str(e))
 
 @router.get("/vms/{requestor_name}/access", response_model=VMAccessInfo)
-async def get_vm_access(requestor_name: str) -> VMAccessInfo:
+async def get_vm_access(requestor_name: str, req: Request) -> VMAccessInfo:
     """Get VM access information."""
     try:
         # Get VM info
-        vm = await provider.get_vm_status(requestor_name)
+        vm = await req.app.state.provider.get_vm_status(requestor_name)
         if not vm:
             raise HTTPException(404, "VM not found")
         
         # Get multipass name from mapper
-        multipass_name = await provider.name_mapper.get_multipass_name(requestor_name)
+        multipass_name = await req.app.state.provider.name_mapper.get_multipass_name(requestor_name)
         if not multipass_name:
             raise HTTPException(404, "VM mapping not found")
         
@@ -130,7 +123,7 @@ async def get_vm_access(requestor_name: str) -> VMAccessInfo:
         raise HTTPException(500, str(e))
 
 @router.delete("/vms/{requestor_name}")
-async def delete_vm(requestor_name: str) -> None:
+async def delete_vm(requestor_name: str, req: Request) -> None:
     """Delete a VM.
     
     Args:
@@ -140,14 +133,14 @@ async def delete_vm(requestor_name: str) -> None:
         logger.process(f"🗑️  Deleting VM '{requestor_name}'")
         
         # Get multipass name from mapper
-        multipass_name = await provider.name_mapper.get_multipass_name(requestor_name)
+        multipass_name = await req.app.state.provider.name_mapper.get_multipass_name(requestor_name)
         if not multipass_name:
             logger.warning(f"No multipass name found for VM '{requestor_name}' (may have been already deleted)")
             return
             
         try:
             vm_status_change(requestor_name, "STOPPING", "Cleanup in progress")
-            await provider.delete_vm(requestor_name)
+            await req.app.state.provider.delete_vm(requestor_name)
             vm_status_change(requestor_name, "TERMINATED", "Cleanup complete")
             logger.success(f"✨ Successfully deleted VM '{requestor_name}'")
         except MultipassError as e:

{golem_vm_provider-0.1.1 → golem_vm_provider-0.1.7}/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.7}/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.7}/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.7}/provider/vm/multipass.py

@@ -37,7 +37,7 @@ class MultipassProvider(VMProvider):
         self.vm_data_dir.mkdir(parents=True, exist_ok=True)
 
         # Initialize managers
-        self.proxy_manager = PythonProxyManager()
+        self.proxy_manager = PythonProxyManager(port_manager=port_manager)
         self.name_mapper = VMNameMapper(self.vm_data_dir / "vm_names.json")
 
     def _verify_installation(self) -> None:

{golem_vm_provider-0.1.1 → golem_vm_provider-0.1.7}/provider/vm/port_manager.py

@@ -1,5 +1,6 @@
 import os
 import json
+import socket
 import logging
 import asyncio
 from pathlib import Path
@@ -7,7 +8,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 +41,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 +69,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
@@ -147,7 +173,23 @@ class PortManager:
             if vm_id in self._used_ports:
                 port = self._used_ports[vm_id]
                 if port in self.verified_ports:
-                    return port
+                    # Quick check if port is still available
+                    try:
+                        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:  # Port is available
+                            return port
+                        else:
+                            # Port is in use, remove from verified ports
+                            self.verified_ports.remove(port)
+                            self._used_ports.pop(vm_id)
+                    except Exception as e:
+                        logger.debug(f"Failed to check port {port}: {e}")
+                        # Keep the port if check fails, let proxy setup handle any issues
+                        return port
                 else:
                     # Previously allocated port is no longer verified
                     self._used_ports.pop(vm_id)
@@ -157,10 +199,24 @@ class PortManager:
             # Find first available verified port
             for port in sorted(self.verified_ports):
                 if port not in used_ports:
-                    self._used_ports[vm_id] = port
-                    self._save_state()
-                    logger.info(f"Allocated verified port {port} for VM {vm_id}")
-                    return port
+                    # Quick check if port is actually available
+                    try:
+                        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:  # Port is available
+                            self._used_ports[vm_id] = port
+                            self._save_state()
+                            logger.info(f"Allocated verified port {port} for VM {vm_id}")
+                            return port
+                        else:
+                            # Port is in use, remove from verified ports
+                            self.verified_ports.remove(port)
+                    except Exception as e:
+                        logger.debug(f"Failed to check port {port}: {e}")
+                        continue
             
             logger.error("No verified ports available for allocation")
             return None

{golem_vm_provider-0.1.1 → golem_vm_provider-0.1.7}/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,16 +131,22 @@ 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."""
     
     def __init__(
         self,
-        port_manager: Optional[PortManager] = None,
+        port_manager: PortManager,
         state_file: Optional[str] = None
     ):
         """Initialize the proxy manager.
@@ -138,7 +155,7 @@ class PythonProxyManager:
             port_manager: Port allocation manager
             state_file: Path to persist proxy state
         """
-        self.port_manager = port_manager or PortManager()
+        self.port_manager = port_manager
         self.state_file = state_file or os.path.expanduser("~/.golem/provider/proxy_state.json")
         self._proxies: Dict[str, ProxyServer] = {}  # vm_id -> ProxyServer
         self._load_state()
@@ -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.7}/pyproject.toml

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