golem-vm-provider 0.1.24__py3-none-any.whl → 0.1.27__py3-none-any.whl

provider/main.py

@@ -1,185 +1,73 @@
+from .api import routes
 import asyncio
 import os
+import socket
 from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
 from typing import Optional
 
 from .config import settings
 from .utils.logging import setup_logger, PROCESS, SUCCESS
 from .utils.ascii_art import startup_animation
 from .discovery.resource_tracker import ResourceTracker
-from .discovery.advertiser import ResourceAdvertiser
-from .vm.multipass import MultipassProvider
-from .vm.port_manager import PortManager
-
-logger = setup_logger(__name__)
+from .discovery.advertiser import DiscoveryServerAdvertiser
+from .container import Container
+from .service import ProviderService
+from .utils.logging import setup_logger
 
 app = FastAPI(title="VM on Golem Provider")
-
-async def setup_provider() -> None:
-    """Setup and initialize the provider components."""
-    try:
-        # Create resource tracker first
-        logger.process("🔄 Initializing resource tracker...")
-        resource_tracker = ResourceTracker()
-        app.state.resource_tracker = resource_tracker
-
-        # Create provider with resource tracker and temporary port manager
-        logger.process("🔄 Initializing VM provider...")
-        provider = MultipassProvider(resource_tracker, port_manager=None)  # Will be set later
-        
-        try:
-            # Initialize provider (without port operations)
-            await asyncio.wait_for(provider.initialize(), timeout=30)
-            
-            # Store provider reference
-            app.state.provider = provider
-            app.state.proxy_manager = provider.proxy_manager
-            
-            # Initialize port manager first to verify all ports
-            logger.process("🔄 Initializing port manager...")
-            port_manager = PortManager(
-                start_port=settings.PORT_RANGE_START,
-                end_port=settings.PORT_RANGE_END,
-                discovery_port=settings.PORT
-            )
-            
-            if not await port_manager.initialize():
-                raise RuntimeError("Port verification failed")
-            
-            # Store port manager references
-            app.state.port_manager = port_manager
-            provider.port_manager = port_manager
-            app.state.proxy_manager.port_manager = port_manager
-            
-            # Now restore proxy configurations using only verified ports
-            logger.process("🔄 Restoring proxy configurations...")
-            await app.state.proxy_manager._load_state()
-            
-        except asyncio.TimeoutError:
-            logger.error("Provider initialization timed out")
-            raise
-        except Exception as e:
-            logger.error(f"Failed to initialize provider: {e}")
-            raise
-        
-        # Create and start advertiser in background
-        logger.process("🔄 Starting resource advertiser...")
-        advertiser = ResourceAdvertiser(
-            resource_tracker=resource_tracker,
-            discovery_url=settings.DISCOVERY_URL,
-            provider_id=settings.PROVIDER_ID
-        )
-        
-        # Start advertiser in background task
-        app.state.advertiser_task = asyncio.create_task(advertiser.start())
-        app.state.advertiser = advertiser
-        
-        logger.success("✨ Provider setup complete and ready to accept requests")
-    except Exception as e:
-        logger.error(f"Failed to setup provider: {e}")
-        # Attempt cleanup of any initialized components
-        await cleanup_provider()
-        raise
-
-async def cleanup_provider() -> None:
-    """Cleanup provider components."""
-    cleanup_errors = []
-    
-    # Stop advertiser
-    if hasattr(app.state, "advertiser"):
-        try:
-            await app.state.advertiser.stop()
-            if hasattr(app.state, "advertiser_task"):
-                app.state.advertiser_task.cancel()
-                try:
-                    await app.state.advertiser_task
-                except asyncio.CancelledError:
-                    pass
-        except Exception as e:
-            cleanup_errors.append(f"Failed to stop advertiser: {e}")
-    
-    # Cleanup proxy manager first to stop all proxy servers
-    if hasattr(app.state, "proxy_manager"):
-        try:
-            await asyncio.wait_for(app.state.proxy_manager.cleanup(), timeout=30)
-        except asyncio.TimeoutError:
-            cleanup_errors.append("Proxy manager cleanup timed out")
-        except Exception as e:
-            cleanup_errors.append(f"Failed to cleanup proxy manager: {e}")
-    
-    # Cleanup provider
-    if hasattr(app.state, "provider"):
-        try:
-            await asyncio.wait_for(app.state.provider.cleanup(), timeout=30)
-        except asyncio.TimeoutError:
-            cleanup_errors.append("Provider cleanup timed out")
-        except Exception as e:
-            cleanup_errors.append(f"Failed to cleanup provider: {e}")
-    
-    if cleanup_errors:
-        error_msg = "\n".join(cleanup_errors)
-        logger.error(f"Errors during cleanup:\n{error_msg}")
-    else:
-        logger.success("✨ Provider cleanup complete")
+container = Container()
+container.config.from_pydantic(settings)
+app.container = container
+container.wire(modules=[".api.routes"])
+
+from .vm.models import VMNotFoundError
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+@app.exception_handler(VMNotFoundError)
+async def vm_not_found_exception_handler(request: Request, exc: VMNotFoundError):
+    return JSONResponse(
+        status_code=404,
+        content={"message": str(exc)},
+    )
+
+@app.exception_handler(Exception)
+async def generic_exception_handler(request: Request, exc: Exception):
+    return JSONResponse(
+        status_code=500,
+        content={"message": "An unexpected error occurred"},
+    )
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
 
 @app.on_event("startup")
 async def startup_event():
     """Handle application startup."""
