golem-vm-provider 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

{golem_vm_provider-0.1.26.dist-info → golem_vm_provider-0.1.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.26
+Version: 0.1.28
 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.28.dist-info/RECORD

@@ -0,0 +1,38 @@
+provider/__init__.py,sha256=HO1fkPpZqPO3z8O8-eVIyx8xXSMIVuTR_b1YF0RtXOg,45
+provider/api/__init__.py,sha256=ssX1ugDqEPt8Fn04IymgmG-Ev8PiXLsCSaiZVvHQnec,344
+provider/api/models.py,sha256=hTQYzVZHJ-SD_pIpoV0KbPUghR-PUY9YKyUlETstwuQ,3567
+provider/api/routes.py,sha256=0_bh3Oh_5f__9wX6Fqb2Hray4YZAStzmlienyV__Sbs,5459
+provider/config.py,sha256=9POtsNbRYDcVW1XGTv6szosKOR5h-41-lHXnJ2_5coM,17856
+provider/container.py,sha256=u8A1FuG2targtBBqQlSiPW1yCTOm1tbrRQh8sIHstiM,2442
+provider/discovery/__init__.py,sha256=Y6o8RxGevBpuQS3k32y-zSVbP6HBXG3veBl9ElVPKaU,349
+provider/discovery/advertiser.py,sha256=2-khnnzaaftiV1QfJoILkzX-ipa3m1PxSdNd7gy7Y0A,5672
+provider/discovery/golem_base_advertiser.py,sha256=qXIiQ0nvn7ytb6LR9KaMNFwGSE2HTY4XtMlkkAG7pj4,6093
+provider/discovery/golem_base_utils.py,sha256=xk7vznhMgzrn0AuGyk6-9N9ukp9oPdBbbk1RI-sVjp0,607
+provider/discovery/resource_monitor.py,sha256=AmiEc7yBGEGXCunQ-QKmVgosDX3gOhK1Y58LJZXrwAs,949
+provider/discovery/resource_tracker.py,sha256=MP7IXd3aIMsjB4xz5Oj9zFDTEnvrnw-Cyxpl33xcJcc,6006
+provider/discovery/service.py,sha256=qU_fa8znPDNk-fQZ6Z3x6HDTbopK6RgfC_D8rixqBmY,709
+provider/main.py,sha256=rC9WK3adULZ2hAQHdMgubBe-s23TXJuJnZrNySiJZSA,6081
+provider/network/port_verifier.py,sha256=3l6WNwBHydggJRFYkAsuBp1eCxaU619kjWuM-zSVj2o,13267
+provider/security/ethereum.py,sha256=EwPZj4JR8OEpto6LhKjuuT3Z9pBX6P7-UQaqJtqFkYQ,1242
+provider/security/faucet.py,sha256=O2DgP3bIrRUm9tdLCdgnda9em0rPyeW42sWhO1EQJaA,5363
+provider/service.py,sha256=Bc7jOemhqgz9adaWOFLbWum8HFY7fmf1Mmx50-Ygwuo,2389
+provider/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+provider/utils/ascii_art.py,sha256=ykBFsztk57GIiz1NJ-EII5UvN74iECqQL4h9VmiW6Z8,3161
+provider/utils/logging.py,sha256=VV3oTYSRT8hUejtXLuua1M6kCHmIJgPspIkzsUVhYW0,1920
+provider/utils/port_display.py,sha256=u1HWQFA2kPbsM-TnsQfL6Hr4KmjIZWZfsjoxarHpbW0,11981
+provider/utils/retry.py,sha256=1p12vZZkfotRDnv56jDXWG4W7jgGuZfRSXcbZC_ytTI,2935
+provider/utils/setup.py,sha256=Z5dLuBQkb5vdoQsu1HJZwXmu9NWsiBYJ7Vq9-C-_tY8,2932
+provider/vm/__init__.py,sha256=LJL504QGbqZvBbMN3G9ixMgAwvOWAKW37zUm_EiaW9M,508
+provider/vm/cloud_init.py,sha256=E5dDH7dqStRcJNDfbarBBe83-c9N63W8B5ycIrHI8eU,4627
+provider/vm/models.py,sha256=hNeXgOnXWyeSiYt07Pdks0B20cDi_VC8jV-tCxULNng,6350
+provider/vm/multipass.py,sha256=rjO3GtuS4O_wXyYXSUiDGWYtQV2LpGxm6kITrA-ghBQ,617
+provider/vm/multipass_adapter.py,sha256=1s3PtiaRmRxqOQJU651pIgZW1kwnZtl-Tclkk341TLM,10104
+provider/vm/name_mapper.py,sha256=14nKfCjJ1WkXfC4vnCYIxNGQUwcl2vcxrJYUAz4fL40,4073
+provider/vm/port_manager.py,sha256=iYSwjTjD_ziOhG8aI7juKHw1OwwRUTJQyQoRUNQvz9w,12514
+provider/vm/provider.py,sha256=A7QN89EJjcSS40_SmKeinG1Jp_NGffJaLse-XdKciAs,1164
+provider/vm/proxy_manager.py,sha256=n4NTsyz2rtrvjtf_ceKBk-g2q_mzqPwruB1q7UlQVBc,14928
+provider/vm/service.py,sha256=VpWhUuVtsmz9yUIiCT7XSoA0aA89I_4-g3JKbaGrryw,3651
+golem_vm_provider-0.1.28.dist-info/METADATA,sha256=6d6iT0cjkTYlrOOTKuE4-lqoVBLoxm7oAD1_-J-so80,10793
+golem_vm_provider-0.1.28.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+golem_vm_provider-0.1.28.dist-info/entry_points.txt,sha256=iFUajRxfViYkFcPMPv2EIjYm-BLOp86LJj_IjCwwZUw,74
+golem_vm_provider-0.1.28.dist-info/RECORD,,

{golem_vm_provider-0.1.26.dist-info → golem_vm_provider-0.1.28.dist-info}/entry_points.txt

@@ -1,3 +1,4 @@
 [console_scripts]
+dev=provider.main:dev
 golem-provider=provider.main:cli
 

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)}")
 
 

