request-vm-on-golem 0.1.50__py3-none-any.whl → 0.1.51__py3-none-any.whl

{request_vm_on_golem-0.1.50.dist-info → request_vm_on_golem-0.1.51.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: request-vm-on-golem
-Version: 0.1.50
+Version: 0.1.51
 Summary: VM on Golem Requestor CLI - Create and manage virtual machines on the Golem Network
 Keywords: golem,vm,cloud,decentralized,cli
 Author: Phillip Jensen
@@ -171,6 +171,16 @@ poetry run golem vm stream status my-vm
 poetry run golem vm stream inspect --stream-id 123
 ```
 
+- Stopping or destroying a VM ends the stream:
+
+```bash
+# Stop VM and terminate payment stream (best-effort)
+poetry run golem vm stop my-vm
+
+# Destroy VM and terminate stream
+poetry run golem vm destroy my-vm
+```
+
 - Create a VM and attach an existing stream (no auto-streams are created by the requestor):
 
 ```bash
@@ -195,6 +205,11 @@ Efficiency tips:
 - Withdrawals are typically executed by providers; requestors don’t need to withdraw.
 - The CLI `vm stream open` will prefer the provider’s advertised contract/token addresses to prevent mismatches.
 
+Monitoring and auto top-up:
+
+- The requestor API runs a background monitor that keeps each running VM’s stream funded with at least 1 hour runway (configurable). It checks every 30s and tops up to the target runway.
+- Configure via env (prefix `GOLEM_REQUESTOR_`): `stream_monitor_enabled` (default true), `stream_monitor_interval_seconds` (default 30), `stream_min_remaining_seconds` (default 3600), `stream_topup_target_seconds` (default 3600).
+
 ## Faucet (L2 ETH)
 
 - Request L2 test ETH to cover stream transactions:

{request_vm_on_golem-0.1.50.dist-info → request_vm_on_golem-0.1.51.dist-info}/RECORD

@@ -1,13 +1,14 @@
 requestor/__init__.py,sha256=OqSUAh1uZBMx7GW0MoSMg967PVdmT8XdPJx3QYjwkak,116
-requestor/api/main.py,sha256=7utCzFNbh5Ol-vsBWeSwT4lXeHD7zdA-GFZuS3rHMWc,2180
+requestor/api/main.py,sha256=CTnaM7KyBtDwVlyclYbNDy-nGi5_xt9GTcGusRasDVY,2493
 requestor/cli/__init__.py,sha256=e3E4oEGxmGj-STPtFkQwg_qIWhR0JAiAQdw3G1hXciU,37
-requestor/cli/commands.py,sha256=JfDvDYNvji1uIUF-0fHEHZxLzHWl-NslBdG1Yw2sFuY,45748
-requestor/config.py,sha256=2ayNJzvIIoU0jMAVqbs-yfG4H63W_uALLScBG4EjUOw,8241
+requestor/cli/commands.py,sha256=N1Jj1Yy5AX-eOHLROlkBsm-CTXzn9--eOrB1dZZpCiA,47357
+requestor/config.py,sha256=g6fhGxWmKxJMqkoaB1RDhMRPn45hqmuqIRmItBoInlg,8835
 requestor/data/deployments/l2.json,sha256=XTNN2C5LkBfp4YbDKdUKfWMdp1fKnfv8D3TgcwVWxtQ,249
 requestor/db/__init__.py,sha256=Gm5DfWls6uvCZZ3HGGnyRHswbUQdeA5OGN8yPwH0hc8,88
 requestor/db/sqlite.py,sha256=l5pWbx2qlHuar1N_a0B9tVnmumLJY1w5rp3yZ7jmsC0,4146
 requestor/errors.py,sha256=wVpHBuYgQx5pTe_SamugfK-k768noikY1RxvPOjQGko,665
 requestor/payments/blockchain_service.py,sha256=CACvZH2ZstutX7f0L_PXl8K_V5WlIkxNYIaeJuhP5I0,7500
+requestor/payments/monitor.py,sha256=JtSnh2plFf-f8sJU-bkOpadhoK_R82_ULwkDRmBYSbc,6012
 requestor/provider/__init__.py,sha256=fmW23aYUVciF8-gmBZkG-PLhn22upmcDzdPfAOLHG6g,103
 requestor/provider/client.py,sha256=pfJymufYR13W4kfykHZSVvs6ikRUE5AdHp0W0DB17AE,4130
 requestor/run.py,sha256=GqOG6n34szt8Sp3SEqjRV6huWm737yCN6YnBqoiwI-U,1785
@@ -16,12 +17,12 @@ requestor/services/__init__.py,sha256=1qSn_6RMn0KB0A7LCnY2IW6_tC3HBQsdfkFeV-h94e
 requestor/services/database_service.py,sha256=GlSrzzzd7PSYQJNup00sxkB-B2PMr1__04K8k5QSWvs,2996
 requestor/services/provider_service.py,sha256=eb4t6tkcw9VzJev2sfawT1KvVc5TxQnb1pgYgoQZcM4,15000
 requestor/services/ssh_service.py,sha256=tcOCtk2SlB9Uuv-P2ghR22e7BJ9kigQh5b4zSGdPFns,4280
-requestor/services/vm_service.py,sha256=eQ2pPMpYlfPVbVFrkFElsRO5swPq-2XZEfuvxagyHDk,7941
+requestor/services/vm_service.py,sha256=1EUypRbCykdQTVJf4gYiNzkZNk66T3df32Vc51HkSMI,7983
 requestor/ssh/__init__.py,sha256=hNgSqJ5s1_AwwxVRyFjUqh_LTBpI4Hmzq0F-f_wXN9g,119
 requestor/ssh/manager.py,sha256=3jQtbbK7CVC2yD1zCO88jGXh2fBcuv3CzWEqDLuaQVk,9758
 requestor/utils/logging.py,sha256=oFNpO8pJboYM8Wp7g3HOU4HFyBTKypVdY15lUiz1a4I,3721
 requestor/utils/spinner.py,sha256=PUHJdTD9jpUHur__01_qxXy87WFfNmjQbD_sLG-KlGo,2459
-request_vm_on_golem-0.1.50.dist-info/METADATA,sha256=EWV0bEfyWQeyBldHWHx3nUgOmZmD_5b5K6Btyp6VQt4,14363
-request_vm_on_golem-0.1.50.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-request_vm_on_golem-0.1.50.dist-info/entry_points.txt,sha256=Z-skRNpJ8aZcIl_En9mEm1ygkp9FKy0bzQoL3zO52-0,44
-request_vm_on_golem-0.1.50.dist-info/RECORD,,
+request_vm_on_golem-0.1.51.dist-info/METADATA,sha256=0SYRZbBOrAmZyg_6wtjwvGAW0nc6EWcXShblUUvyRsA,15027
+request_vm_on_golem-0.1.51.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+request_vm_on_golem-0.1.51.dist-info/entry_points.txt,sha256=Z-skRNpJ8aZcIl_En9mEm1ygkp9FKy0bzQoL3zO52-0,44
+request_vm_on_golem-0.1.51.dist-info/RECORD,,

requestor/api/main.py

@@ -5,11 +5,13 @@ from contextlib import asynccontextmanager
 from ..services.database_service import DatabaseService
 from ..config import config
 from ..errors import DatabaseError
+from ..payments.monitor import RequestorStreamMonitor
 
 logger = logging.getLogger(__name__)
 
 # Global variable to hold the database service instance
 db_service: DatabaseService = None
+stream_monitor: RequestorStreamMonitor | None = None
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -26,9 +28,15 @@ async def lifespan(app: FastAPI):
         logger.error(f"Failed to initialize database during startup: {e}")
         # Depending on requirements, you might want to prevent the app from starting
         # raise RuntimeError(f"Database initialization failed: {e}") from e
+    # Start requestor stream monitor
+    global stream_monitor
+    stream_monitor = RequestorStreamMonitor(db_service)
+    stream_monitor.start()
     yield
     # Shutdown: Cleanup (if needed)
     logger.info("Shutting down API.")
+    if stream_monitor:
+        await stream_monitor.stop()
     # No explicit cleanup needed for aiosqlite connection usually
 
 app = FastAPI(lifespan=lifespan)
@@ -56,4 +64,4 @@ async def list_vms():
 # Example of another endpoint (can be removed if not needed)
 @app.get("/")
 async def read_root():
-    return {"message": "Golem Requestor API"}
+    return {"message": "Golem Requestor API"}

requestor/cli/commands.py

@@ -743,7 +743,16 @@ async def destroy_vm(name: str):
         # Initialize VM service
         provider_url = config.get_provider_url(vm['provider_ip'])
         async with ProviderClient(provider_url) as client:
-            vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client)
+            # Initialize blockchain client for stream termination on destroy
+            from ..payments.blockchain_service import StreamPaymentClient, StreamPaymentConfig
+            spc = StreamPaymentConfig(
+                rpc_url=config.polygon_rpc_url,
+                contract_address=config.stream_payment_address,
+                glm_token_address=config.glm_token_address,
+                private_key=config.ethereum_private_key,
+            )
+            sp_client = StreamPaymentClient(spc)
+            vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client, sp_client)
             await vm_service.destroy_vm(name)
         
         # Show fancy success message