-    try:
-        # Display startup animation
-        await startup_animation()
-
-        # Verify ports first
-        from .vm.port_manager import PortManager
-        from .utils.port_display import PortVerificationDisplay
-        from .config import settings
+    provider_service = container.provider_service()
+    await provider_service.setup(app)
 
-        display = PortVerificationDisplay(
-            provider_port=settings.PORT,
-            port_range_start=settings.PORT_RANGE_START,
-            port_range_end=settings.PORT_RANGE_END
-        )
-        display.print_header()
-
-        # Initialize port manager
-        logger.process("🔄 Verifying port accessibility...")
-        port_manager = PortManager(
-            start_port=settings.PORT_RANGE_START,
-            end_port=settings.PORT_RANGE_END,
-            discovery_port=settings.PORT
-        )
-        if not await port_manager.initialize():
-            logger.error("Port verification failed. Please ensure:")
-            logger.error(f"1. Port {settings.PORT} is accessible for provider access")
-            logger.error(f"2. Some ports in range {settings.PORT_RANGE_START}-{settings.PORT_RANGE_END} are accessible for VM access")
-            logger.error("3. Your firewall/router is properly configured")
-            raise RuntimeError("Port verification failed")
-
-        logger.success(f"✅ Port verification successful - {len(port_manager.verified_ports)} ports available")
-        
-        # Store port manager in app state for later use
-        app.state.port_manager = port_manager
-
-        # Initialize provider
-        await setup_provider()
-    except Exception as e:
-        logger.error(f"Startup failed: {e}")
-        # Ensure proper cleanup
-        await cleanup_provider()
-        raise
 
 @app.on_event("shutdown")
 async def shutdown_event():
     """Handle application shutdown."""
-    await cleanup_provider()
+    provider_service = container.provider_service()
+    await provider_service.cleanup()
 
 # Import routes after app creation to avoid circular imports
-from .api import routes
 app.include_router(routes.router, prefix="/api/v1")
 
 # Export app for uvicorn
 __all__ = ["app", "start"]
 
+
 def check_requirements():
     """Check if all requirements are met."""
     try:
@@ -190,12 +78,13 @@ def check_requirements():
         logger.error(f"Requirements check failed: {e}")
         return False
 
+
 async def verify_provider_port(port: int) -> bool:
     """Verify that the provider port is available for binding.
-    
+
     Args:
         port: The port to verify
-        
+
     Returns:
         bool: True if the port is available, False otherwise
     """
@@ -218,23 +107,47 @@ async def verify_provider_port(port: int) -> bool:
         logger.error("3. Your firewall allows binding to this port")
         return False
 
-def start():
+
+# The get_local_ip function has been removed as this logic is now handled in config.py
+
+
+import typer
+
+cli = typer.Typer()
+
+@cli.command()
+def start(no_verify_port: bool = typer.Option(False, "--no-verify-port", help="Skip provider port verification.")):
     """Start the provider server."""
