golem-vm-provider 0.1.36__tar.gz → 0.1.38__tar.gz

{golem_vm_provider-0.1.36 → golem_vm_provider-0.1.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.36
+Version: 0.1.38
 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.36 → golem_vm_provider-0.1.38}/provider/config.py

@@ -39,7 +39,8 @@ def ensure_config() -> None:
         print("Using default settings – run with --help to customize")
 
 
-ensure_config()
+if not os.environ.get("GOLEM_PROVIDER_SKIP_BOOTSTRAP") and not os.environ.get("PYTEST_CURRENT_TEST"):
+    ensure_config()
 
 
 class Settings(BaseSettings):
@@ -125,7 +126,10 @@ class Settings(BaseSettings):
     # Discovery Service Settings
     DISCOVERY_URL: str = "http://195.201.39.101:9001"
     ADVERTISER_TYPE: str = "golem_base"  # or "discovery_server"
+    # Deprecated: use platform-specific intervals below
     ADVERTISEMENT_INTERVAL: int = 240  # seconds
+    DISCOVERY_ADVERTISEMENT_INTERVAL: int = 240  # seconds
+    GOLEM_BASE_ADVERTISEMENT_INTERVAL: int = 3600  # seconds (on-chain cost, keep higher)
 
     # Golem Base Settings
     GOLEM_BASE_RPC_URL: str = "https://ethwarsaw.holesky.golemdb.io/rpc"
@@ -274,6 +278,14 @@ class Settings(BaseSettings):
     # Rate Limiting
     RATE_LIMIT_PER_MINUTE: int = 100
 
+    # Retry/Timeout Settings (for long-running external calls)
+    RETRY_ATTEMPTS: int = 5
+    RETRY_DELAY_SECONDS: float = 2.0
+    RETRY_BACKOFF: float = 2.0
+    CREATE_VM_MAX_RETRIES: int = 15
+    CREATE_VM_RETRY_DELAY_SECONDS: float = 5.0
+    LAUNCH_TIMEOUT_SECONDS: int = 300
+
     # Multipass Settings
     MULTIPASS_BINARY_PATH: str = Field(
         default="",
@@ -467,6 +479,25 @@ class Settings(BaseSettings):
             logger.info(f"Using manually provided IP: {v}")
         return v
 
+    # Pricing Settings (configured in USD; auto-converted to GLM)
+    # Per-month prices per unit
+    PRICE_USD_PER_CORE_MONTH: float = Field(default=5.0, ge=0)
+    PRICE_USD_PER_GB_RAM_MONTH: float = Field(default=2.0, ge=0)
+    PRICE_USD_PER_GB_STORAGE_MONTH: float = Field(default=0.1, ge=0)
+
+    # Auto-updated GLM-denominated prices (derived from USD via CoinGecko)
+    PRICE_GLM_PER_CORE_MONTH: float = Field(default=0.0, ge=0)
+    PRICE_GLM_PER_GB_RAM_MONTH: float = Field(default=0.0, ge=0)
+    PRICE_GLM_PER_GB_STORAGE_MONTH: float = Field(default=0.0, ge=0)
+
+    # CoinGecko integration
+    COINGECKO_API_URL: str = "https://api.coingecko.com/api/v3"
+    COINGECKO_IDS: str = "golem,golem-network-tokens"  # try both, first wins
+    PRICING_UPDATE_ENABLED: bool = True
+    PRICING_UPDATE_MIN_DELTA_PERCENT: float = Field(default=1.0, ge=0.0)
+    PRICING_UPDATE_INTERVAL_DISCOVERY: int = 900    # 15 minutes
+    PRICING_UPDATE_INTERVAL_GOLEM_BASE: int = 14400 # 4 hours
+
     class Config:
         env_prefix = "GOLEM_PROVIDER_"
         case_sensitive = True

{golem_vm_provider-0.1.36 → golem_vm_provider-0.1.38}/provider/container.py

@@ -6,6 +6,7 @@ from .config import settings
 from .discovery.resource_tracker import ResourceTracker
 from .discovery.golem_base_advertiser import GolemBaseAdvertiser
 from .discovery.advertiser import DiscoveryServerAdvertiser
+from .discovery.multi_advertiser import MultiAdvertiser
 from .discovery.service import AdvertisementService
 from .service import ProviderService
 from .vm.multipass_adapter import MultipassAdapter
@@ -32,6 +33,10 @@ class Container(containers.DeclarativeContainer):
             DiscoveryServerAdvertiser,
             resource_tracker=resource_tracker,
         ),
