golem-vm-provider 0.1.58__tar.gz → 0.1.59__tar.gz

{golem_vm_provider-0.1.58 → golem_vm_provider-0.1.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.58
+Version: 0.1.59
 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.58 → golem_vm_provider-0.1.59}/provider/api/models.py

@@ -116,6 +116,9 @@ class ProviderInfoResponse(BaseModel):
     provider_id: str
     stream_payment_address: str
     glm_token_address: str
+    ip_address: Optional[str] = None
+    country: Optional[str] = None
+    platform: Optional[str] = None
 
 
 class StreamOnChain(BaseModel):
@@ -144,3 +147,10 @@ class StreamStatus(BaseModel):
     computed: StreamComputed
     verified: bool
     reason: str
+
+
+class CreateVMJobResponse(BaseModel):
+    """Lightweight response for async VM creation scheduling."""
+    job_id: str = Field(..., description="Server-side job identifier for creation task")
+    vm_id: str = Field(..., description="Requestor VM identifier (name)")
+    status: str = Field("creating", description="Initial status indicator")

{golem_vm_provider-0.1.58 → golem_vm_provider-0.1.59}/provider/api/routes.py

@@ -2,13 +2,17 @@ import json
 import os
 from typing import List
 from pathlib import Path
-from fastapi import APIRouter, HTTPException, Request
+import asyncio
+import uuid
+from fastapi import APIRouter, HTTPException, Request, Query
+from fastapi.responses import JSONResponse
 
 from dependency_injector.wiring import inject, Provide
 from fastapi import APIRouter, HTTPException, Depends
 
 from typing import TYPE_CHECKING, Any
 from ..container import Container
+from ..jobs.store import JobStore
 from ..utils.logging import setup_logger
 from ..utils.ascii_art import vm_creation_animation, vm_status_change
 from ..vm.models import VMInfo, VMAccessInfo, VMConfig, VMResources, VMNotFoundError
@@ -18,6 +22,7 @@ from .models import (
     StreamStatus,
     StreamOnChain,
     StreamComputed,
+    CreateVMJobResponse,
 )
 from ..payments.blockchain_service import StreamPaymentReader
 from ..vm.service import VMService
@@ -26,28 +31,30 @@ from ..vm.multipass_adapter import MultipassError
 logger = setup_logger(__name__)
 router = APIRouter()
 
+# Job status persisted in SQLite via JobStore (see Container.job_store)
 
-@router.post("/vms", response_model=VMInfo)
+
+@router.post("/vms")
 @inject
 async def create_vm(
     request: CreateVMRequest,
     vm_service: VMService = Depends(Provide[Container.vm_service]),
     settings: Any = Depends(Provide[Container.config]),
     stream_map = Depends(Provide[Container.stream_map]),
-) -> VMInfo:
-    """Create a new VM."""
+    job_store: JobStore = Depends(Provide[Container.job_store]),
+    async_mode: bool = Query(default=False, alias="async"),
+) -> Any:
+    """Create a VM (sync by default; async when `?async=true`)."""
     try:
-        logger.info(f"📥 Received VM creation request for '{request.name}'")
-        
+        logger.info(f"📥 Received VM creation request for '{request.name}' (async={async_mode})")
+
         resources = request.resources or VMResources()
 
         # If payments are enabled, require a valid stream before starting
-        # Determine if we should enforce gating
         enforce = False
         spa = (settings.get("STREAM_PAYMENT_ADDRESS") if isinstance(settings, dict) else getattr(settings, "STREAM_PAYMENT_ADDRESS", None))
         if spa and spa != "0x0000000000000000000000000000000000000000":
             if os.environ.get("PYTEST_CURRENT_TEST"):
-                # In pytest, skip gating only when using default deployment address
                 try:
                     from ..config import Settings as _Cfg  # type: ignore
                     default_spa, _ = _Cfg._load_l2_deployment()  # type: ignore[attr-defined]
@@ -73,39 +80,70 @@ async def create_vm(
                     f"start={s['startTime']} stop={s['stopTime']} rate={s['ratePerSecond']} deposit={s['deposit']} withdrawn={s['withdrawn']} remaining={remaining}s"
                 )
             except Exception:
-                # Best-effort logging; creation will continue/fail based on ok
                 pass
             if not ok:
                 raise HTTPException(status_code=400, detail=f"invalid stream: {reason}")