@@ -798,7 +807,16 @@ async def purge_vms(force: bool):
                 provider_url = config.get_provider_url(vm['provider_ip'])
                 
                 async with ProviderClient(provider_url) as client:
-                    vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client)
+                    # Initialize blockchain client for stream termination on purge
+                    from ..payments.blockchain_service import StreamPaymentClient, StreamPaymentConfig
+                    spc = StreamPaymentConfig(
+                        rpc_url=config.polygon_rpc_url,
+                        contract_address=config.stream_payment_address,
+                        glm_token_address=config.glm_token_address,
+                        private_key=config.ethereum_private_key,
+                    )
+                    sp_client = StreamPaymentClient(spc)
+                    vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client, sp_client)
                     await vm_service.destroy_vm(vm['name'])
                     results['success'].append((vm['name'], 'Destroyed successfully'))
 
@@ -921,7 +939,16 @@ async def stop_vm(name: str):
         # Initialize VM service
         provider_url = config.get_provider_url(vm['provider_ip'])
         async with ProviderClient(provider_url) as client:
-            vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client)
+            # Initialize blockchain client for stream termination on stop
+            from ..payments.blockchain_service import StreamPaymentClient, StreamPaymentConfig
+            spc = StreamPaymentConfig(
+                rpc_url=config.polygon_rpc_url,
+                contract_address=config.stream_payment_address,
+                glm_token_address=config.glm_token_address,
+                private_key=config.ethereum_private_key,
+            )
+            sp_client = StreamPaymentClient(spc)
+            vm_service = VMService(db_service, SSHService(config.ssh_key_dir), client, sp_client)
             await vm_service.stop_vm(name)
 
         # Show fancy success message