+        both=providers.Singleton(
+            MultiAdvertiser,
+            resource_tracker=resource_tracker,
+        ),
     )
 
     advertisement_service = providers.Singleton(

{golem_vm_provider-0.1.36 → golem_vm_provider-0.1.38}/provider/discovery/advertiser.py

@@ -65,7 +65,7 @@ class DiscoveryServerAdvertiser(Advertiser):
         try:
             while not self._stop_event.is_set():
                 await self.post_advertisement()
-                await asyncio.sleep(settings.ADVERTISEMENT_INTERVAL)
+                await asyncio.sleep(settings.DISCOVERY_ADVERTISEMENT_INTERVAL)
         finally:
             await self.stop()
 
@@ -76,7 +76,12 @@ class DiscoveryServerAdvertiser(Advertiser):
             await self.session.close()
             self.session = None
 
-    @async_retry(retries=5, delay=1.0, backoff=2.0, exceptions=(aiohttp.ClientError, asyncio.TimeoutError))
+    @async_retry(
+        retries=settings.RETRY_ATTEMPTS,
+        delay=settings.RETRY_DELAY_SECONDS,
+        backoff=settings.RETRY_BACKOFF,
+        exceptions=(aiohttp.ClientError, asyncio.TimeoutError),
+    )
     async def _check_discovery_health(self):
         """Check discovery service health with retries."""
         if not self.session:
@@ -86,7 +91,12 @@ class DiscoveryServerAdvertiser(Advertiser):
             if not response.ok:
                 raise Exception(f"Discovery service health check failed: {response.status}")
 
-    @async_retry(retries=3, delay=1.0, backoff=2.0, exceptions=(aiohttp.ClientError, asyncio.TimeoutError))
+    @async_retry(
+        retries=settings.RETRY_ATTEMPTS,
+        delay=settings.RETRY_DELAY_SECONDS,
+        backoff=settings.RETRY_BACKOFF,
+        exceptions=(aiohttp.ClientError, asyncio.TimeoutError),
+    )
     async def post_advertisement(self):
         """Post resource advertisement to discovery service."""
         if not self.session:
@@ -115,7 +125,15 @@ class DiscoveryServerAdvertiser(Advertiser):
                 json={
                     "ip_address": ip_address,
                     "country": settings.PROVIDER_COUNTRY,
-                    "resources": resources
+                    "resources": resources,
+                    "pricing": {
+                        "usd_per_core_month": settings.PRICE_USD_PER_CORE_MONTH,
+                        "usd_per_gb_ram_month": settings.PRICE_USD_PER_GB_RAM_MONTH,
+                        "usd_per_gb_storage_month": settings.PRICE_USD_PER_GB_STORAGE_MONTH,
+                        "glm_per_core_month": settings.PRICE_GLM_PER_CORE_MONTH,
+                        "glm_per_gb_ram_month": settings.PRICE_GLM_PER_GB_RAM_MONTH,
+                        "glm_per_gb_storage_month": settings.PRICE_GLM_PER_GB_STORAGE_MONTH,
+                    }
                 },
                 timeout=aiohttp.ClientTimeout(total=5)
             ) as response:
@@ -132,7 +150,12 @@ class DiscoveryServerAdvertiser(Advertiser):
             logger.error("Advertisement request timed out")
             raise
 