-        
-        # Create VM config
+
         config = VMConfig(
             name=request.name,
             image=request.image or (settings.get("DEFAULT_VM_IMAGE") if isinstance(settings, dict) else getattr(settings, "DEFAULT_VM_IMAGE", "")),
             resources=resources,
-            ssh_key=request.ssh_key
+            ssh_key=request.ssh_key,
         )
-        
-        vm_info = await vm_service.create_vm(config)
-        # Persist VM->stream mapping if provided
-        if request.stream_id is not None:
+
+        if not async_mode:
+            vm_info = await vm_service.create_vm(config)
+            if request.stream_id is not None:
+                try:
+                    await stream_map.set(vm_info.id, int(request.stream_id))
+                except Exception as e:  # noqa: BLE001
+                    logger.warning(f"failed to persist stream mapping for {vm_info.id}: {e}")
+            await vm_creation_animation(request.name)
+            return vm_info
+
+        # Async path
+        job_id = str(uuid.uuid4())
+        await job_store.create_job(job_id, request.name, status="creating")
+
+        async def _run_creation():
             try:
-                await stream_map.set(vm_info.id, int(request.stream_id))
-            except Exception as e:
-                logger.warning(f"failed to persist stream mapping for {vm_info.id}: {e}")
-        await vm_creation_animation(request.name)
-        return vm_info
+                vm_info = await vm_service.create_vm(config)
+                if request.stream_id is not None:
+                    try:
+                        await stream_map.set(vm_info.id, int(request.stream_id))
+                    except Exception as e:  # noqa: BLE001
+                        logger.warning(f"failed to persist stream mapping for {vm_info.id}: {e}")
+                await vm_creation_animation(request.name)
+                await job_store.update_job(job_id, status="ready")
+            except Exception as e:  # noqa: BLE001
+                logger.error(f"Create VM job failed: {e}")
+                await job_store.update_job(job_id, status="failed", error=str(e))
+
+        asyncio.create_task(_run_creation(), name=f"create-vm:{request.name}")
+
+        env = CreateVMJobResponse(job_id=job_id, vm_id=request.name, status="creating")
+        return JSONResponse(status_code=202, content=env.model_json_schema() and env.model_dump())
+
     except MultipassError as e:
         logger.error(f"Failed to create VM: {e}")
         raise HTTPException(status_code=500, detail=str(e))
     except HTTPException:
-        # Propagate explicit HTTP errors (e.g., payment gating)
         raise
     except Exception as e:
         logger.error(f"An unexpected error occurred: {e}")
         raise HTTPException(status_code=500, detail="An unexpected error occurred")
 
 
