request-vm-on-golem 0.1.49__tar.gz → 0.1.51__tar.gz

{request_vm_on_golem-0.1.49 → request_vm_on_golem-0.1.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: request-vm-on-golem
-Version: 0.1.49
+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.49 → request_vm_on_golem-0.1.51}/README.md

@@ -130,6 +130,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
@@ -154,6 +164,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.49 → request_vm_on_golem-0.1.51}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "request-vm-on-golem"
-version = "0.1.49"
+version = "0.1.51"
 description = "VM on Golem Requestor CLI - Create and manage virtual machines on the Golem Network"
 authors = ["Phillip Jensen <phillip+vm-on-golem@golemgrid.com>"]
 readme = "README.md"

{request_vm_on_golem-0.1.49 → request_vm_on_golem-0.1.51}/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"}

{request_vm_on_golem-0.1.49 → request_vm_on_golem-0.1.51}/requestor/cli/commands.py

@@ -340,6 +340,90 @@ def vm_stream():
     pass
 
 
+@vm_stream.command('list')
+@click.option('--json', 'as_json', is_flag=True, help='Output in JSON format')
+@async_command
+async def stream_list(as_json: bool):
+    """List payment stream status for all known VMs."""
+    try:
+        vms = await db_service.list_vms()
+        if not vms:
+            logger.warning("No VMs found in local database")
+            click.echo(json.dumps({"streams": []}, indent=2) if as_json else "No VMs found.")
+            return {"streams": []}
+
+        results = []
+        for vm in vms:
+            item: dict = {
+                "name": vm.get("name"),
+                "provider_ip": vm.get("provider_ip"),
+                "stream_id": None,
+                "verified": False,
+                "reason": None,
+                "computed": {},
+                "error": None,
+            }
+            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'])
+                item.update({
+                    "stream_id": status.get("stream_id"),
+                    "verified": bool(status.get("verified")),
+                    "reason": status.get("reason"),
+                    "computed": status.get("computed", {}),
+                })
+            except Exception as e:
+                msg = str(e)
+                # Normalize common provider errors
+                if "no stream mapped" in msg.lower():
+                    item.update({
+                        "stream_id": None,
+                        "verified": False,
+                        "reason": "unmapped",
+                    })
+                else:
+                    item["error"] = msg
+            results.append(item)
+
+        out = {"streams": results}
+
+        if as_json:
+            click.echo(json.dumps(out, indent=2))
+        else:
+            # Render a concise table
+            headers = [
+                "VM",
+                "Stream ID",
+                "Verified",
+                "Reason",
+                "Remaining (s)",
+                "Withdrawable (wei)",
+            ]
+            rows = []
+            for r in results:
+                comp = r.get("computed") or {}
+                rows.append([
+                    r.get("name"),
+                    r.get("stream_id") if r.get("stream_id") is not None else "—",
+                    "✔" if r.get("verified") else "✖",
+                    r.get("reason") or ("error: " + r.get("error") if r.get("error") else ""),
+                    comp.get("remaining_seconds", ""),
+                    comp.get("withdrawable_wei", ""),
+                ])
+            click.echo("\n" + "─" * 60)
+            click.echo(click.style(f"  💸 Streams ({len(results)} VMs)", fg="blue", bold=True))
+            click.echo("─" * 60)
+            click.echo("\n" + tabulate(rows, headers=[click.style(h, bold=True) for h in headers], tablefmt="grid"))
+            click.echo("\n" + "─" * 60)
+
+        return out
+
+    except Exception as e:
+        logger.error(f"Failed to list streams: {e}")
+        raise click.Abort()
+
+
 @vm_stream.command('open')
 @click.option('--provider-id', required=True, help='Provider ID to use')
 @click.option('--cpu', type=int, required=True, help='CPU cores for rate calc')
@@ -659,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
@@ -714,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'))
 
@@ -837,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

{request_vm_on_golem-0.1.49 → request_vm_on_golem-0.1.51}/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",

request_vm_on_golem-0.1.51/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)

{request_vm_on_golem-0.1.49 → request_vm_on_golem-0.1.51}/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