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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.26
+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
@@ -17,6 +17,7 @@ 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: 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)
@@ -275,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.26 → 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.26 → 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
 
@@ -18,14 +18,14 @@ class CreateVMRequest(BaseModel):
     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)}")
 
 

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.26 → golem_vm_provider-0.1.27}/provider/config.py

@@ -2,9 +2,10 @@ import os
 from pathlib import Path
 from typing import Optional
 import uuid
+import socket
 
 from pydantic_settings import BaseSettings
-from pydantic import validator, Field
+from pydantic import field_validator, Field
 from .utils.logging import setup_logger
 
 logger = setup_logger(__name__)
@@ -24,10 +25,10 @@ class Settings(BaseSettings):
     def DEV_MODE(self) -> bool:
         return self.ENVIRONMENT == "development"
 
-    @validator("SKIP_PORT_VERIFICATION", always=True)
+    @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.get("DEBUG", False)
+        return v or values.data.get("DEBUG", False)
 
     # Provider Settings
     PROVIDER_NAME: str = "golem-provider"
@@ -39,7 +40,7 @@ class Settings(BaseSettings):
     CAPTCHA_URL: str = "https://cap.gobas.me"
     CAPTCHA_API_KEY: str = "05381a2cef5e"
  
-    @validator("ETHEREUM_KEY_DIR", pre=True)
+    @field_validator("ETHEREUM_KEY_DIR", mode='before')
     def resolve_key_dir(cls, v: str) -> str:
         """Resolve Ethereum key directory path."""
         if not v:
@@ -49,7 +50,7 @@ class Settings(BaseSettings):
             path = Path.home() / path
         return str(path)
 
-    @validator("ETHEREUM_PRIVATE_KEY", always=True)
+    @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
@@ -57,17 +58,17 @@ class Settings(BaseSettings):
         if v:
             return v
         
-        key_dir = values.get("ETHEREUM_KEY_DIR")
+        key_dir = values.data.get("ETHEREUM_KEY_DIR")
         identity = EthereumIdentity(key_dir)
         _, private_key = identity.get_or_create_identity()
         return private_key
 
-    @validator("PROVIDER_ID", always=True)
+    @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.get("ETHEREUM_PRIVATE_KEY")
+        private_key = values.data.get("ETHEREUM_PRIVATE_KEY")
         if not private_key:
             raise ValueError("ETHEREUM_PRIVATE_KEY is not set")
 
@@ -83,16 +84,16 @@ class Settings(BaseSettings):
         
         return provider_id_from_key
  
-    @validator("PROVIDER_NAME", always=True)
+    @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.get("ENVIRONMENT") == "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"
-    DISCOVERY_DRIVER: str = "golem-base" # or "legacy"
+    ADVERTISER_TYPE: str = "golem_base"  # or "discovery_server"
     ADVERTISEMENT_INTERVAL: int = 240  # seconds
 
     # Golem Base Settings
@@ -107,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
@@ -190,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:
@@ -209,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:
@@ -248,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
@@ -373,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:
@@ -392,26 +393,47 @@ class Settings(BaseSettings):
             
         return str(path)
 
-    @validator("PUBLIC_IP", pre=True)
+    @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":
-            if values.get("ENVIRONMENT") == "development":
-                import socket
-                try:
-                    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-                    s.connect(("8.8.8.8", 80))
-                    local_ip = s.getsockname()[0]
-                    s.close()
-                    return local_ip
-                except Exception:
-                    return "127.0.0.1"
             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",
+]