golem-vm-provider 0.1.24__tar.gz → 0.1.27__tar.gz

{golem_vm_provider-0.1.24 → golem_vm_provider-0.1.27}/PKG-INFO

@@ -1,29 +1,30 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.24
+Version: 0.1.27
 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
 Author-email: phillip+vm-on-golem@golemgrid.com
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.13,<4.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: System Administrators
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: System :: Distributed Computing
 Requires-Dist: aiohttp (>=3.8.1,<4.0.0)
 Requires-Dist: colorlog (>=6.8.0,<7.0.0)
 Requires-Dist: cryptography (>=3.4.7,<4.0.0)
-Requires-Dist: eth-account (>=0.8.0,<0.9.0)
-Requires-Dist: fastapi (>=0.68.0,<0.69.0)
+Requires-Dist: dependency-injector (>=4.41.0,<5.0.0)
+Requires-Dist: eth-account (>=0.13.6,<0.14.0)
+Requires-Dist: fastapi (>=0.103.0,<0.104.0)
+Requires-Dist: golem-base-sdk (==0.1.0)
+Requires-Dist: httpx (>=0.23.0,<0.24.0)
 Requires-Dist: psutil (>=5.9.0,<6.0.0)
-Requires-Dist: pydantic (>=1.8.2,<2.0.0)
+Requires-Dist: pydantic (>=2.4.0,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.1.0,<3.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.3.0,<4.0.0)
 Requires-Dist: python-multipart (>=0.0.5,<0.0.6)
@@ -31,7 +32,9 @@ Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Requires-Dist: rich (>=13.7.0,<14.0.0)
 Requires-Dist: setuptools (>=69.0.3,<70.0.0)
+Requires-Dist: typer (>=0.4.0,<0.5.0)
 Requires-Dist: uvicorn (>=0.15.0,<0.16.0)
+Requires-Dist: web3 (==7.13.0)
 Project-URL: Homepage, https://github.com/cryptobench/vm-on-golem
 Project-URL: Repository, https://github.com/cryptobench/vm-on-golem
 Description-Content-Type: text/markdown
@@ -273,7 +276,11 @@ Response:
 ### Starting the Provider
 
 ```bash
-poetry run python run.py
+# To run in production mode
+poetry run golem-provider start
+
+# To run in development mode
+poetry run golem-provider dev
 ```
 
 The provider will:

{golem_vm_provider-0.1.24 → golem_vm_provider-0.1.27}/README.md

@@ -235,7 +235,11 @@ Response:
 ### Starting the Provider
 
 ```bash
-poetry run python run.py
+# To run in production mode
+poetry run golem-provider start
+
+# To run in development mode
+poetry run golem-provider dev
 ```
 
 The provider will:

{golem_vm_provider-0.1.24 → golem_vm_provider-0.1.27}/provider/api/models.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, field_validator
 from typing import Dict, Optional, List, Any
 from datetime import datetime
 
@@ -11,21 +11,21 @@ logger = setup_logger(__name__)
 class CreateVMRequest(BaseModel):
     """Request model for creating a VM."""
     name: str = Field(..., min_length=3, max_length=64,
-                      regex="^[a-z0-9][a-z0-9-]*[a-z0-9]$")
+                      pattern="^[a-z0-9][a-z0-9-]*[a-z0-9]$")
     size: Optional[VMSize] = None
     resources: Optional[VMResources] = None
     image: str = Field(default="24.04")  # Ubuntu 24.04 LTS
-    ssh_key: str = Field(..., regex="^(ssh-rsa|ssh-ed25519) ",
+    ssh_key: str = Field(..., pattern="^(ssh-rsa|ssh-ed25519) ",
                          description="SSH public key for VM access")
 
-    @validator("name")
+    @field_validator("name")
     def validate_name(cls, v: str) -> str:
         """Validate VM name."""
         if "--" in v:
             raise ValueError("VM name cannot contain consecutive hyphens")
         return v
 
-    @validator("resources", pre=True)
+    @field_validator("resources", mode='before')
     def validate_resources(cls, v: Optional[Dict[str, Any]], values: Dict[str, Any]) -> VMResources:
         """Validate and set resources."""
         logger.debug(f"Validating resources input: {v}")
@@ -43,10 +43,10 @@ class CreateVMRequest(BaseModel):
                 return v
 
             # If size provided, use that
-            if "size" in values and values["size"] is not None:
-                result = VMResources.from_size(values["size"])
+            if "size" in values.data and values.data["size"] is not None:
+                result = VMResources.from_size(values.data["size"])
                 logger.debug(
-                    f"Created resources from size {values['size']}: {result}")
+                    f"Created resources from size {values.data['size']}: {result}")
                 return result
 
             # Only use defaults if nothing provided