+    run_server(dev_mode=False, no_verify_port=no_verify_port)
+
+@cli.command()
+def dev(no_verify_port: bool = typer.Option(True, "--no-verify-port", help="Skip provider port verification.")):
+    """Start the provider server in development mode."""
+    run_server(dev_mode=True, no_verify_port=no_verify_port)
+
+def run_server(dev_mode: bool, no_verify_port: bool):
+    """Helper to run the uvicorn server."""
     import sys
     from pathlib import Path
     from dotenv import load_dotenv
     import uvicorn
     from .utils.logging import setup_logger
-    from .config import settings
     
-    # Configure logging with debug mode
-    logger = setup_logger(__name__, debug=True)
+    # Load appropriate .env file
+    env_file = ".env.dev" if dev_mode else ".env"
+    env_path = Path(__file__).parent.parent / env_file
+    load_dotenv(dotenv_path=env_path)
     
+    # The logic for setting the public IP in dev mode is now handled in config.py
+    # The following lines are no longer needed and have been removed.
+
+    # Import settings after loading env
+    from .config import settings
+
+    # Configure logging with debug mode
+    logger = setup_logger(__name__, debug=dev_mode)
+
     try:
-        # Load environment variables from .env file
-        env_path = Path(__file__).parent.parent / '.env'
-        load_dotenv(dotenv_path=env_path)
-        
         # Log environment variables
         logger.info("Environment variables:")
         for key, value in os.environ.items():
@@ -245,24 +158,25 @@ def start():
         if not check_requirements():
             logger.error("Requirements check failed")
             sys.exit(1)
-            
+
         # Verify provider port is available
-        if not asyncio.run(verify_provider_port(settings.PORT)):
+        if not no_verify_port and not asyncio.run(verify_provider_port(settings.PORT)):
             logger.error(f"Provider port {settings.PORT} is not available")
             sys.exit(1)
-        
+
         # Configure uvicorn logging
         log_config = uvicorn.config.LOGGING_CONFIG
         log_config["formatters"]["access"]["fmt"] = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        
+
         # Run server
