golem-vm-provider 0.1.18__tar.gz → 0.1.20__tar.gz

{golem_vm_provider-0.1.18 → golem_vm_provider-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.18
+Version: 0.1.20
 Summary: VM on Golem Provider Node - Run your own provider node to offer VMs on the Golem Network
 Keywords: golem,vm,provider,cloud,decentralized
 Author: Phillip Jensen

{golem_vm_provider-0.1.18 → golem_vm_provider-0.1.20}/provider/main.py

@@ -31,11 +31,15 @@ async def setup_provider() -> None:
         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
+            # Store provider and proxy manager references
+            app.state.provider = provider
             app.state.proxy_manager = provider.proxy_manager
             
+            # Restore proxy configurations
+            logger.process("🔄 Restoring proxy configurations...")
+            await app.state.proxy_manager._load_state()
+            
         except asyncio.TimeoutError:
             logger.error("Provider initialization timed out")
             raise

{golem_vm_provider-0.1.18 → golem_vm_provider-0.1.20}/provider/vm/multipass.py

@@ -37,8 +37,11 @@ class MultipassProvider(VMProvider):
         self.vm_data_dir.mkdir(parents=True, exist_ok=True)
 
         # Initialize managers
-        self.proxy_manager = PythonProxyManager(port_manager=port_manager)
         self.name_mapper = VMNameMapper(self.vm_data_dir / "vm_names.json")
+        self.proxy_manager = PythonProxyManager(
+            port_manager=port_manager,
+            name_mapper=self.name_mapper
+        )
 
     def _verify_installation(self) -> None:
         """Verify multipass is installed and get version."""

{golem_vm_provider-0.1.18 → golem_vm_provider-0.1.20}/provider/vm/proxy_manager.py

@@ -147,42 +147,64 @@ class PythonProxyManager:
     def __init__(
         self,
         port_manager: PortManager,
+        name_mapper: "VMNameMapper",
         state_file: Optional[str] = None
     ):
         """Initialize the proxy manager.
         
         Args:
             port_manager: Port allocation manager
+            name_mapper: VM name mapping manager
             state_file: Path to persist proxy state
         """
         self.port_manager = port_manager
+        self.name_mapper = name_mapper
         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()
+        self._proxies: Dict[str, ProxyServer] = {}  # multipass_name -> ProxyServer
+        # Note: _load_state is now async and will be called explicitly during provider setup
     
-    def _load_state(self) -> None:
-        """Load proxy state from file."""
+    async def _load_state(self) -> None:
+        """Load and restore proxy state from file."""
         try:
             state_path = Path(self.state_file)
             if state_path.exists():
                 with open(state_path, 'r') as f:
                     state = json.load(f)
-                    # We only need to restore port allocations
-                    # Actual proxy servers will be recreated as needed
-                    logger.info(f"Loaded proxy state for {len(state)} VMs")
+                    # Restore proxy servers from saved state
+                    restore_tasks = []
+                    for requestor_name, proxy_info in state.items():
+                        # Get current multipass name for the requestor's VM
+                        multipass_name = await self.name_mapper.get_multipass_name(requestor_name)
+                        if multipass_name:
+                            # Create task to restore proxy
+                            task = self.add_vm(
+                                vm_id=multipass_name,  # Use multipass name for internal tracking
+                                vm_ip=proxy_info['target'],
+                                port=proxy_info['port']
+                            )
+                            restore_tasks.append(task)
+                        else:
+                            logger.warning(f"No multipass name found for requestor VM {requestor_name}")
+                    
+                    # Wait for all proxies to be restored
+                    if restore_tasks:
+                        results = await asyncio.gather(*restore_tasks, return_exceptions=True)
+                        successful = sum(1 for r in results if r is True)
+                        logger.info(f"Restored {successful}/{len(state)} proxy configurations")
         except Exception as e:
             logger.error(f"Failed to load proxy state: {e}")
     
-    def _save_state(self) -> None:
-        """Save current proxy state to file."""
+    async def _save_state(self) -> None:
+        """Save current proxy state to file using requestor names."""
         try:
-            state = {
-                vm_id: {
-                    'port': proxy.listen_port,
-                    'target': proxy.target_host
-                }
-                for vm_id, proxy in self._proxies.items()
-            }
+            state = {}
+            for multipass_name, proxy in self._proxies.items():
+                requestor_name = await self.name_mapper.get_requestor_name(multipass_name)
+                if requestor_name:
+                    state[requestor_name] = {
+                        'port': proxy.listen_port,
+                        'target': proxy.target_host
+                    }
             os.makedirs(os.path.dirname(self.state_file), exist_ok=True)
             with open(self.state_file, 'w') as f:
                 json.dump(state, f)
@@ -193,7 +215,7 @@ class PythonProxyManager:
         """Add proxy configuration for a new VM.
         
         Args:
-            vm_id: Unique identifier for the VM
+            vm_id: Unique identifier for the VM (multipass name)
             vm_ip: IP address of the VM
             port: Optional specific port to use, if not provided one will be allocated
             
@@ -213,7 +235,7 @@ class PythonProxyManager:
             await proxy.start()
             
             self._proxies[vm_id] = proxy
-            self._save_state()
+            await self._save_state()
             
             logger.info(f"Started proxy for VM {vm_id} on port {port}")
             return True
@@ -229,14 +251,14 @@ class PythonProxyManager:
         """Remove proxy configuration for a VM.
         
         Args:
-            vm_id: Unique identifier for the VM
+            vm_id: Unique identifier for the VM (multipass name)
         """
         try:
             if vm_id in self._proxies:
                 proxy = self._proxies.pop(vm_id)
                 await proxy.stop()
                 self.port_manager.deallocate_port(vm_id)
-                self._save_state()
+                await self._save_state()
                 logger.info(f"Removed proxy for VM {vm_id}")
         except Exception as e:
             logger.error(f"Failed to remove proxy for VM {vm_id}: {e}")
@@ -257,7 +279,7 @@ class PythonProxyManager:
                 cleanup_errors.append(f"Failed to remove proxy for VM {vm_id}: {e}")
         
         try:
-            self._save_state()
+            await self._save_state()
         except Exception as e:
             cleanup_errors.append(f"Failed to save state: {e}")
             

{golem_vm_provider-0.1.18 → golem_vm_provider-0.1.20}/pyproject.toml

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