provider/api/routes.py

@@ -3,150 +3,144 @@ from typing import List
 from pathlib import Path
 from fastapi import APIRouter, HTTPException, Request
 
-from ..config import settings
-from ..utils.logging import setup_logger, PROCESS, SUCCESS
+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, VMStatus, VMAccessInfo, VMConfig, VMResources
+from ..vm.models import VMInfo, VMAccessInfo, VMConfig, VMResources, VMNotFoundError
 from .models import CreateVMRequest
-from ..vm.multipass import MultipassProvider, MultipassError
+from ..vm.service import VMService
+from ..vm.multipass_adapter import MultipassError
 
 logger = setup_logger(__name__)
 router = APIRouter()
 
+
 @router.post("/vms", response_model=VMInfo)
-async def create_vm(request: CreateVMRequest, req: Request) -> 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}'")
         
-        # Determine resources based on request
-        resources = request.resources
-        if resources is None:
-            # This shouldn't happen due to validator, but just in case
-            resources = VMResources(cpu=1, memory=1, storage=10)
-            
-        logger.info(f"📥 Using resources: {resources.cpu} CPU, {resources.memory}GB RAM, {resources.storage}GB storage")
+        resources = request.resources or VMResources()
         
-        # Validate against minimum requirements
-        if resources.cpu < settings.MIN_CPU_CORES:
-            logger.error(f"❌ CPU cores {resources.cpu} below minimum {settings.MIN_CPU_CORES}")
-            raise HTTPException(400, f"Minimum CPU cores required: {settings.MIN_CPU_CORES}")
-        if resources.memory < settings.MIN_MEMORY_GB:
-            logger.error(f"❌ Memory {resources.memory}GB below minimum {settings.MIN_MEMORY_GB}GB")
-            raise HTTPException(400, f"Minimum memory required: {settings.MIN_MEMORY_GB}GB")
-        if resources.storage < settings.MIN_STORAGE_GB:
-            logger.error(f"❌ Storage {resources.storage}GB below minimum {settings.MIN_STORAGE_GB}GB")
-            raise HTTPException(400, f"Minimum storage required: {settings.MIN_STORAGE_GB}GB")
-
-        # Check and allocate resources
-        logger.process("🔄 Allocating resources")
-        if not await req.app.state.resource_tracker.allocate(resources):
-            logger.error("❌ Insufficient resources available")
-            raise HTTPException(400, "Insufficient resources available on provider")
-        
-        try:
-            # Create VM config
-            config = VMConfig(
-                name=request.name,
-                image=request.image or settings.DEFAULT_VM_IMAGE,
-                resources=resources,
-                ssh_key=request.ssh_key
-            )
-            
-            # Create VM
-            logger.process(f"🔄 Creating VM with config: {config}")
-            vm_info = await req.app.state.provider.create_vm(config)
-
-            # Show success message
-            await vm_creation_animation(request.name)
-            return vm_info
-        except Exception as e:
-            # If VM creation fails, deallocate resources
-            logger.warning("⚠️ VM creation failed, deallocating resources")
-            await req.app.state.resource_tracker.deallocate(resources)
-            raise
+        # 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(500, str(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])
-async def list_vms(req: Request) -> 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")
-        vms = []
-        for vm_id in req.app.state.resource_tracker.get_allocated_vms():
-            vm_info = await req.app.state.provider.get_vm_status(vm_id)
-            vms.append(vm_info)
-        return vms
+        return await vm_service.list_vms()
     except MultipassError as e:
         logger.error(f"Failed to list VMs: {e}")