-        logger.process(f"🚀 Starting provider server on {settings.HOST}:{settings.PORT}")
+        logger.process(
+            f"🚀 Starting provider server on {settings.HOST}:{settings.PORT}")
         uvicorn.run(
             "provider:app",
             host=settings.HOST,
             port=settings.PORT,
             reload=settings.DEBUG,
-            log_level="info" if not settings.DEBUG else "debug",
+            log_level="debug" if dev_mode else "info",
             log_config=log_config,
             timeout_keep_alive=60,  # Increase keep-alive timeout
             limit_concurrency=100,  # Limit concurrent connections
@@ -270,3 +184,6 @@ def start():
     except Exception as e:
         logger.error(f"Failed to start provider server: {e}")
         sys.exit(1)
+
+if __name__ == "__main__":
+    cli()

provider/security/ethereum.py

@@ -13,29 +13,25 @@ class EthereumIdentity:
         self.key_dir = Path(key_dir)
         self.key_file = self.key_dir / "provider_key.json"
         
-    def get_or_create_identity(self) -> str:
-        """Get existing provider ID or create new one from Ethereum key."""
-        # Create directory if it doesn't exist
+    def get_or_create_identity(self) -> (str, str):
+        """Get existing provider ID and private key, or create a new one."""
         self.key_dir.mkdir(parents=True, exist_ok=True)
-        self.key_dir.chmod(0o700)  # Secure permissions
-        
-        # Check for existing key
+        self.key_dir.chmod(0o700)
+
         if self.key_file.exists():
-            with open(self.key_file) as f:
+            with open(self.key_file, "r") as f:
                 key_data = json.load(f)
-                return key_data["address"]
-        
-        # Generate new key
+                return key_data["address"], key_data["private_key"]
+
         Account.enable_unaudited_hdwallet_features()
         acct = Account.create()
         
-        # Save key securely
         key_data = {
             "address": acct.address,
             "private_key": acct.key.hex()
         }
         with open(self.key_file, "w") as f:
             json.dump(key_data, f)
-        self.key_file.chmod(0o600)  # Secure permissions
+        self.key_file.chmod(0o600)
         
-        return acct.address
+        return acct.address, acct.key.hex()

provider/security/faucet.py

@@ -0,0 +1,132 @@
+import asyncio
+import hashlib
+import httpx
+from typing import Optional
+
+from golem_base_sdk import GolemBaseClient
+from provider.utils.logging import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class FaucetClient:
+    """A client for interacting with a Proof of Work-protected faucet."""
+
+    def __init__(self, faucet_url: str, captcha_url: str, captcha_api_key: str):
+        self.faucet_url = faucet_url
+        self.captcha_url = captcha_url
+        self.captcha_api_key = captcha_api_key
+        self.api_endpoint = f"{faucet_url}/api"
+        self.client: Optional[GolemBaseClient] = None
+
+    async def _ensure_client(self):
+        if not self.client:
+            from ..config import settings
+            private_key_hex = settings.ETHEREUM_PRIVATE_KEY.replace("0x", "")
+            private_key_bytes = bytes.fromhex(private_key_hex)
+            self.client = await GolemBaseClient.create_ro_client(
+                rpc_url=settings.GOLEM_BASE_RPC_URL,
+                ws_url=settings.GOLEM_BASE_WS_URL,
+            )
+
+    async def check_balance(self, address: str) -> Optional[float]:
+        """Check the balance of the given address."""
+        await self._ensure_client()
+        try:
+            balance_wei = await self.client.http_client().eth.get_balance(address)
+            balance_eth = self.client.http_client().from_wei(balance_wei, 'ether')
+            return float(balance_eth)
+        except Exception as e:
+            logger.error(f"Failed to check balance: {e}")
+            return None
+
+    async def get_funds(self, address: str) -> Optional[str]:
+        """Request funds from the faucet for the given address."""
+        try:
+            balance = await self.check_balance(address)
+            if balance is not None and balance > 0.01:
+                logger.info(f"Sufficient funds ({balance} ETH), skipping faucet request.")
+                return None
+
+            logger.info("Requesting funds from faucet...")
+            challenge_data = await self._get_challenge()
+            if not challenge_data:
+                return None
+
+            challenge_list = challenge_data.get("challenge")
+            token = challenge_data.get("token")
+
+            if not challenge_list or not token:
+                logger.error(f"Invalid challenge data received: {challenge_data}")
+                return None
+
+            solutions = []
+            for salt, target in challenge_list:
+                nonce = self._solve_challenge(salt, target)
+                solutions.append([salt, target, nonce])
+
+            redeemed_token = await self._redeem_solution(token, solutions)
+            if not redeemed_token:
+                return None
+
+            tx_hash = await self._request_faucet(address, redeemed_token)
+            if tx_hash:
+                logger.success(f"Successfully requested funds. Transaction hash: {tx_hash}")
+            return tx_hash
+        except Exception as e:
+            import traceback
+            logger.error(f"Failed to get funds from faucet: {e}")
+            logger.error(traceback.format_exc())
+            return None
+
+    async def _get_challenge(self) -> Optional[dict]:
+        """Get a PoW challenge from the faucet."""
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                url = f"{self.captcha_url}/{self.captcha_api_key}/api/challenge"
+                response = await client.post(url)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Failed to get PoW challenge: {e.response.text}")
+            return None
+
+    def _solve_challenge(self, salt: str, target: str) -> int:
+        """Solve the PoW challenge."""
+        target_hash = bytes.fromhex(target)
+        nonce = 0
+        while True:
+            hasher = hashlib.sha256()
+            hasher.update(f"{salt}{nonce}".encode())
+            if hasher.digest().startswith(target_hash):
+                return nonce
+            nonce += 1
+
+    async def _redeem_solution(self, token: str, solutions: list) -> Optional[str]:
+        """Redeem the PoW solution to get a CAPTCHA token."""
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                url = f"{self.captcha_url}/{self.captcha_api_key}/api/redeem"
+                response = await client.post(
+                    url,
+                    json={"token": token, "solutions": solutions}
+                )
+                response.raise_for_status()
+                return response.json().get("token")
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Failed to redeem PoW solution: {e.response.text}")
+            return None
+
+    async def _request_faucet(self, address: str, token: str) -> Optional[str]:
+        """Request funds from the faucet with the CAPTCHA token."""
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                response = await client.post(
+                    f"{self.api_endpoint}/faucet",
+                    json={"address": address, "captchaToken": token}
+                )
+                response.raise_for_status()
+                return response.json().get("txHash")
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Faucet request failed: {e.response.text}")
+            return None

provider/service.py

@@ -0,0 +1,67 @@
+import asyncio
+from fastapi import FastAPI
+
+from .utils.logging import setup_logger
+from .vm.service import VMService
+from .discovery.service import AdvertisementService
+
+logger = setup_logger(__name__)
+
+
+class ProviderService:
+    """Service for managing the provider's lifecycle."""
+
+    def __init__(self, vm_service: VMService, advertisement_service: AdvertisementService, port_manager):
+        self.vm_service = vm_service
+        self.advertisement_service = advertisement_service
+        self.port_manager = port_manager
+
+    async def setup(self, app: FastAPI):
+        """Setup and initialize the provider components."""
+        from .config import settings
+        from .utils.ascii_art import startup_animation
+        from .security.faucet import FaucetClient
+
+        try:
+            # Display startup animation
+            await startup_animation()
+
+            logger.process("🔄 Initializing provider...")
+
+            # Setup directories
+            self._setup_directories()
+
+            # Initialize services
+            await self.port_manager.initialize()
+            await self.vm_service.provider.initialize()
+            await self.advertisement_service.start()
+
+            # Check wallet balance and request funds if needed
+            faucet_client = FaucetClient(
+                faucet_url=settings.FAUCET_URL,
+                captcha_url=settings.CAPTCHA_URL,
+                captcha_api_key=settings.CAPTCHA_API_KEY,
+            )
+            await faucet_client.get_funds(settings.PROVIDER_ID)
+
+            logger.success("✨ Provider setup complete")
+        except Exception as e:
+            logger.error(f"Startup failed: {e}")
+            await self.cleanup()
+            raise
+
+    async def cleanup(self):
+        """Cleanup provider components."""
+        logger.process("🔄 Cleaning up provider...")
+        await self.advertisement_service.stop()
+        await self.vm_service.provider.cleanup()
+        logger.success("✨ Provider cleanup complete")
+
+    def _setup_directories(self):
+        """Create necessary directories for the provider."""
+        from .config import settings
+        from pathlib import Path
+        
+        Path(settings.VM_DATA_DIR).mkdir(parents=True, exist_ok=True)
+        Path(settings.SSH_KEY_DIR).mkdir(parents=True, exist_ok=True)
+        Path(settings.CLOUD_INIT_DIR).mkdir(parents=True, exist_ok=True)

provider/utils/logging.py

@@ -39,42 +39,26 @@ def setup_logger(name: Optional[str] = None, debug: bool = False) -> logging.Log
         Configured logger instance
     """
     logger = logging.getLogger(name or __name__)
-    logger.handlers = []  # Clear existing handlers
-    
-    # Fancy handler for important logs
-    fancy_handler = colorlog.StreamHandler(sys.stdout)
-    fancy_formatter = colorlog.ColoredFormatter(
-        "%(log_color)s[%(asctime)s] %(message)s",
+    if logger.handlers:
+        return logger  # Already configured
+
+    handler = colorlog.StreamHandler(sys.stdout)
+    formatter = colorlog.ColoredFormatter(
+        "%(log_color)s[%(asctime)s] %(levelname)s: %(message)s",
         datefmt="%Y-%m-%d %H:%M:%S",
-        reset=True,
         log_colors={
+            'DEBUG': 'cyan',
             'INFO': 'green',
             'PROCESS': 'yellow',
             'WARNING': 'yellow',
             'SUCCESS': 'green,bold',
             'ERROR': 'red',
             'CRITICAL': 'red,bold',
-        },
-        secondary_log_colors={},
-        style='%'
+        }
     )
-    fancy_handler.setFormatter(fancy_formatter)
-    fancy_handler.addFilter(lambda record: record.levelno in [INFO, PROCESS, SUCCESS, WARNING, ERROR, CRITICAL])
-    logger.addHandler(fancy_handler)
-    
-    if debug:
-        # Debug handler for detailed logs
-        debug_handler = logging.StreamHandler(sys.stdout)
-        debug_formatter = logging.Formatter(
-            '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-            datefmt="%Y-%m-%d %H:%M:%S"
-        )
-        debug_handler.setFormatter(debug_formatter)
-        debug_handler.addFilter(lambda record: record.levelno == DEBUG)
-        logger.addHandler(debug_handler)
-        logger.setLevel(logging.DEBUG)
-    else:
-        logger.setLevel(logging.INFO)
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(logging.DEBUG if debug else logging.INFO)
     
     return logger