requestor/config.py

@@ -113,6 +113,23 @@ class RequestorConfig(BaseSettings):
         default="",
         description="Token address (0x0 means native ETH). Defaults from l2.json"
     )
+    # Stream monitor (auto top-up)
+    stream_monitor_enabled: bool = Field(
+        default=True,
+        description="Enable background monitor to auto top-up streams"
+    )
+    stream_monitor_interval_seconds: int = Field(
+        default=30,
+        description="How frequently to check and top up streams"
+    )
+    stream_min_remaining_seconds: int = Field(
+        default=3600,
+        description="Minimum remaining runway to maintain (seconds)"
+    )
+    stream_topup_target_seconds: int = Field(
+        default=3600,
+        description="Target runway after top-up (seconds)"
+    )
     # Faucet settings (L2 payments)
     l2_faucet_url: str = Field(
         default="https://l2.holesky.golemdb.io/faucet",

requestor/payments/monitor.py

@@ -0,0 +1,126 @@
+import asyncio
+from typing import Optional
+
+from ..services.database_service import DatabaseService
+from ..provider.client import ProviderClient
+from ..config import config
+from ..utils.logging import setup_logger
+from .blockchain_service import StreamPaymentClient, StreamPaymentConfig
+
+
+class RequestorStreamMonitor:
+    def __init__(self, db: DatabaseService):
+        self.db = db
+        self._task: Optional[asyncio.Task] = None
+        self._logger = setup_logger(__name__)
+        self._sp = StreamPaymentClient(
+            StreamPaymentConfig(
+                rpc_url=config.polygon_rpc_url,
+                contract_address=config.stream_payment_address,
+                glm_token_address=config.glm_token_address,
+                private_key=config.ethereum_private_key,
+            )
+        )
+
+    def start(self):
+        if not config.stream_monitor_enabled:
+            return
+        self._logger.info(
+            f"⏱️ Requestor stream auto-topup enabled interval={config.stream_monitor_interval_seconds}s "
+            f"min_remaining={config.stream_min_remaining_seconds}s target={config.stream_topup_target_seconds}s"
+        )
+        self._task = asyncio.create_task(self._run(), name="requestor-stream-monitor")
+
+    async def stop(self):
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            self._logger.info("Requestor stream auto-topup stopped")
+
+    async def _resolve_stream_id(self, vm: dict) -> Optional[int]:
+        # Prefer local DB recorded stream_id
+        sid = vm.get("config", {}).get("stream_id")
+        if isinstance(sid, int):
+            return sid
+        # Ask provider for mapping
+        try:
+            provider_url = config.get_provider_url(vm["provider_ip"])
+            async with ProviderClient(provider_url) as client:
+                status = await client.get_vm_stream_status(vm["vm_id"])
+                sid = status.get("stream_id")
+                self._logger.debug(f"Resolved stream for VM {vm['name']}: {sid}")
+                return int(sid) if sid is not None else None
+        except Exception as e:
+            self._logger.debug(f"Could not resolve stream for VM {vm['name']}: {e}")
+            return None
+
+    async def _run(self):
+        interval = max(int(config.stream_monitor_interval_seconds), 5)
+        min_remaining = max(int(config.stream_min_remaining_seconds), 0)
+        target_seconds = max(int(config.stream_topup_target_seconds), min_remaining)
+        while True:
+            try:
+                vms = await self.db.list_vms()
+                self._logger.debug(f"stream monitor tick: {len(vms)} VMs to check")
+                for vm in vms:
+                    # Only manage running VMs
+                    if vm.get("status") != "running":
+                        self._logger.debug(f"skip VM {vm.get('name')} status={vm.get('status')}")
+                        continue
+                    stream_id = await self._resolve_stream_id(vm)
+                    if stream_id is None:
+                        self._logger.debug(f"skip VM {vm.get('name')} no stream mapped")
+                        continue
+                    # Read on-chain stream tuple via contract
+                    try:
+                        token, sender, recipient, startTime, stopTime, ratePerSecond, deposit, withdrawn, halted = (
+                            self._sp.contract.functions.streams(int(stream_id)).call()
+                        )
+                    except Exception as e:
+                        self._logger.warning(f"stream lookup failed for {stream_id}: {e}")
+                        continue
+                    if bool(halted):
+                        # Respect terminated streams
+                        self._logger.debug(f"skip stream {stream_id} halted=true")
+                        continue
+                    # Compute remaining seconds using chain time
+                    try:
+                        now = int(self._sp.web3.eth.get_block("latest")["timestamp"])
+                    except Exception as e:
+                        self._logger.warning(f"could not get chain time: {e}")
+                        continue
+                    remaining = max(int(stopTime) - now, 0)
+                    self._logger.debug(
+                        f"VM {vm.get('name')} stream {stream_id}: remaining={remaining}s rate={int(ratePerSecond)}"
+                    )
+                    if remaining < min_remaining:
+                        # Top up to reach target_seconds of runway
+                        deficit = max(target_seconds - remaining, 0)
+                        add_wei = int(deficit) * int(ratePerSecond)
+                        if add_wei <= 0:
+                            continue
+                        try:
+                            self._logger.info(
+                                f"⛽ topping up stream {stream_id} by {add_wei} wei to reach {target_seconds}s"
+                            )
+                            self._sp.top_up(int(stream_id), int(add_wei))
+                            self._logger.success(
+                                f"topped up stream {stream_id} (+{add_wei} wei); VM={vm.get('name')}"
+                            )
+                        except Exception as e:
+                            # Ignore failures; will retry next tick
+                            self._logger.warning(f"top-up failed for stream {stream_id}: {e}")
+                    else:
+                        self._logger.debug(
+                            f"stream {stream_id} healthy (remaining={remaining}s >= {min_remaining}s)"
+                        )
+                await asyncio.sleep(interval)
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                # Keep the monitor resilient
+                self._logger.error(f"requestor stream monitor error: {e}")
+                await asyncio.sleep(interval)

requestor/services/vm_service.py

@@ -142,11 +142,11 @@ class VMService:
             # Update status in database
             await self.db.update_vm_status(name, "stopped")
 
-            # Best-effort withdraw on stop
+            # Best-effort terminate stream on stop (treat stop as end of agreement)
             try:
                 stream_id = vm.get('config', {}).get('stream_id')
                 if stream_id is not None and self.blockchain_client:
-                    self.blockchain_client.withdraw(stream_id)
+                    self.blockchain_client.terminate(stream_id)
             except Exception:
                 pass