-    @async_retry(retries=3, delay=1.0, backoff=2.0, exceptions=(aiohttp.ClientError, asyncio.TimeoutError))
+    @async_retry(
+        retries=settings.RETRY_ATTEMPTS,
+        delay=settings.RETRY_DELAY_SECONDS,
+        backoff=settings.RETRY_BACKOFF,
+        exceptions=(aiohttp.ClientError, asyncio.TimeoutError),
+    )
     async def _get_public_ip(self) -> str:
         """Get public IP address with retries."""
         if not self.session:

{golem_vm_provider-0.1.36 → golem_vm_provider-0.1.38}/provider/discovery/golem_base_advertiser.py

@@ -36,7 +36,7 @@ class GolemBaseAdvertiser(Advertiser):
         try:
             while not self._stop_event.is_set():
                 await self.post_advertisement()
-                await asyncio.sleep(settings.ADVERTISEMENT_INTERVAL)
+                await asyncio.sleep(settings.GOLEM_BASE_ADVERTISEMENT_INTERVAL)
         finally:
             await self.stop()
 
@@ -70,11 +70,18 @@ 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_price_currency", value="USD/GLM"),
             ]
             numeric_annotations = [
                 Annotation(key="golem_cpu", value=resources["cpu"]),
                 Annotation(key="golem_memory", value=resources["memory"]),
                 Annotation(key="golem_storage", value=resources["storage"]),
+                Annotation(key="golem_price_usd_core_month", value=float(settings.PRICE_USD_PER_CORE_MONTH)),
+                Annotation(key="golem_price_usd_ram_gb_month", value=float(settings.PRICE_USD_PER_GB_RAM_MONTH)),
+                Annotation(key="golem_price_usd_storage_gb_month", value=float(settings.PRICE_USD_PER_GB_STORAGE_MONTH)),
+                Annotation(key="golem_price_glm_core_month", value=float(settings.PRICE_GLM_PER_CORE_MONTH)),
+                Annotation(key="golem_price_glm_ram_gb_month", value=float(settings.PRICE_GLM_PER_GB_RAM_MONTH)),
+                Annotation(key="golem_price_glm_storage_gb_month", value=float(settings.PRICE_GLM_PER_GB_STORAGE_MONTH)),
             ]
 
             if len(existing_keys) > 1:

golem_vm_provider-0.1.38/provider/discovery/multi_advertiser.py

@@ -0,0 +1,28 @@
+import asyncio
+from typing import Optional
+
+from .advertiser import Advertiser
+from .golem_base_advertiser import GolemBaseAdvertiser
+from .advertiser import DiscoveryServerAdvertiser
+from .resource_tracker import ResourceTracker
+
+
+class MultiAdvertiser(Advertiser):
+    """Advertise to both Golem Base and the Discovery Server."""
+
+    def __init__(self, resource_tracker: ResourceTracker):
+        self.golem = GolemBaseAdvertiser(resource_tracker)
+        self.discovery = DiscoveryServerAdvertiser(resource_tracker)
+
+    async def initialize(self):
+        await asyncio.gather(self.golem.initialize(), self.discovery.initialize())
+
+    async def start_loop(self):
+        await asyncio.gather(self.golem.start_loop(), self.discovery.start_loop())
+
+    async def stop(self):
+        await asyncio.gather(self.golem.stop(), self.discovery.stop())
+
+    async def post_advertisement(self):
+        await asyncio.gather(self.golem.post_advertisement(), self.discovery.post_advertisement())
+

{golem_vm_provider-0.1.36 → golem_vm_provider-0.1.38}/provider/discovery/service.py

@@ -21,4 +21,11 @@ class AdvertisementService:
         if self._task:
             self._task.cancel()
             await self._task
