golem-vm-provider 0.1.54__tar.gz → 0.1.55__tar.gz

{golem_vm_provider-0.1.54 → golem_vm_provider-0.1.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.54
+Version: 0.1.55
 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
@@ -510,6 +510,7 @@ sequenceDiagram
     participant DS as Discovery Service
 
     P->>RT: Initialize
+    P->>RT: Sync with existing VMs
     RT->>AD: Register Callback
     loop Every 4 minutes
         AD->>RT: Get Resources
@@ -519,6 +520,8 @@ sequenceDiagram
     end
 ```
 
+On startup, the provider syncs the resource tracker with all VMs currently running on the host (via Multipass). This ensures advertisements reflect already-allocated CPU, RAM, and storage after restarts, preventing false “outdated advertisement” updates when existing VMs are consuming resources. The sync is based on actual VMs present, independent of any still-open payment streams.
+
 ### Monitoring
 
 The provider includes comprehensive logging:

{golem_vm_provider-0.1.54 → golem_vm_provider-0.1.55}/README.md

@@ -465,6 +465,7 @@ sequenceDiagram
     participant DS as Discovery Service
 
     P->>RT: Initialize
+    P->>RT: Sync with existing VMs
     RT->>AD: Register Callback
     loop Every 4 minutes
         AD->>RT: Get Resources
@@ -474,6 +475,8 @@ sequenceDiagram
     end
 ```
 
+On startup, the provider syncs the resource tracker with all VMs currently running on the host (via Multipass). This ensures advertisements reflect already-allocated CPU, RAM, and storage after restarts, preventing false “outdated advertisement” updates when existing VMs are consuming resources. The sync is based on actual VMs present, independent of any still-open payment streams.
+
 ### Monitoring
 
 The provider includes comprehensive logging:

{golem_vm_provider-0.1.54 → golem_vm_provider-0.1.55}/provider/payments/monitor.py

@@ -56,21 +56,41 @@ class StreamMonitor:
                         logger.warning(f"stream {stream_id} lookup failed: {e}")
                         continue
                     # Stop VM if remaining runway < threshold
-                    remaining = max(s["stopTime"] - now, 0)
+                    remaining = max(int(s["stopTime"]) - int(now), 0)
                     logger.debug(
                         f"stream {stream_id} for VM {vm_id}: start={s['startTime']} stop={s['stopTime']} "
                         f"rate={s['ratePerSecond']} withdrawn={s['withdrawn']} halted={s['halted']} remaining={remaining}s"
                     )
-                    if self._get("STREAM_MONITOR_ENABLED", False) and remaining < int(self._get("STREAM_MIN_REMAINING_SECONDS", 0)):
-                        logger.info(f"Stopping VM {vm_id} due to low stream runway ({remaining}s)")
+                    # If stream is force-halted, delete immediately to free all resources
+                    if bool(s.get("halted")):
+                        logger.info(
+                            f"Deleting VM {vm_id} due to halted stream (id={stream_id}, now={now})"
+                        )
+                        try:
+                            await self.vm_service.delete_vm(vm_id)
+                        except Exception as e:
+                            logger.warning(f"delete_vm failed for {vm_id}: {e}")
+                        try:
+                            await self.stream_map.remove(vm_id)
+                        except Exception as e:
+                            logger.debug(f"failed to remove vm {vm_id} from stream map: {e}")
+                        continue
+
+                    # Only stop a VM when runway is completely empty
+                    if remaining == 0:
+                        logger.info(
+                            f"Stopping VM {vm_id} as stream runway is exhausted (id={stream_id}, now={now}, stop={s.get('stopTime')})"
+                        )
                         try:
                             await self.vm_service.stop_vm(vm_id)
                         except Exception as e:
                             logger.warning(f"stop_vm failed for {vm_id}: {e}")
-                    else:
-                        logger.debug(
-                            f"VM {vm_id} stream {stream_id} healthy (remaining={remaining}s, threshold={self._get('STREAM_MIN_REMAINING_SECONDS', 0)}s)"
-                        )
+                        continue
+
+                    # Otherwise, do not stop; just log health and consider withdrawals
+                    logger.debug(
+                        f"VM {vm_id} stream {stream_id} healthy (remaining={remaining}s)"
+                    )
                     # Withdraw if enough vested and configured
                     if self._get("STREAM_WITHDRAW_ENABLED", False) and self.client:
                         vested = max(min(now, s["stopTime"]) - s["startTime"], 0) * s["ratePerSecond"]

golem_vm_provider-0.1.55/provider/service.py

@@ -0,0 +1,148 @@
+import asyncio
+from fastapi import FastAPI
+
+from .utils.logging import setup_logger
+from .vm.service import VMService
+from .discovery.service import AdvertisementService
+from .utils.pricing import PricingAutoUpdater
+
+logger = setup_logger(__name__)
+
+
+class ProviderService:
+    """Service for managing the provider's lifecycle."""
+
+    def __init__(self, vm_service: VMService, advertisement_service: AdvertisementService, port_manager):
+        self.vm_service = vm_service
+        self.advertisement_service = advertisement_service
+        self.port_manager = port_manager
+        self._pricing_updater: PricingAutoUpdater | None = None
+        self._stream_monitor = None
+
+    async def setup(self, app: FastAPI):
+        """Setup and initialize the provider components."""
+        from .config import settings
+        from .utils.ascii_art import startup_animation
+        from .security.faucet import FaucetClient
+
+        try:
+            # Display startup animation
+            await startup_animation()
+
+            logger.process("🔄 Initializing provider...")
+
+            # Setup directories
+            self._setup_directories()
+
+            # Initialize services
+            await self.port_manager.initialize()
+            await self.vm_service.provider.initialize()
+
+            # Before starting advertisement, sync allocated resources with existing VMs
+            try:
+                vm_resources = await self.vm_service.get_all_vms_resources()
+                await self.vm_service.resource_tracker.sync_with_multipass(vm_resources)
+            except Exception as e:
+                logger.warning(f"Failed to sync resources with existing VMs: {e}")
+
+            # Cross-check running VMs against payment streams. If a VM has no
+            # active stream, it is no longer rented: terminate it and free resources.
+            try:
+                # Only perform checks if payments are configured
+                if settings.STREAM_PAYMENT_ADDRESS and not settings.STREAM_PAYMENT_ADDRESS.lower().endswith("0000000000000000000000000000000000000000") and settings.POLYGON_RPC_URL:
+                    stream_map = app.container.stream_map()
+                    reader = app.container.stream_reader()
+
+                    # Use the most recent view of VMs from the previous sync
+                    vm_ids = list(vm_resources.keys()) if 'vm_resources' in locals() else []
+                    for vm_id in vm_ids:
+                        try:
+                            stream_id = await stream_map.get(vm_id)
+                        except Exception:
+                            stream_id = None
+
+                        if stream_id is None:
+                            reason = "no stream mapped"
+                            should_terminate = True
+                        else:
+                            try:
+                                ok, msg = reader.verify_stream(int(stream_id), settings.PROVIDER_ID)
+                                should_terminate = not ok
+                                reason = msg if not ok else "ok"
+                            except Exception as e:
+                                # If verification cannot be performed, be conservative and keep the VM
+                                logger.warning(f"Stream verification error for VM {vm_id} (stream {stream_id}): {e}")
+                                should_terminate = False
+                                reason = f"verification error: {e}"
+
+                        if should_terminate:
+                            logger.info(
+                                f"Deleting VM {vm_id}: inactive stream (stream_id={stream_id}, reason={reason})"
+                            )
+                            try:
+                                await self.vm_service.delete_vm(vm_id)
+                            except Exception as e:
+                                logger.warning(f"Failed to delete VM {vm_id}: {e}")
+                            try:
+                                await stream_map.remove(vm_id)
+                            except Exception:
+                                pass
+
+                    # Re-sync after any terminations to ensure ads reflect capacity
+                    try:
+                        vm_resources = await self.vm_service.get_all_vms_resources()
+                        await self.vm_service.resource_tracker.sync_with_multipass(vm_resources)
+                    except Exception as e:
+                        logger.warning(f"Post-termination resource sync failed: {e}")
+                else:
+                    logger.info("Payments not configured; skipping startup stream checks")
+            except Exception as e:
+                logger.warning(f"Failed to reconcile VMs with payment streams: {e}")
+
+            await self.advertisement_service.start()
+            # Start pricing auto-updater; trigger re-advertise after updates
+            async def _on_price_updated(platform: str, glm_usd):
+                await self.advertisement_service.trigger_update()
+            self._pricing_updater = PricingAutoUpdater(on_updated_callback=_on_price_updated)
+            asyncio.create_task(self._pricing_updater.start())
+
+            # Start stream monitor if enabled
+            from .container import Container
+            from .config import settings as cfg
+            if cfg.STREAM_MONITOR_ENABLED or cfg.STREAM_WITHDRAW_ENABLED:
+                self._stream_monitor = app.container.stream_monitor()
+                self._stream_monitor.start()
+
+            # Check wallet balance and request funds if needed
+            faucet_client = FaucetClient(
+                faucet_url=settings.FAUCET_URL,
+                captcha_url=settings.CAPTCHA_URL,
+                captcha_api_key=settings.CAPTCHA_API_KEY,
+            )
+            await faucet_client.get_funds(settings.PROVIDER_ID)
+
+            logger.success("✨ Provider setup complete")
+        except Exception as e:
+            logger.error(f"Startup failed: {e}")
+            await self.cleanup()
+            raise
+
+    async def cleanup(self):
+        """Cleanup provider components."""
+        logger.process("🔄 Cleaning up provider...")
+        await self.advertisement_service.stop()
+        await self.vm_service.provider.cleanup()
+        if self._pricing_updater:
+            self._pricing_updater.stop()
+        if self._stream_monitor:
+            await self._stream_monitor.stop()
+        logger.success("✨ Provider cleanup complete")
+
+    def _setup_directories(self):
+        """Create necessary directories for the provider."""
+        from .config import settings
+        from pathlib import Path
+        
+        Path(settings.VM_DATA_DIR).mkdir(parents=True, exist_ok=True)
+        Path(settings.SSH_KEY_DIR).mkdir(parents=True, exist_ok=True)
+        Path(settings.CLOUD_INIT_DIR).mkdir(parents=True, exist_ok=True)

{golem_vm_provider-0.1.54 → golem_vm_provider-0.1.55}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "golem-vm-provider"
-version = "0.1.54"
+version = "0.1.55"
 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.54/provider/service.py

@@ -1,86 +0,0 @@
-import asyncio
-from fastapi import FastAPI
-
-from .utils.logging import setup_logger
-from .vm.service import VMService
-from .discovery.service import AdvertisementService
-from .utils.pricing import PricingAutoUpdater
-
-logger = setup_logger(__name__)
-
-
-class ProviderService:
-    """Service for managing the provider's lifecycle."""
-
-    def __init__(self, vm_service: VMService, advertisement_service: AdvertisementService, port_manager):
-        self.vm_service = vm_service
-        self.advertisement_service = advertisement_service
-        self.port_manager = port_manager
-        self._pricing_updater: PricingAutoUpdater | None = None
-        self._stream_monitor = None
-
-    async def setup(self, app: FastAPI):
-        """Setup and initialize the provider components."""
-        from .config import settings
-        from .utils.ascii_art import startup_animation
-        from .security.faucet import FaucetClient
-
-        try:
-            # Display startup animation
-            await startup_animation()
-
-            logger.process("🔄 Initializing provider...")
-
-            # Setup directories
-            self._setup_directories()
-
-            # Initialize services
-            await self.port_manager.initialize()
-            await self.vm_service.provider.initialize()
-            await self.advertisement_service.start()
-            # Start pricing auto-updater; trigger re-advertise after updates
-            async def _on_price_updated(platform: str, glm_usd):
-                await self.advertisement_service.trigger_update()
-            self._pricing_updater = PricingAutoUpdater(on_updated_callback=_on_price_updated)
-            asyncio.create_task(self._pricing_updater.start())
-
-            # Start stream monitor if enabled
-            from .container import Container
-            from .config import settings as cfg
-            if cfg.STREAM_MONITOR_ENABLED or cfg.STREAM_WITHDRAW_ENABLED:
-                self._stream_monitor = app.container.stream_monitor()
-                self._stream_monitor.start()
-
-            # Check wallet balance and request funds if needed
-            faucet_client = FaucetClient(
-                faucet_url=settings.FAUCET_URL,
-                captcha_url=settings.CAPTCHA_URL,
-                captcha_api_key=settings.CAPTCHA_API_KEY,
-            )
-            await faucet_client.get_funds(settings.PROVIDER_ID)
-
-            logger.success("✨ Provider setup complete")
-        except Exception as e:
-            logger.error(f"Startup failed: {e}")
-            await self.cleanup()
-            raise
-
-    async def cleanup(self):
-        """Cleanup provider components."""
-        logger.process("🔄 Cleaning up provider...")
-        await self.advertisement_service.stop()
-        await self.vm_service.provider.cleanup()
-        if self._pricing_updater:
-            self._pricing_updater.stop()
-        if self._stream_monitor:
-            await self._stream_monitor.stop()
-        logger.success("✨ Provider cleanup complete")
-
-    def _setup_directories(self):
-        """Create necessary directories for the provider."""
-        from .config import settings
-        from pathlib import Path
-        
-        Path(settings.VM_DATA_DIR).mkdir(parents=True, exist_ok=True)
-        Path(settings.SSH_KEY_DIR).mkdir(parents=True, exist_ok=True)
-        Path(settings.CLOUD_INIT_DIR).mkdir(parents=True, exist_ok=True)