-        raise HTTPException(500, str(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)
-async def get_vm_status(requestor_name: str, req: Request) -> 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 req.app.state.provider.get_vm_status(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(500, str(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)
-async def get_vm_access(requestor_name: str, req: Request) -> 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:
-        # Get VM info
-        vm = await req.app.state.provider.get_vm_status(requestor_name)
+        vm = await vm_service.get_vm_status(requestor_name)
         if not vm:
             raise HTTPException(404, "VM not found")
         
-        # Get multipass name from mapper
-        multipass_name = await req.app.state.provider.name_mapper.get_multipass_name(requestor_name)
+        multipass_name = await vm_service.name_mapper.get_multipass_name(requestor_name)
         if not multipass_name:
             raise HTTPException(404, "VM mapping not found")
         
-        # Return access info with both names
         return VMAccessInfo(
-            ssh_host=settings.PUBLIC_IP or "localhost",
-            ssh_port=vm.ssh_port or 22,
+            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(500, str(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}")
-async def delete_vm(requestor_name: str, req: Request) -> None:
-    """Delete a VM.
-    
-    Args:
-        requestor_name: Name of the VM as provided by requestor
-    """
+@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}'")
-        
-        # Get multipass name from mapper
-        multipass_name = await req.app.state.provider.name_mapper.get_multipass_name(requestor_name)
-        if not multipass_name:
-            logger.warning(f"No multipass name found for VM '{requestor_name}' (may have been already deleted)")
-            return
-            
-        try:
-            vm_status_change(requestor_name, "STOPPING", "Cleanup in progress")
-            await req.app.state.provider.delete_vm(requestor_name)
-            vm_status_change(requestor_name, "TERMINATED", "Cleanup complete")
-            logger.success(f"✨ Successfully deleted VM '{requestor_name}'")
-        except MultipassError as e:
-            logger.error(f"Failed to delete VM: {e}")
-            raise HTTPException(500, str(e))
-            
-    except Exception as e:
+        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(500, str(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")

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:

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,
+    )

provider/discovery/__init__.py

@@ -1,6 +1,12 @@
-from .advertiser import ResourceMonitor, ResourceAdvertiser
+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",
-    "ResourceAdvertiser"
+    "AdvertisementService",
 ]