-        await self.advertiser.stop()
+        await self.advertiser.stop()
+
+    async def trigger_update(self):
+        """Trigger an immediate advertisement update."""
+        try:
+            await self.advertiser.post_advertisement()
+        except Exception:
+            pass

{golem_vm_provider-0.1.36 → golem_vm_provider-0.1.38}/provider/main.py

@@ -121,6 +121,8 @@ except ImportError:
     import importlib_metadata as metadata
 
 cli = typer.Typer()
+pricing_app = typer.Typer(help="Configure USD pricing; auto-converts to GLM.")
+cli.add_typer(pricing_app, name="pricing")
 
 def print_version(ctx: typer.Context, value: bool):
     if not value:
@@ -149,6 +151,64 @@ def dev(no_verify_port: bool = typer.Option(True, "--no-verify-port", help="Skip
     """Start the provider server in development mode."""
     run_server(dev_mode=True, no_verify_port=no_verify_port)
 
+def _env_path_for(dev_mode: Optional[bool]) -> str:
+    from pathlib import Path
+    env_file = ".env.dev" if dev_mode else ".env"
+    return str(Path(__file__).parent.parent / env_file)
+
+def _write_env_vars(path: str, updates: dict):
+    # Simple .env updater: preserves other lines, replaces/append updated keys
+    import re
+    import io
+    try:
+        with open(path, "r") as f:
+            lines = f.readlines()
+    except FileNotFoundError:
+        lines = []
+
+    kv = {**updates}
+    pattern = re.compile(r"^(?P<k>[A-Z0-9_]+)=.*$")
+    out = []
+    seen = set()
+    for line in lines:
+        m = pattern.match(line.strip())
+        if not m:
+            out.append(line)
+            continue
+        k = m.group("k")
+        if k in kv:
+            out.append(f"{k}={kv[k]}\n")
+            seen.add(k)
+        else:
+            out.append(line)
+    for k, v in kv.items():
+        if k not in seen:
+            out.append(f"{k}={v}\n")
+
+    with open(path, "w") as f:
+        f.writelines(out)
+
+def _print_pricing_examples(glm_usd):
+    from decimal import Decimal
+    from .utils.pricing import calculate_monthly_cost, calculate_monthly_cost_usd
+    from .vm.models import VMResources
+    examples = [
+        ("Small", VMResources(cpu=1, memory=1, storage=10)),
+        ("Medium", VMResources(cpu=2, memory=4, storage=20)),
+        ("Example 2c/2g/10g", VMResources(cpu=2, memory=2, storage=10)),
+    ]
+    # Maintain legacy header for tests while adding a clearer caption
+    print("\nExample monthly costs with current settings:")
+    print("(Estimated monthly earnings with your current pricing)")
+    for name, res in examples:
+        glm = calculate_monthly_cost(res)
+        usd = calculate_monthly_cost_usd(res, glm_usd)
+        usd_str = f"${usd:.2f}" if usd is not None else "—"
+        glm_str = f"{glm:.4f} GLM"
+        print(
+            f"- {name} ({res.cpu}C, {res.memory}GB RAM, {res.storage}GB Disk): ~{usd_str} per month (~{glm_str})"
+        )
+
 def run_server(dev_mode: bool, no_verify_port: bool):
     """Helper to run the uvicorn server."""
     import sys
@@ -209,3 +269,74 @@ def run_server(dev_mode: bool, no_verify_port: bool):
 
 if __name__ == "__main__":
     cli()
+
+
+@pricing_app.command("show")
+def pricing_show():
+    """Show current USD and GLM per-unit monthly prices and examples."""
+    from decimal import Decimal
+    from .utils.pricing import fetch_glm_usd_price, update_glm_unit_prices_from_usd
+
+    print("Current pricing (per month):")
+    print(
+        f"  - USD per unit: CPU ${settings.PRICE_USD_PER_CORE_MONTH}/core, RAM ${settings.PRICE_USD_PER_GB_RAM_MONTH}/GB, Disk ${settings.PRICE_USD_PER_GB_STORAGE_MONTH}/GB"
+    )
+    glm_usd = fetch_glm_usd_price()
+    if not glm_usd:
+        print("Error: Could not fetch GLM/USD price. Please try again later.")
+        raise typer.Exit(code=1)
+    # Coerce to Decimal for calculations if needed
+    from decimal import Decimal
+    if not isinstance(glm_usd, Decimal):
+        glm_usd = Decimal(str(glm_usd))
+    update_glm_unit_prices_from_usd(glm_usd)
+    print(f"  - GLM price: ${glm_usd} per GLM")
+    print(f"  - Rate: {glm_usd} USD/GLM")
+    print(
+        f"  - GLM per unit: CPU {round(float(settings.PRICE_GLM_PER_CORE_MONTH), 6)} GLM/core, RAM {round(float(settings.PRICE_GLM_PER_GB_RAM_MONTH), 6)} GLM/GB, Disk {round(float(settings.PRICE_GLM_PER_GB_STORAGE_MONTH), 6)} GLM/GB"
+    )
+    _print_pricing_examples(glm_usd)
+
+
+@pricing_app.command("set")
+def pricing_set(
+    usd_per_core: float = typer.Option(
+        ..., "--usd-per-core", "--core-usd", help="USD per CPU core per month"
+    ),
+    usd_per_mem: float = typer.Option(
+        ..., "--usd-per-mem", "--ram-usd", help="USD per GB of RAM per month"
+    ),
+    usd_per_disk: float = typer.Option(
+        ..., "--usd-per-disk", "--usd-per-storage", "--storage-usd", help="USD per GB of disk per month"
+    ),
+    dev: bool = typer.Option(False, "--dev", help="Write to .env.dev instead of .env"),
+):
+    """Set USD pricing; GLM rates auto-update via CoinGecko in background."""
+    if usd_per_core < 0 or usd_per_mem < 0 or usd_per_disk < 0:
+        raise typer.BadParameter("All pricing values must be >= 0")
+    env_path = _env_path_for(dev)
+    updates = {
+        "GOLEM_PROVIDER_PRICE_USD_PER_CORE_MONTH": usd_per_core,
+        "GOLEM_PROVIDER_PRICE_USD_PER_GB_RAM_MONTH": usd_per_mem,
+        "GOLEM_PROVIDER_PRICE_USD_PER_GB_STORAGE_MONTH": usd_per_disk,
+    }
+    _write_env_vars(env_path, updates)
+    print(f"Updated pricing in {env_path}")
+    # Immediately reflect in current process settings as well
+    settings.PRICE_USD_PER_CORE_MONTH = usd_per_core
+    settings.PRICE_USD_PER_GB_RAM_MONTH = usd_per_mem
+    settings.PRICE_USD_PER_GB_STORAGE_MONTH = usd_per_disk
+
+    from .utils.pricing import fetch_glm_usd_price, update_glm_unit_prices_from_usd
+    glm_usd = fetch_glm_usd_price()
+    if glm_usd:
+        # Coerce to Decimal for calculations if needed
+        from decimal import Decimal
+        if not isinstance(glm_usd, Decimal):
+            glm_usd = Decimal(str(glm_usd))
+        update_glm_unit_prices_from_usd(glm_usd)
+        print("Recalculated GLM prices due to updated USD configuration.")
+        _print_pricing_examples(glm_usd)
+    else:
+        print("Warning: could not fetch GLM/USD; GLM unit prices not recalculated.")
+        print("Tip: run 'golem-provider pricing show' when online to verify pricing with USD examples.")

{golem_vm_provider-0.1.36 → golem_vm_provider-0.1.38}/provider/service.py

@@ -4,6 +4,7 @@ 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__)
 
@@ -15,6 +16,7 @@ class ProviderService:
         self.vm_service = vm_service
         self.advertisement_service = advertisement_service
         self.port_manager = port_manager
+        self._pricing_updater: PricingAutoUpdater | None = None
 
     async def setup(self, app: FastAPI):
         """Setup and initialize the provider components."""
@@ -35,6 +37,11 @@ class ProviderService:
             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())
 
             # Check wallet balance and request funds if needed
             faucet_client = FaucetClient(
@@ -55,6 +62,8 @@ class ProviderService:
         logger.process("🔄 Cleaning up provider...")
         await self.advertisement_service.stop()
         await self.vm_service.provider.cleanup()
+        if self._pricing_updater:
+            self._pricing_updater.stop()
         logger.success("✨ Provider cleanup complete")
 
     def _setup_directories(self):

golem_vm_provider-0.1.38/provider/utils/pricing.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal, ROUND_HALF_UP, getcontext
+from typing import Optional, Tuple
+import time
+import requests
+
+from ..vm.models import VMResources
+from ..config import settings
+from .logging import setup_logger
+
+logger = setup_logger(__name__)
+
+# Increase precision for financial calcs
+getcontext().prec = 28
+
+
+def quantize_money(value: Decimal) -> Decimal:
+    return value.quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
+
+
+def _coingecko_simple_price(ids: str) -> Optional[Decimal]:
+    base = settings.COINGECKO_API_URL.rstrip("/")
+    url = f"{base}/simple/price"
+    try:
+        resp = requests.get(url, params={"ids": ids, "vs_currencies": "usd"}, timeout=10)
+        resp.raise_for_status()
+        data = resp.json()
+        # Try ids in order and return the first available
+        for _id in ids.split(","):
+            _id = _id.strip()
+            if _id and _id in data and "usd" in data[_id]:
+                usd = Decimal(str(data[_id]["usd"]))
+                if usd > 0:
+                    return usd
+    except Exception as e:
+        logger.warning(f"CoinGecko price fetch failed: {e}")
+    return None
+
+
+def fetch_glm_usd_price() -> Optional[Decimal]:
+    """Fetch the current GLM price in USD from CoinGecko.
+
+    Tries multiple IDs to hedge against slug changes.
+    """
+    return _coingecko_simple_price(settings.COINGECKO_IDS)
+
+
+def usd_to_glm(usd_amount: Decimal, glm_usd: Decimal) -> Decimal:
+    if glm_usd <= 0:
+        raise ValueError("Invalid GLM/USD price")
+    return (usd_amount / glm_usd).quantize(Decimal("0.00000001"), rounding=ROUND_HALF_UP)
+
+
+def glm_to_usd(glm_amount: Decimal, glm_usd: Decimal) -> Decimal:
+    return (glm_amount * glm_usd).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
+
+
+def calculate_monthly_cost(resources: VMResources) -> Decimal:
+    """Calculate monthly cost in GLM for the given resources.
+
+    Uses the GLM-denominated price-per-unit values configured in settings.
+    """
+    core_price = Decimal(str(settings.PRICE_GLM_PER_CORE_MONTH))
+    ram_price = Decimal(str(settings.PRICE_GLM_PER_GB_RAM_MONTH))
+    storage_price = Decimal(str(settings.PRICE_GLM_PER_GB_STORAGE_MONTH))
+
+    total = (
+        core_price * Decimal(resources.cpu) +
+        ram_price * Decimal(resources.memory) +
+        storage_price * Decimal(resources.storage)
+    )
+    return total.quantize(Decimal("0.00000001"), rounding=ROUND_HALF_UP)
+
+
+# Note: function to derive per-unit prices from a total was intentionally not added.
+
+
+def calculate_monthly_cost_usd(resources: VMResources, glm_usd: Decimal) -> Optional[Decimal]:
+    cost_glm = calculate_monthly_cost(resources)
+    try:
+        return glm_to_usd(cost_glm, glm_usd)
+    except Exception:
+        return None
+
+
+def update_glm_unit_prices_from_usd(glm_usd: Decimal) -> Tuple[Decimal, Decimal, Decimal]:
+    """Recompute GLM per-unit monthly prices using current USD config and a GLM/USD rate.
+
+    Returns a tuple of (core_glm, ram_glm, storage_glm).
+    """
+    core_usd = Decimal(str(settings.PRICE_USD_PER_CORE_MONTH))
+    ram_usd = Decimal(str(settings.PRICE_USD_PER_GB_RAM_MONTH))
+    storage_usd = Decimal(str(settings.PRICE_USD_PER_GB_STORAGE_MONTH))
+
+    core_glm = usd_to_glm(core_usd, glm_usd)
+    ram_glm = usd_to_glm(ram_usd, glm_usd)
+    storage_glm = usd_to_glm(storage_usd, glm_usd)
+
+    # Persist on settings instance (in-memory)
+    settings.PRICE_GLM_PER_CORE_MONTH = float(core_glm)
+    settings.PRICE_GLM_PER_GB_RAM_MONTH = float(ram_glm)
+    settings.PRICE_GLM_PER_GB_STORAGE_MONTH = float(storage_glm)
+
+    logger.info(
+        f"Updated GLM prices from USD @ {glm_usd} USD/GLM: core={core_glm}, ram={ram_glm}, storage={storage_glm}"
+    )
+    return core_glm, ram_glm, storage_glm
+
+
+class PricingAutoUpdater:
+    """Background updater for pricing based on CoinGecko.
+
+    It refreshes GLM-per-unit prices from USD config and can trigger callbacks (e.g., re-advertise).
+    """
+
+    def __init__(self, on_updated_callback=None):
+        self._stop = False
+        self._on_updated = on_updated_callback
+        self._last_price: Optional[Decimal] = None
+
+    async def start(self):
+        if not settings.PRICING_UPDATE_ENABLED:
+            return
+
+        # Choose update interval based on platform to avoid excessive on-chain updates
+        interval = (
+            settings.PRICING_UPDATE_INTERVAL_GOLEM_BASE
+            if getattr(settings, "ADVERTISER_TYPE", "discovery_server") == "golem_base"
+            else settings.PRICING_UPDATE_INTERVAL_DISCOVERY
+        )
+        await self._run_loop(interval)
+
+    def stop(self):
+        self._stop = True
+
+    async def _run_loop(self, interval_discovery: int):
+        import asyncio
+
+        while not self._stop:
+            try:
+                glm_usd = fetch_glm_usd_price()
+                if glm_usd:
+                    changed = self._should_update(glm_usd)
+                    if changed:
+                        update_glm_unit_prices_from_usd(glm_usd)
+                        if callable(self._on_updated):
+                            # Inform callback which advertising platform is active
+                            platform = getattr(settings, "ADVERTISER_TYPE", "discovery_server")
+                            await self._on_updated(platform=platform, glm_usd=glm_usd)
+                else:
+                    logger.warning("Skipping pricing update; failed to fetch GLM price")
+            except Exception as e:
+                logger.error(f"Pricing update error: {e}")
+
+            await asyncio.sleep(interval_discovery)
+
+    def _should_update(self, new_price: Decimal) -> bool:
+        if self._last_price is None:
+            self._last_price = new_price
+            return True
+        old = self._last_price
+        if old == 0:
+            self._last_price = new_price
+            return True
+        delta = abs((new_price - old) / old) * Decimal("100")
+        if delta >= Decimal(str(settings.PRICING_UPDATE_MIN_DELTA_PERCENT)):
+            self._last_price = new_price
+            return True
+        return False

{golem_vm_provider-0.1.36 → golem_vm_provider-0.1.38}/provider/utils/retry.py

@@ -7,6 +7,11 @@ logger = logging.getLogger(__name__)
 
 T = TypeVar('T')
 
+
+class NonRetryableError(Exception):
+    """Base class for errors that should not be retried by retry decorators."""
+    pass
+
 def async_retry(
     retries: int = 3,
     delay: float = 1.0,
@@ -68,7 +73,8 @@ def async_retry_unless_not_found(
                 try:
                     return await func(*args, **kwargs)
                 except exceptions as e:
-                    if isinstance(e, VMNotFoundError):
+                    # Skip retries for known non-retryable cases
+                    if isinstance(e, (VMNotFoundError, NonRetryableError)):
                         raise e
 
                     last_exception = e

{golem_vm_provider-0.1.36 → golem_vm_provider-0.1.38}/provider/vm/multipass_adapter.py

@@ -4,7 +4,7 @@ import subprocess
 from pathlib import Path
 import asyncio
 from typing import Dict, List, Optional
-from ..utils.retry import async_retry_unless_not_found
+from ..utils.retry import async_retry_unless_not_found, NonRetryableError
 
 from ..config import settings
 from ..utils.logging import setup_logger
@@ -19,6 +19,11 @@ class MultipassError(VMError):
     pass
 
 
+class NonRetryableMultipassError(MultipassError, NonRetryableError):
+    """Multipass error that should not be retried (e.g., parse/validation errors)."""
+    pass
+
+
 class MultipassAdapter(VMProvider):
     """Manages VMs using Multipass."""
 
@@ -35,7 +40,7 @@ class MultipassAdapter(VMProvider):
 
         # We add a timeout to the launch command to prevent it from hanging indefinitely
         # e.g. during image download. 300 seconds = 5 minutes.
-        timeout = 300 if args[0] == 'launch' else None
+        timeout = settings.LAUNCH_TIMEOUT_SECONDS if args[0] == 'launch' else None
 
         try:
             return await asyncio.to_thread(
@@ -53,7 +58,11 @@ class MultipassAdapter(VMProvider):
             stderr = e.stderr if should_capture and e.stderr else "No stderr captured. See provider logs for command output."
             raise MultipassError(f"Multipass command '{' '.join(args)}' timed out after {timeout} seconds. Stderr: {stderr}")
 
-    @async_retry_unless_not_found(retries=5, delay=2.0)
+    @async_retry_unless_not_found(
+        retries=settings.RETRY_ATTEMPTS,
+        delay=settings.RETRY_DELAY_SECONDS,
+        backoff=settings.RETRY_BACKOFF,
+    )
     async def _get_vm_info(self, vm_id: str) -> Dict:
         """Get detailed information about a VM."""
         try:
@@ -70,7 +79,10 @@ class MultipassAdapter(VMProvider):
                 raise VMNotFoundError(f"VM {vm_id} not found in multipass") from e
             raise
         except (json.JSONDecodeError, KeyError) as e:
-            raise MultipassError(f"Failed to parse VM info or essential fields are missing: {e}")
+            # Parsing/validation issues are not transient; do not waste time retrying
+            raise NonRetryableMultipassError(
+                f"Failed to parse VM info or essential fields are missing: {e}"
+            )
 
     async def initialize(self) -> None:
         """Initialize the VM provider."""
@@ -100,8 +112,8 @@ class MultipassAdapter(VMProvider):
             logger.info(f"VM {multipass_name} launched, waiting for it to be ready...")
 
             ip_address = None
-            max_retries = 15
-            retry_delay = 5  # seconds
+            max_retries = settings.CREATE_VM_MAX_RETRIES
+            retry_delay = settings.CREATE_VM_RETRY_DELAY_SECONDS  # seconds
             for attempt in range(max_retries):
                 try:
                     info = await self._get_vm_info(multipass_name)
@@ -218,4 +230,4 @@ class MultipassAdapter(VMProvider):
 
     async def cleanup(self) -> None:
         """Cleanup resources used by the provider."""
-        pass
+        pass

{golem_vm_provider-0.1.36 → golem_vm_provider-0.1.38}/pyproject.toml

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