@@ -57,7 +57,7 @@ class CreateVMRequest(BaseModel):
         except Exception as e:
             logger.error(f"Error validating resources: {e}")
             logger.error(f"Input value: {v}")
-            logger.error(f"Values dict: {values}")
+            logger.error(f"Values dict: {values.data}")
             raise ValueError(f"Invalid resource configuration: {str(e)}")
 
 
@@ -82,7 +82,7 @@ class VMResponse(BaseModel):
 class AddSSHKeyRequest(BaseModel):
     """Request model for adding SSH key."""
     name: str = Field(..., min_length=1, max_length=64)
-    public_key: str = Field(..., regex="^(ssh-rsa|ssh-ed25519) ")
+    public_key: str = Field(..., pattern="^(ssh-rsa|ssh-ed25519) ")
 
 
 class ErrorResponse(BaseModel):

golem_vm_provider-0.1.27/provider/api/routes.py

@@ -0,0 +1,146 @@
+import json
+from typing import List
+from pathlib import Path
+from fastapi import APIRouter, HTTPException, Request
+
+from dependency_injector.wiring import inject, Provide
+from fastapi import APIRouter, HTTPException, Depends
+
+from ..config import Settings
+from ..container import Container
+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
+from .models import CreateVMRequest
+from ..vm.service import VMService
+from ..vm.multipass_adapter import MultipassError
+
+logger = setup_logger(__name__)
+router = APIRouter()
+
+
+@router.post("/vms", response_model=VMInfo)
+@inject
+async def create_vm(
+    request: CreateVMRequest,
+    vm_service: VMService = Depends(Provide[Container.vm_service]),
+    settings: Settings = Depends(Provide[Container.config]),
+) -> VMInfo:
+    """Create a new VM."""
+    try:
+        logger.info(f"📥 Received VM creation request for '{request.name}'")
+        
+        resources = request.resources or VMResources()
+        
+        # Create VM config
+        config = VMConfig(
+            name=request.name,
+            image=request.image or settings["DEFAULT_VM_IMAGE"],
+            resources=resources,
+            ssh_key=request.ssh_key
+        )
+        
+        vm_info = await vm_service.create_vm(config)
+        await vm_creation_animation(request.name)
+        return vm_info
+    except MultipassError as e:
+        logger.error(f"Failed to create VM: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+    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", response_model=List[VMInfo])
+@inject
+async def list_vms(
+    vm_service: VMService = Depends(Provide[Container.vm_service]),
+) -> List[VMInfo]:
+    """List all VMs."""
+    try:
+        logger.info("📋 Listing all VMs")
+        return await vm_service.list_vms()
+    except MultipassError as e:
+        logger.error(f"Failed to list VMs: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+    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/{requestor_name}", response_model=VMInfo)
+@inject
+async def get_vm_status(
+    requestor_name: str,
+    vm_service: VMService = Depends(Provide[Container.vm_service]),
+) -> VMInfo:
+    """Get VM status."""
+    try:
+        logger.info(f"🔍 Getting status for VM '{requestor_name}'")
+        status = await vm_service.get_vm_status(requestor_name)
+        vm_status_change(requestor_name, status.status.value)
+        return status
+    except VMNotFoundError as e:
+        logger.error(f"VM not found: {e}")
+        raise HTTPException(status_code=404, detail=str(e))
+    except MultipassError as e:
+        logger.error(f"Failed to get VM status: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+    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/{requestor_name}/access", response_model=VMAccessInfo)
+@inject
+async def get_vm_access(
+    requestor_name: str,
+    vm_service: VMService = Depends(Provide[Container.vm_service]),
+    settings: Settings = Depends(Provide[Container.config]),
+) -> VMAccessInfo:
+    """Get VM access information."""
+    try:
+        vm = await vm_service.get_vm_status(requestor_name)
+        if not vm:
+            raise HTTPException(404, "VM not found")
+        
+        multipass_name = await vm_service.name_mapper.get_multipass_name(requestor_name)
+        if not multipass_name:
+            raise HTTPException(404, "VM mapping not found")
+        
+        return VMAccessInfo(
+            ssh_host=settings["PUBLIC_IP"] or "localhost",
+            ssh_port=vm.ssh_port,
+            vm_id=requestor_name,
+            multipass_name=multipass_name
+        )
+    except MultipassError as e:
+        logger.error(f"Failed to get VM access info: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+        raise HTTPException(status_code=500, detail="An unexpected error occurred")
+
+
+@router.delete("/vms/{requestor_name}")
+@inject
+async def delete_vm(
+    requestor_name: str,
+    vm_service: VMService = Depends(Provide[Container.vm_service]),
+) -> None:
+    """Delete a VM."""
+    try:
+        logger.process(f"🗑️  Deleting VM '{requestor_name}'")
+        vm_status_change(requestor_name, "STOPPING", "Cleanup in progress")
+        await vm_service.delete_vm(requestor_name)
+        vm_status_change(requestor_name, "TERMINATED", "Cleanup complete")
+        logger.success(f"✨ Successfully deleted VM '{requestor_name}'")
+    except VMNotFoundError as e:
+        logger.error(f"VM not found: {e}")
+        raise HTTPException(status_code=404, detail=str(e))
+    except MultipassError as e:
+        logger.error(f"Failed to delete VM: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+        raise HTTPException(status_code=500, detail="An unexpected error occurred")

{golem_vm_provider-0.1.24 → golem_vm_provider-0.1.27}/provider/config.py

@@ -2,8 +2,10 @@ import os
 from pathlib import Path
 from typing import Optional
 import uuid
+import socket
 
-from pydantic import BaseSettings, validator, Field
+from pydantic_settings import BaseSettings
+from pydantic import field_validator, Field
 from .utils.logging import setup_logger
 
 logger = setup_logger(__name__)
@@ -16,14 +18,29 @@ class Settings(BaseSettings):
     DEBUG: bool = True
     HOST: str = "0.0.0.0"
     PORT: int = 7466
+    SKIP_PORT_VERIFICATION: bool = False
+    ENVIRONMENT: str = "production"
+
+    @property
+    def DEV_MODE(self) -> bool:
+        return self.ENVIRONMENT == "development"
+
+    @field_validator("SKIP_PORT_VERIFICATION", mode='before')
+    def set_skip_verification(cls, v: bool, values: dict) -> bool:
+        """Set skip verification based on debug mode."""
+        return v or values.data.get("DEBUG", False)
 
     # Provider Settings
-    PROVIDER_ID: str = ""  # Will be set from Ethereum identity
     PROVIDER_NAME: str = "golem-provider"
     PROVIDER_COUNTRY: str = "SE"
     ETHEREUM_KEY_DIR: str = ""
-
-    @validator("ETHEREUM_KEY_DIR", pre=True)
+    ETHEREUM_PRIVATE_KEY: Optional[str] = None
+    PROVIDER_ID: str = ""  # Will be set from Ethereum identity
+    FAUCET_URL: str = "https://ethwarsaw.holesky.golemdb.io/faucet"
+    CAPTCHA_URL: str = "https://cap.gobas.me"
+    CAPTCHA_API_KEY: str = "05381a2cef5e"
+ 
+    @field_validator("ETHEREUM_KEY_DIR", mode='before')
     def resolve_key_dir(cls, v: str) -> str:
         """Resolve Ethereum key directory path."""
         if not v:
@@ -33,24 +50,56 @@ class Settings(BaseSettings):
             path = Path.home() / path
         return str(path)
 
-    @validator("PROVIDER_ID", always=True)
-    def get_or_create_provider_id(cls, v: str, values: dict) -> str:
-        """Get or create provider ID from Ethereum identity."""
+    @field_validator("ETHEREUM_PRIVATE_KEY", mode='before')
+    def get_private_key(cls, v: Optional[str], values: dict) -> str:
+        """Get private key from key file if not provided."""
         from provider.security.ethereum import EthereumIdentity
 
-        # If ID provided in env, use it
         if v:
             return v
-
-        # Get ID from Ethereum identity
-        key_dir = values.get("ETHEREUM_KEY_DIR")
+        
+        key_dir = values.data.get("ETHEREUM_KEY_DIR")
         identity = EthereumIdentity(key_dir)
-        return identity.get_or_create_identity()
-
+        _, private_key = identity.get_or_create_identity()
+        return private_key
+
+    @field_validator("PROVIDER_ID", mode='before')
+    def get_provider_id(cls, v: str, values: dict) -> str:
+        """Get provider ID from private key."""
+        from eth_account import Account
+
+        private_key = values.data.get("ETHEREUM_PRIVATE_KEY")
+        if not private_key:
+            raise ValueError("ETHEREUM_PRIVATE_KEY is not set")
+
+        acct = Account.from_key(private_key)
+        provider_id_from_key = acct.address
+
+        # If ID was provided via env, warn if it doesn't match
+        if v and v != provider_id_from_key:
+            logger.warning(
+                f"Provider ID from env ('{v}') does not match ID from key file ('{provider_id_from_key}'). "
+                "Using ID from key file."
+            )
+        
+        return provider_id_from_key
+ 
+    @field_validator("PROVIDER_NAME", mode='before')
+    def set_provider_name(cls, v: str, values: dict) -> str:
+        """Prefix provider name with DEVMODE if in development."""
+        if values.data.get("ENVIRONMENT") == "development":
+            return f"DEVMODE-{v}"
+        return v
+ 
     # Discovery Service Settings
     DISCOVERY_URL: str = "http://195.201.39.101:9001"
+    ADVERTISER_TYPE: str = "golem_base"  # or "discovery_server"
     ADVERTISEMENT_INTERVAL: int = 240  # seconds
 
+    # Golem Base Settings
+    GOLEM_BASE_RPC_URL: str = "https://ethwarsaw.holesky.golemdb.io/rpc"
+    GOLEM_BASE_WS_URL: str = "wss://ethwarsaw.holesky.golemdb.io/rpc/ws"
+
     # VM Settings
     MAX_VMS: int = 10
     DEFAULT_VM_IMAGE: str = "ubuntu:24.04"
@@ -59,7 +108,7 @@ class Settings(BaseSettings):
     CLOUD_INIT_DIR: str = ""
     CLOUD_INIT_FALLBACK_DIR: str = ""  # Will be set to a temp directory if needed
 
-    @validator("CLOUD_INIT_DIR", pre=True)
+    @field_validator("CLOUD_INIT_DIR", mode='before')
     def resolve_cloud_init_dir(cls, v: str) -> str:
         """Resolve and create cloud-init directory path."""
         import platform
@@ -142,7 +191,7 @@ class Settings(BaseSettings):
             logger.error(f"Failed to create cloud-init directory at {path}: {e}")
             raise ValueError(f"Failed to create cloud-init directory: {e}")
 
-    @validator("VM_DATA_DIR", pre=True)
+    @field_validator("VM_DATA_DIR", mode='before')
     def resolve_vm_data_dir(cls, v: str) -> str:
         """Resolve and create VM data directory path."""
         if not v:
@@ -161,7 +210,7 @@ class Settings(BaseSettings):
             
         return str(path)
 
-    @validator("SSH_KEY_DIR", pre=True)
+    @field_validator("SSH_KEY_DIR", mode='before')
     def resolve_ssh_key_dir(cls, v: str) -> str:
         """Resolve and create SSH key directory path with secure permissions."""
         if not v:
@@ -200,7 +249,7 @@ class Settings(BaseSettings):
         description="Path to multipass binary"
     )
 
-    @validator("MULTIPASS_BINARY_PATH")
+    @field_validator("MULTIPASS_BINARY_PATH")
     def detect_multipass_path(cls, v: str) -> str:
         """Detect and validate Multipass binary path."""
         import platform
@@ -325,7 +374,7 @@ class Settings(BaseSettings):
     PROXY_STATE_DIR: str = ""
     PUBLIC_IP: Optional[str] = None
 
-    @validator("PROXY_STATE_DIR", pre=True)
+    @field_validator("PROXY_STATE_DIR", mode='before')
     def resolve_proxy_state_dir(cls, v: str) -> str:
         """Resolve and create proxy state directory path."""
         if not v:
@@ -344,16 +393,47 @@ class Settings(BaseSettings):
             
         return str(path)
 
-    @validator("PUBLIC_IP", pre=True)
-    def get_public_ip(cls, v: Optional[str]) -> Optional[str]:
+    @field_validator("PUBLIC_IP", mode='before')
+    def get_public_ip(cls, v: Optional[str], values: dict) -> Optional[str]:
         """Get public IP if set to 'auto'."""
+        if values.data.get("ENVIRONMENT") == "development":
+            try:
+                hostname = socket.gethostname()
+                ips = socket.gethostbyname_ex(hostname)[2]
+                local_ips = [ip for ip in ips if not ip.startswith("127.")]
+                if local_ips:
+                    ip = local_ips[0]
+                    logger.info(f"Found local IP for development: {ip}")
+                    return ip
+            except socket.gaierror:
+                pass
+
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            try:
+                s.connect(('8.8.8.8', 80))
+                IP = s.getsockname()[0]
+                if IP:
+                    logger.info(f"Found local IP for development: {IP}")
+                    return IP
+            except Exception:
+                pass
+            finally:
+                s.close()
+
+            raise ValueError("Could not determine local IP address in development mode. "
+                             "Please ensure you have a valid network connection.")
         if v == "auto":
             try:
                 import requests
                 response = requests.get("https://api.ipify.org")
-                return response.text.strip()
+                ip = response.text.strip()
+                logger.info(f"Found public IP: {ip}")
+                return ip
             except Exception:
                 return None
+        
+        if v:
+            logger.info(f"Using manually provided IP: {v}")
         return v
 
     class Config:

golem_vm_provider-0.1.27/provider/container.py

@@ -0,0 +1,84 @@
+import os
+from dependency_injector import containers, providers
+from pathlib import Path
+
+from .config import settings
+from .discovery.resource_tracker import ResourceTracker
+from .discovery.golem_base_advertiser import GolemBaseAdvertiser
+from .discovery.advertiser import DiscoveryServerAdvertiser
+from .discovery.service import AdvertisementService
+from .service import ProviderService
+from .vm.multipass_adapter import MultipassAdapter
+from .vm.service import VMService
+from .vm.name_mapper import VMNameMapper
+from .vm.port_manager import PortManager
+from .vm.proxy_manager import PythonProxyManager
+
+
+class Container(containers.DeclarativeContainer):
+    """Dependency injection container."""
+
+    config = providers.Configuration()
+
+    resource_tracker = providers.Singleton(ResourceTracker)
+
+    advertiser = providers.Selector(
+        config.ADVERTISER_TYPE,
+        golem_base=providers.Singleton(
+            GolemBaseAdvertiser,
+            resource_tracker=resource_tracker,
+        ),
+        discovery_server=providers.Singleton(
+            DiscoveryServerAdvertiser,
+            resource_tracker=resource_tracker,
+        ),
+    )
+
+    advertisement_service = providers.Singleton(
+        AdvertisementService,
+        advertiser=advertiser,
+    )
+
+    vm_name_mapper = providers.Singleton(
+        VMNameMapper,
+        db_path=Path(settings.VM_DATA_DIR) / "vm_names.json",
+    )
+
+    port_manager = providers.Singleton(
+        PortManager,
+        start_port=config.PORT_RANGE_START,
+        end_port=config.PORT_RANGE_END,
+        state_file=providers.Callable(
+            os.path.join,
+            config.PROXY_STATE_DIR,
+            "ports.json"
+        ),
+        discovery_port=config.PORT,
+        skip_verification=config.SKIP_PORT_VERIFICATION,
+    )
+
+    proxy_manager = providers.Singleton(
+        PythonProxyManager,
+        port_manager=port_manager,
+        name_mapper=vm_name_mapper,
+    )
+
+    vm_provider = providers.Singleton(
+        MultipassAdapter,
+        proxy_manager=proxy_manager,
+        name_mapper=vm_name_mapper,
+    )
+
+    vm_service = providers.Singleton(
+        VMService,
+        provider=vm_provider,
+        resource_tracker=resource_tracker,
+        name_mapper=vm_name_mapper,
+    )
+
+    provider_service = providers.Singleton(
+        ProviderService,
+        vm_service=vm_service,
+        advertisement_service=advertisement_service,
+        port_manager=port_manager,
+    )

golem_vm_provider-0.1.27/provider/discovery/__init__.py

@@ -0,0 +1,12 @@
+from .advertiser import Advertiser, DiscoveryServerAdvertiser
+from .golem_base_advertiser import GolemBaseAdvertiser
+from .resource_monitor import ResourceMonitor
+from .service import AdvertisementService
+
+__all__ = [
+    "Advertiser",
+    "DiscoveryServerAdvertiser",
+    "GolemBaseAdvertiser",
+    "ResourceMonitor",
+    "AdvertisementService",
+]