+@router.get("/vms/jobs/{job_id}")
+@inject
+async def get_create_job(job_id: str, job_store: JobStore = Depends(Provide[Container.job_store])):
+    """Return async creation job status."""
+    job = await job_store.get_job(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="job not found")
+    return job
+
+
 @router.get("/vms", response_model=List[VMInfo])
 @inject
 async def list_vms(
@@ -163,9 +201,18 @@ async def get_vm_access(
         if not multipass_name:
             raise HTTPException(404, "VM mapping not found")
         
+        # If ssh_port is not yet assigned, return 202 with a simple status payload
+        if vm.ssh_port is None:
+            return JSONResponse(status_code=202, content={
+                "vm_id": requestor_name,
+                "multipass_name": multipass_name,
+                "status": "creating",
+                "ssh_port": None,
+            })
+
         return VMAccessInfo(
             ssh_host=((settings.get("PUBLIC_IP") if isinstance(settings, dict) else getattr(settings, "PUBLIC_IP", None)) or "localhost"),
-            ssh_port=vm.ssh_port,
+            ssh_port=int(vm.ssh_port),
             vm_id=requestor_name,
             multipass_name=multipass_name
         )
@@ -231,10 +278,33 @@ async def delete_vm(
 @router.get("/provider/info", response_model=ProviderInfoResponse)
 @inject
 async def provider_info(settings: Any = Depends(Provide[Container.config])) -> ProviderInfoResponse:
+    # Derive platform similar to advertiser
+    import platform as _plat
+    raw = _plat.machine().lower()
+    platform_str = None
+    try:
+        if 'arm' in raw:
+            platform_str = 'arm64'
+        elif 'x86_64' in raw or 'amd64' in raw or 'x64' in raw:
+            platform_str = 'x86_64'
+        else:
+            platform_str = raw
+    except Exception:
+        platform_str = None
+
+    ip_addr = None
+    try:
+        ip_addr = settings.get("PUBLIC_IP") if isinstance(settings, dict) else getattr(settings, "PUBLIC_IP", None)
+    except Exception:
+        ip_addr = None
+
     return ProviderInfoResponse(
         provider_id=settings["PROVIDER_ID"],
         stream_payment_address=settings["STREAM_PAYMENT_ADDRESS"],
         glm_token_address=settings["GLM_TOKEN_ADDRESS"],
+        ip_address=ip_addr,
+        country=(settings.get("PROVIDER_COUNTRY") if isinstance(settings, dict) else getattr(settings, "PROVIDER_COUNTRY", None)),
+        platform=platform_str,
     )
 
 

{golem_vm_provider-0.1.58 → golem_vm_provider-0.1.59}/provider/config.py

@@ -186,6 +186,12 @@ class Settings(BaseSettings):
         description="Min withdrawable amount (wei) before triggering withdraw"
     )
 
+    # Shutdown behavior
+    STOP_VMS_ON_EXIT: bool = Field(
+        default=False,
+        description="When true, stop all running VMs on provider shutdown. Default keeps VMs running."
+    )
+
     # Faucet settings (L3 for Golem Base adverts)
     FAUCET_URL: str = "https://ethwarsaw.holesky.golemdb.io/faucet"
     CAPTCHA_URL: str = "https://cap.gobas.me"

{golem_vm_provider-0.1.58 → golem_vm_provider-0.1.59}/provider/container.py

@@ -14,6 +14,7 @@ from .vm.name_mapper import VMNameMapper
 from .vm.port_manager import PortManager
 from .vm.proxy_manager import PythonProxyManager
 from .payments.stream_map import StreamMap
+from .jobs.store import JobStore
 from .payments.blockchain_service import StreamPaymentReader, StreamPaymentClient, StreamPaymentConfig as _SPC
 from .payments.monitor import StreamMonitor
 
@@ -119,3 +120,9 @@ class Container(containers.DeclarativeContainer):
         advertisement_service=advertisement_service,
         port_manager=port_manager,
     )
+
+    # Async job store for VM creations
+    job_store = providers.Singleton(
+        JobStore,
+        db_path=providers.Callable(lambda base: Path(base) / "jobs.sqlite", config.VM_DATA_DIR),
+    )

{golem_vm_provider-0.1.58 → golem_vm_provider-0.1.59}/provider/discovery/advertiser.py

@@ -115,6 +115,16 @@ class DiscoveryServerAdvertiser(Advertiser):
             return
 
         try:
+            import platform as _plat
+            raw = (_plat.machine() or '').lower()
+            platform_str = None
+            if raw:
+                if 'aarch64' in raw or 'arm64' in raw or raw.startswith('arm'):
+                    platform_str = 'arm64'
+                elif 'x86_64' in raw or 'amd64' in raw or 'x64' in raw:
+                    platform_str = 'x86_64'
+                else:
+                    platform_str = raw
             async with self.session.post(
                 f"{self.discovery_url}/api/v1/advertisements",
                 headers={
@@ -125,6 +135,7 @@ class DiscoveryServerAdvertiser(Advertiser):
                 json={
                     "ip_address": ip_address,
                     "country": settings.PROVIDER_COUNTRY,
+                    "platform": platform_str,
                     "resources": resources,
                     "pricing": {
                         "usd_per_core_month": settings.PRICE_USD_PER_CORE_MONTH,

{golem_vm_provider-0.1.58 → golem_vm_provider-0.1.59}/provider/discovery/golem_base_advertiser.py

@@ -65,6 +65,16 @@ class GolemBaseAdvertiser(Advertiser):
             existing_keys = await get_provider_entity_keys(self.client, settings.PROVIDER_ID)
 
             # String annotations (metadata + prices as strings; on-chain numeric annotations must be ints)
+            import platform as _plat
+            raw = (_plat.machine() or '').lower()
+            platform_str = None
+            if raw:
+                if 'aarch64' in raw or 'arm64' in raw or raw.startswith('arm'):
+                    platform_str = 'arm64'
+                elif 'x86_64' in raw or 'amd64' in raw or 'x64' in raw:
+                    platform_str = 'x86_64'
+                else:
+                    platform_str = raw
             string_annotations = [
                 Annotation(key="golem_type", value="provider"),
                 Annotation(key="golem_network", value=settings.NETWORK),
@@ -73,6 +83,7 @@ class GolemBaseAdvertiser(Advertiser):
                 Annotation(key="golem_ip_address", value=ip_address),
                 Annotation(key="golem_country", value=settings.PROVIDER_COUNTRY),
                 Annotation(key="golem_provider_name", value=settings.PROVIDER_NAME),
+                Annotation(key="golem_platform", value=platform_str or ""),
                 Annotation(key="golem_price_currency", value="USD/GLM"),
                 # Prices must be strings to avoid RLP sedes errors (ints only allowed for numeric annotations)
                 Annotation(key="golem_price_usd_core_month", value=str(float(settings.PRICE_USD_PER_CORE_MONTH))),

{golem_vm_provider-0.1.58 → golem_vm_provider-0.1.59}/provider/discovery/service.py

@@ -20,7 +20,10 @@ class AdvertisementService:
         """Stop the advertiser."""
         if self._task:
             self._task.cancel()
-            await self._task
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
         await self.advertiser.stop()
 
     async def trigger_update(self):

golem_vm_provider-0.1.59/provider/jobs/store.py

@@ -0,0 +1,116 @@
+import asyncio
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+
+@dataclass
+class JobRecord:
+    job_id: str
+    vm_id: str
+    status: str
+    error: Optional[str]
+    created_at: str
+    updated_at: str
+
+
+class JobStore:
+    """SQLite-backed store for VM creation jobs.
+
+    Keeps minimal fields to track progress and errors across restarts.
+    """
+
+    def __init__(self, db_path: Path):
+        self._db_path = Path(db_path)
+        # Ensure parent directory exists
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_schema()
+
+    def _init_schema(self) -> None:
+        conn = sqlite3.connect(self._db_path, check_same_thread=False)
+        try:
+            with conn:
+                conn.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS jobs (
+                        job_id TEXT PRIMARY KEY,
+                        vm_id TEXT NOT NULL,
+                        status TEXT NOT NULL,
+                        error TEXT,
+                        created_at TEXT NOT NULL,
+                        updated_at TEXT NOT NULL
+                    )
+                    """
+                )
+        finally:
+            conn.close()
+
+    async def create_job(self, job_id: str, vm_id: str, status: str = "creating") -> None:
+        now = datetime.now(timezone.utc).isoformat()
+
+        def _op():
+            conn = sqlite3.connect(self._db_path, check_same_thread=False)
+            try:
+                with conn:
+                    conn.execute(
+                        "INSERT OR REPLACE INTO jobs (job_id, vm_id, status, error, created_at, updated_at) VALUES (?, ?, ?, NULL, ?, ?)",
+                        (job_id, vm_id, status, now, now),
+                    )
+            finally:
+                conn.close()
+
+        await asyncio.to_thread(_op)
+
+    async def update_job(self, job_id: str, *, status: Optional[str] = None, error: Optional[str] = None) -> None:
+        now = datetime.now(timezone.utc).isoformat()
+
+        def _op():
+            conn = sqlite3.connect(self._db_path, check_same_thread=False)
+            try:
+                with conn:
+                    if status is not None and error is not None:
+                        conn.execute(
+                            "UPDATE jobs SET status = ?, error = ?, updated_at = ? WHERE job_id = ?",
+                            (status, error, now, job_id),
+                        )
+                    elif status is not None:
+                        conn.execute(
+                            "UPDATE jobs SET status = ?, updated_at = ? WHERE job_id = ?",
+                            (status, now, job_id),
+                        )
+                    elif error is not None:
+                        conn.execute(
+                            "UPDATE jobs SET error = ?, updated_at = ? WHERE job_id = ?",
+                            (error, now, job_id),
+                        )
+            finally:
+                conn.close()
+
+        await asyncio.to_thread(_op)
+
+    async def get_job(self, job_id: str) -> Optional[Dict[str, Any]]:
+        def _op():
+            conn = sqlite3.connect(self._db_path, check_same_thread=False)
+            try:
+                cur = conn.execute(
+                    "SELECT job_id, vm_id, status, error, created_at, updated_at FROM jobs WHERE job_id = ?",
+                    (job_id,),
+                )
+                row = cur.fetchone()
+                if not row:
+                    return None
+                return {
+                    "job_id": row[0],
+                    "vm_id": row[1],
+                    "status": row[2],
+                    "error": row[3],
+                    "created_at": row[4],
+                    "updated_at": row[5],
+                }
+            finally:
+                conn.close()
+
+        return await asyncio.to_thread(_op)
+

{golem_vm_provider-0.1.58 → golem_vm_provider-0.1.59}/provider/main.py

@@ -1240,8 +1240,12 @@ def streams_withdraw(
 def start(
     no_verify_port: bool = typer.Option(False, "--no-verify-port", help="Skip provider port verification."),
     network: str = typer.Option(None, "--network", help="Target network: 'testnet' or 'mainnet' (overrides env)"),
-    gui: Optional[bool] = typer.Option(None, "--gui/--no-gui", help="Auto-launch Electron GUI (default: auto)"),
+    gui: bool = typer.Option(False, "--gui/--no-gui", help="Launch Electron GUI (default: no)"),
     daemon: bool = typer.Option(False, "--daemon", help="Start in background and write a PID file"),
+    stop_vms_on_exit: Optional[bool] = typer.Option(
+        None, "--stop-vms-on-exit/--keep-vms-on-exit",
+        help="On shutdown: stop all VMs (default: keep VMs running)"
+    ),
 ):
     """Start the provider server."""
     if daemon:
@@ -1258,6 +1262,8 @@ def start(
             args += ["--network", network]
         # Force no GUI for daemonized child to avoid duplicates
         args.append("--no-gui")
+        if stop_vms_on_exit is not None:
+            args.append("--stop-vms-on-exit" if stop_vms_on_exit else "--keep-vms-on-exit")
         cmd = _self_command(args)
         # Ensure GUI not auto-launched via env, regardless of defaults
         env = {**os.environ, "GOLEM_PROVIDER_LAUNCH_GUI": "0"}
@@ -1266,7 +1272,13 @@ def start(
         print(f"Started provider in background (pid={child_pid})")
         raise typer.Exit(code=0)
     else:
-        run_server(dev_mode=False, no_verify_port=no_verify_port, network=network, launch_gui=gui)
+        run_server(
+            dev_mode=False,
+            no_verify_port=no_verify_port,
+            network=network,
+            launch_gui=gui,
+            stop_vms_on_exit=stop_vms_on_exit,
+        )
 
 
 @cli.command()
@@ -1445,17 +1457,6 @@ def _print_pricing_examples(glm_usd):
             f"- {name} ({res.cpu}C, {res.memory}GB RAM, {res.storage}GB Disk): ~{usd_str} per month (~{glm_str})"
         )
 
-def _can_launch_gui() -> bool:
-    import shutil
-    plat = _sys.platform
-    # Basic headless checks
-    if plat.startswith("linux"):
-        if not (os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")):
-            return False
-    # Require npm (or electron) available
-    return bool(shutil.which("npm") or shutil.which("electron"))
-
-
 def _maybe_launch_gui(port: int):
     import subprocess, shutil
     import os as _os
@@ -1521,7 +1522,13 @@ def _maybe_launch_gui(port: int):
         logger.warning(f"Failed to launch GUI: {e}")
 
 
-def run_server(dev_mode: bool | None = None, no_verify_port: bool = False, network: str | None = None, launch_gui: Optional[bool] = None):
+def run_server(
+    dev_mode: bool | None = None,
+    no_verify_port: bool = False,
+    network: str | None = None,
+    launch_gui: bool = False,
+    stop_vms_on_exit: bool | None = None,
+):
     """Helper to run the uvicorn server."""
     import sys
     from pathlib import Path
@@ -1539,6 +1546,9 @@ def run_server(dev_mode: bool | None = None, no_verify_port: bool = False, netwo
     # Apply network override early (affects settings and annotations)
     if network:
         os.environ["GOLEM_PROVIDER_NETWORK"] = network
+    # Apply shutdown behavior override early so it is reflected in settings
+    if stop_vms_on_exit is not None:
+        os.environ["GOLEM_PROVIDER_STOP_VMS_ON_EXIT"] = "1" if stop_vms_on_exit else "0"
     
     # The logic for setting the public IP in dev mode is now handled in config.py
     # The following lines are no longer needed and have been removed.
@@ -1577,17 +1587,8 @@ def run_server(dev_mode: bool | None = None, no_verify_port: bool = False, netwo
         log_config = uvicorn.config.LOGGING_CONFIG
         log_config["formatters"]["access"]["fmt"] = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 
-        # Optionally launch GUI (non-blocking)
-        want_gui: bool
-        if launch_gui is None:
-            env_flag = os.environ.get("GOLEM_PROVIDER_LAUNCH_GUI")
-            if env_flag is not None:
-                want_gui = env_flag.strip().lower() in ("1", "true", "yes")
-            else:
-                want_gui = _can_launch_gui()
-        else:
-            want_gui = bool(launch_gui)
-        if want_gui:
+        # Optionally launch GUI (non-blocking) — disabled by default
+        if bool(launch_gui):
             try:
                 _maybe_launch_gui(int(settings.PORT))
             except Exception:

{golem_vm_provider-0.1.58 → golem_vm_provider-0.1.59}/provider/payments/monitor.py

@@ -2,6 +2,7 @@ import asyncio
 from typing import Optional
 
 from ..utils.logging import setup_logger
+from ..vm.models import VMNotFoundError
 
 logger = setup_logger(__name__)
 
@@ -83,6 +84,16 @@ class StreamMonitor:
                         )
                         try:
                             await self.vm_service.stop_vm(vm_id)
+                        except VMNotFoundError as e:
+                            # If the VM cannot be found, remove it from the stream map
+                            # to avoid repeated stop attempts and log spam.
+                            logger.warning(f"stop_vm failed for {vm_id}: {e}")
+                            try:
+                                await self.stream_map.remove(vm_id)
+                            except Exception as rem_err:
+                                logger.debug(
+                                    f"failed to remove vm {vm_id} from stream map after not-found: {rem_err}"
+                                )
                         except Exception as e:
                             logger.warning(f"stop_vm failed for {vm_id}: {e}")
                         continue

{golem_vm_provider-0.1.58 → golem_vm_provider-0.1.59}/provider/service.py

@@ -17,6 +17,7 @@ class ProviderService:
         self.advertisement_service = advertisement_service
         self.port_manager = port_manager
         self._pricing_updater: PricingAutoUpdater | None = None
+        self._pricing_task: asyncio.Task | None = None
         self._stream_monitor = None
 
     async def setup(self, app: FastAPI):
@@ -104,7 +105,8 @@ class ProviderService:
             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())
+            # Keep a handle to the background task so we can cancel it promptly on shutdown
+            self._pricing_task = asyncio.create_task(self._pricing_updater.start(), name="pricing-updater")
 
             # Start stream monitor if enabled
             from .container import Container
@@ -130,10 +132,49 @@ class ProviderService:
     async def cleanup(self):
         """Cleanup provider components."""
         logger.process("🔄 Cleaning up provider...")
-        await self.advertisement_service.stop()
-        await self.vm_service.provider.cleanup()
+        from .config import settings
+
+        # Stop advertising loop
+        try:
+            await self.advertisement_service.stop()
+        except Exception:
+            pass
+
+        # Optionally stop all running VMs based on configuration (default: keep running)
+        try:
+            if bool(getattr(settings, "STOP_VMS_ON_EXIT", False)):
+                try:
+                    vms = await self.vm_service.list_vms()
+                except Exception:
+                    vms = []
+                for vm in vms:
+                    try:
+                        await self.vm_service.stop_vm(vm.id)
+                    except Exception as e:
+                        logger.warning(f"Failed to stop VM {getattr(vm, 'id', '?')}: {e}")
+        except Exception:
+            pass
+
+        # Provider cleanup hook
+        try:
+            await self.vm_service.provider.cleanup()
+        except Exception:
+            pass
+
+        # Stop pricing updater promptly (cancel background task and set stop flag)
         if self._pricing_updater:
-            self._pricing_updater.stop()
+            try:
+                self._pricing_updater.stop()
+            except Exception:
+                pass
+        if self._pricing_task:
+            try:
+                self._pricing_task.cancel()
+                await self._pricing_task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                pass
         if self._stream_monitor:
             await self._stream_monitor.stop()
         logger.success("✨ Provider cleanup complete")

{golem_vm_provider-0.1.58 → golem_vm_provider-0.1.59}/pyproject.toml

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