unrealon 1.1.6__py3-none-any.whl → 2.0.4__py3-none-any.whl

unrealon_driver/managers/logger.py

@@ -0,0 +1,286 @@
+"""
+Clean logger manager with RPC batching and local fallback.
+"""
+
+import asyncio
+import logging
+import logging.handlers
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+from pathlib import Path
+from collections import deque
+
+from pydantic import BaseModel, Field
+
+from unrealon_core.models.logging import LogEntryData, LogContext
+from unrealon_core.models.websocket.logging import LogBatchMessage, LogBatchData
+from unrealon_driver.utils.time import utc_now
+from .base import BaseManager, ManagerConfig
+
+logger = logging.getLogger(__name__)
+
+
+class LoggerManagerConfig(ManagerConfig):
+    """Logger manager configuration."""
+    
+    # Local logging
+    log_file: Optional[str] = Field(default=None, description="Local log file path")
+    max_file_size: int = Field(default=10485760, description="Max log file size (10MB)")
+    backup_count: int = Field(default=5, description="Number of backup files")
+    
+    # RPC batching
+    batch_size: int = Field(default=10, description="Logs per batch")
+    batch_timeout: float = Field(default=5.0, description="Max batch wait time")
+    
+    # Driver info
+    driver_id: str = Field(..., description="Driver ID for logs")
+
+
+class LoggerManager(BaseManager):
+    """
+    Clean logger manager.
+    
+    Features:
+    - Local file logging (always works)
+    - RPC batching to server (when available)
+    - Automatic fallback on RPC failure
+    - Clean batch processing
+    """
+    
+    def __init__(self, config: LoggerManagerConfig, websocket_client=None):
+        super().__init__(config, "logger")
+        self.config: LoggerManagerConfig = config
+        self.websocket_client = websocket_client
+        
+        # Local logger setup
+        self.local_logger = logging.getLogger(f"driver.{config.driver_id}")
+        self._setup_local_logging()
+        
+        # RPC batching
+        self._log_batch: deque = deque()
+        self._batch_lock = asyncio.Lock()
+        self._batch_task: Optional[asyncio.Task] = None
+        self._running = False
+    
+    def _setup_local_logging(self):
+        """Setup local file logging."""
+        if not self.config.log_file:
+            return
+        
+        try:
+            # Create log directory if needed
+            log_path = Path(self.config.log_file)
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Setup rotating file handler
+            handler = logging.handlers.RotatingFileHandler(
+                self.config.log_file,
+                maxBytes=self.config.max_file_size,
+                backupCount=self.config.backup_count
+            )
+            
+            # Set format
+            formatter = logging.Formatter(
+                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+            )
+            handler.setFormatter(formatter)
+            
+            # Add to logger
+            self.local_logger.addHandler(handler)
+            self.local_logger.setLevel(getattr(logging, self.config.log_level))
+            
+        except Exception as e:
+            logger.error(f"Failed to setup local logging: {e}")
+    
+    async def _initialize(self) -> bool:
+        """Initialize logger manager."""
+        try:
+            # Start batch processor
+            self._running = True
+            self._batch_task = asyncio.create_task(self._batch_processor())
+            
+            logger.info("Logger manager initialized")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Logger manager initialization failed: {e}")
+            return False
+    
+    async def _shutdown(self):
+        """Shutdown logger manager."""
+        try:
+            # Stop batch processor
+            self._running = False
+            
+            if self._batch_task and not self._batch_task.done():
+                self._batch_task.cancel()
+                try:
+                    await self._batch_task
+                except asyncio.CancelledError:
+                    pass
+            
+            # Send remaining logs
+            if self._log_batch:
+                await self._send_batch()
+            
+            logger.info("Logger manager shutdown complete")
+            
+        except Exception as e:
+            logger.error(f"Logger manager shutdown error: {e}")
+    
+    async def _batch_processor(self):
+        """Background task to process log batches."""
+        while self._running:
+            try:
+                # Wait for batch timeout or until we have enough logs
+                await asyncio.sleep(self.config.batch_timeout)
+                
+                async with self._batch_lock:
+                    if len(self._log_batch) >= self.config.batch_size:
+                        await self._send_batch()
+                
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Batch processor error: {e}")
+                await asyncio.sleep(1.0)
+    
+    async def _send_batch(self):
+        """Send current batch via RPC."""
+        if not self._log_batch or not self.websocket_client:
+            return
+        
+        try:
+            # Get logs from batch
+            logs_to_send = []
+            while self._log_batch and len(logs_to_send) < self.config.batch_size:
+                logs_to_send.append(self._log_batch.popleft())
+            
+            if not logs_to_send:
+                return
+            
+            # Create batch message
+            batch_data = LogBatchData(
+                driver_id=self.config.driver_id,
+                logs=logs_to_send,
+                batch_timestamp=utc_now().isoformat()
+            )
+            batch_message = LogBatchMessage(data=batch_data)
+            
+            # Send via WebSocket
+            self.websocket_client.send(batch_message)
+            
+            # Update stats
+            self.stats.record_operation(True, 0.0)
+            
+        except Exception as e:
+            logger.error(f"Failed to send log batch: {e}")
+            # Put logs back in batch for retry
+            for log_entry in reversed(logs_to_send):
+                self._log_batch.appendleft(log_entry)
+            
+            self.stats.record_operation(False, 0.0)
+    
+    def log(self, level: str, message: str, context: Optional[Dict[str, Any]] = None):
+        """
+        Log message with both local and RPC.
+        
+        Args:
+            level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+            message: Log message
+            context: Additional context data
+        """
+        try:
+            # Always log locally first
+            self._log_local(level, message, context)
+            
+            # Add to RPC batch if WebSocket available
+            if self.websocket_client:
+                self._add_to_batch(level, message, context)
+                
+        except Exception as e:
+            logger.error(f"Logging failed: {e}")
+    
+    def _log_local(self, level: str, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log to local file."""
+        try:
+            # Format message with context
+            if context:
+                formatted_message = f"{message} | Context: {context}"
+            else:
+                formatted_message = message
+            
+            # Log at appropriate level
+            log_level = getattr(logging, level.upper(), logging.INFO)
+            self.local_logger.log(log_level, formatted_message)
+            
+        except Exception as e:
+            logger.error(f"Local logging failed: {e}")
+    
+    def _add_to_batch(self, level: str, message: str, context: Optional[Dict[str, Any]] = None):
+        """Add log to RPC batch."""
+        try:
+            # Create log entry
+            log_context = LogContext()  # Use default empty context
+            
+            log_entry = LogEntryData(
+                timestamp=utc_now().isoformat(),
+                level=level.upper(),
+                message=message,
+                driver_id=self.config.driver_id,
+                context=log_context
+            )
+            
+            # Add to batch (thread-safe) - only if event loop is running
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self._add_to_batch_async(log_entry))
+            except RuntimeError:
+                # No running event loop - add directly to batch
+                self._log_batch.append(log_entry)
+            
+        except Exception as e:
+            logger.error(f"Failed to add log to batch: {e}")
+    
+    async def _add_to_batch_async(self, log_entry: LogEntryData):
+        """Add log entry to batch asynchronously."""
+        try:
+            async with self._batch_lock:
+                self._log_batch.append(log_entry)
+                
+                # Send immediately if batch is full
+                if len(self._log_batch) >= self.config.batch_size:
+                    await self._send_batch()
+                    
+        except Exception as e:
+            logger.error(f"Failed to add log to batch async: {e}")
+    
+    # Convenience methods
+    def debug(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log debug message."""
+        self.log("DEBUG", message, context)
+    
+    def info(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log info message."""
+        self.log("INFO", message, context)
+    
+    def warning(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log warning message."""
+        self.log("WARNING", message, context)
+    
+    def error(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log error message."""
+        self.log("ERROR", message, context)
+    
+    def critical(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log critical message."""
+        self.log("CRITICAL", message, context)
+    
+    async def _health_check(self) -> Dict[str, Any]:
+        """Health check for logger."""
+        return {
+            "status": "ok",
+            "batch_size": len(self._log_batch),
+            "local_logging": self.config.log_file is not None,
+            "rpc_logging": self.websocket_client is not None
+        }

unrealon_driver/managers/proxy.py

@@ -0,0 +1,99 @@
+"""
+Clean proxy manager.
+"""
+
+import asyncio
+import random
+from typing import List, Optional, Dict, Any
+from pydantic import Field
+
+from .base import BaseManager, ManagerConfig
+
+
+class ProxyManagerConfig(ManagerConfig):
+    """Proxy manager configuration."""
+    proxies: List[str] = Field(default_factory=list, description="List of proxy URLs")
+    rotation_interval: int = Field(default=300, description="Rotation interval seconds")
+    health_check_interval: int = Field(default=60, description="Health check interval")
+
+
+class ProxyManager(BaseManager):
+    """Simple proxy rotation manager."""
+    
+    def __init__(self, config: ProxyManagerConfig):
+        super().__init__(config, "proxy")
+        self.config: ProxyManagerConfig = config
+        self.active_proxies: List[str] = []
+        self.current_proxy: Optional[str] = None
+        self._rotation_task: Optional[asyncio.Task] = None
+    
+    async def _initialize(self) -> bool:
+        """Initialize proxy manager."""
+        self.active_proxies = self.config.proxies.copy()
+        
+        if self.active_proxies:
+            self.current_proxy = random.choice(self.active_proxies)
+            # Start rotation task
+            self._rotation_task = asyncio.create_task(self._rotation_loop())
+        
+        return True
+    
+    async def _shutdown(self):
+        """Shutdown proxy manager."""
+        if self._rotation_task:
+            self._rotation_task.cancel()
+            try:
+                await self._rotation_task
+            except asyncio.CancelledError:
+                pass
+    
+    async def _rotation_loop(self):
+        """Background proxy rotation."""
+        while True:
+            try:
+                await asyncio.sleep(self.config.rotation_interval)
+                
+                if self.active_proxies:
+                    old_proxy = self.current_proxy
+                    self.current_proxy = random.choice(self.active_proxies)
+                    
+                    if old_proxy != self.current_proxy:
+                        self.logger.info(f"Rotated proxy: {old_proxy} -> {self.current_proxy}")
+                
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.logger.error(f"Proxy rotation error: {e}")
+    
+    def get_proxy(self) -> Optional[str]:
+        """Get current proxy."""
+        return self.current_proxy
+    
+    def get_proxy_dict(self) -> Optional[Dict[str, str]]:
+        """Get proxy as dict for requests."""
+        if not self.current_proxy:
+            return None
+        
+        return {
+            "http": self.current_proxy,
+            "https": self.current_proxy
+        }
+    
+    def mark_proxy_bad(self, proxy: str):
+        """Mark proxy as bad and remove from rotation."""
+        if proxy in self.active_proxies:
+            self.active_proxies.remove(proxy)
+            self.logger.warning(f"Removed bad proxy: {proxy}")
+            
+            # Switch to new proxy if current is bad
+            if proxy == self.current_proxy and self.active_proxies:
+                self.current_proxy = random.choice(self.active_proxies)
+    
+    async def _health_check(self) -> Dict[str, Any]:
+        """Proxy health check."""
+        return {
+            "status": "ok",
+            "current_proxy": self.current_proxy,
+            "active_proxies": len(self.active_proxies),
+            "total_proxies": len(self.config.proxies)
+        }

unrealon_driver/managers/registry.py

@@ -0,0 +1,87 @@
+"""
+Clean manager registry.
+"""
+
+import asyncio
+from typing import Dict, List, Any, Optional
+from .base import BaseManager
+
+
+class ManagerRegistry:
+    """
+    Clean registry for managing all driver managers.
+    
+    Provides centralized lifecycle management and health monitoring.
+    """
+    
+    def __init__(self):
+        self.managers: Dict[str, BaseManager] = {}
+        self._initialized = False
+    
+    def register(self, manager: BaseManager):
+        """Register a manager."""
+        self.managers[manager.name] = manager
+    
+    def get(self, name: str) -> Optional[BaseManager]:
+        """Get manager by name."""
+        return self.managers.get(name)
+    
+    async def initialize_all(self) -> bool:
+        """Initialize all registered managers."""
+        if self._initialized:
+            return True
+        
+        success_count = 0
+        
+        for name, manager in self.managers.items():
+            try:
+                if await manager.initialize():
+                    success_count += 1
+                else:
+                    print(f"Manager {name} initialization failed")
+            except Exception as e:
+                print(f"Manager {name} initialization error: {e}")
+        
+        self._initialized = success_count == len(self.managers)
+        return self._initialized
+    
+    async def shutdown_all(self):
+        """Shutdown all managers."""
+        for name, manager in self.managers.items():
+            try:
+                await manager.shutdown()
+            except Exception as e:
+                print(f"Manager {name} shutdown error: {e}")
+        
+        self._initialized = False
+    
+    async def health_check_all(self) -> Dict[str, Any]:
+        """Get health status of all managers."""
+        health_data = {}
+        
+        for name, manager in self.managers.items():
+            try:
+                health_data[name] = await manager.health_check()
+            except Exception as e:
+                health_data[name] = {
+                    "name": name,
+                    "status": "error",
+                    "error": str(e)
+                }
+        
+        return {
+            "managers": health_data,
+            "total": len(self.managers),
+            "initialized": self._initialized
+        }
+    
+    def get_ready_managers(self) -> List[str]:
+        """Get list of ready manager names."""
+        return [
+            name for name, manager in self.managers.items()
+            if manager.is_ready()
+        ]
+    
+    def is_all_ready(self) -> bool:
+        """Check if all managers are ready."""
+        return all(manager.is_ready() for manager in self.managers.values())

unrealon_driver/managers/threading.py

@@ -0,0 +1,54 @@
+"""
+Clean threading manager.
+"""
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Callable, Optional, Dict
+from pydantic import Field
+
+from .base import BaseManager, ManagerConfig
+
+
+class ThreadManagerConfig(ManagerConfig):
+    """Thread manager configuration."""
+    max_workers: int = Field(default=4, description="Max thread workers")
+
+
+class ThreadManager(BaseManager):
+    """Simple thread pool manager."""
+    
+    def __init__(self, config: ThreadManagerConfig):
+        super().__init__(config, "threading")
+        self.config: ThreadManagerConfig = config
+        self.executor: Optional[ThreadPoolExecutor] = None
+    
+    async def _initialize(self) -> bool:
+        """Initialize thread pool."""
+        self.executor = ThreadPoolExecutor(
+            max_workers=self.config.max_workers,
+            thread_name_prefix="unrealon-driver"
+        )
+        return True
+    
+    async def _shutdown(self):
+        """Shutdown thread pool."""
+        if self.executor:
+            self.executor.shutdown(wait=True)
+            self.executor = None
+    
+    async def run_in_thread(self, func: Callable, *args, **kwargs) -> Any:
+        """Run function in thread pool."""
+        if not self.executor:
+            raise RuntimeError("Thread manager not initialized")
+        
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(self.executor, func, *args, **kwargs)
+    
+    async def _health_check(self) -> Dict[str, Any]:
+        """Thread manager health check."""
+        return {
+            "status": "ok",
+            "max_workers": self.config.max_workers,
+            "active": self.executor is not None
+        }

unrealon_driver/managers/update.py

@@ -0,0 +1,107 @@
+"""
+Clean update manager for driver updates.
+"""
+
+import asyncio
+from typing import Dict, Any, Optional
+from pydantic import Field
+
+from .base import BaseManager, ManagerConfig
+
+
+class UpdateManagerConfig(ManagerConfig):
+    """Update manager configuration."""
+    check_interval: int = Field(default=3600, description="Update check interval seconds")
+    auto_update: bool = Field(default=False, description="Enable auto updates")
+    update_url: Optional[str] = Field(default=None, description="Update server URL")
+
+
+class UpdateManager(BaseManager):
+    """Simple update manager."""
+    
+    def __init__(self, config: UpdateManagerConfig):
+        super().__init__(config, "update")
+        self.config: UpdateManagerConfig = config
+        self._check_task: Optional[asyncio.Task] = None
+        self.last_check: Optional[str] = None
+        self.update_available: bool = False
+    
+    async def _initialize(self) -> bool:
+        """Initialize update manager."""
+        if self.config.update_url:
+            # Start update check task
+            self._check_task = asyncio.create_task(self._update_check_loop())
+        
+        return True
+    
+    async def _shutdown(self):
+        """Shutdown update manager."""
+        if self._check_task:
+            self._check_task.cancel()
+            try:
+                await self._check_task
+            except asyncio.CancelledError:
+                pass
+    
+    async def _update_check_loop(self):
+        """Background update checking."""
+        while True:
+            try:
+                await asyncio.sleep(self.config.check_interval)
+                await self.check_for_updates()
+                
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.logger.error(f"Update check error: {e}")
+    
+    async def check_for_updates(self) -> bool:
+        """Check for available updates."""
+        try:
+            # Placeholder for actual update checking logic
+            self.logger.info("Checking for updates...")
+            
+            # TODO: Implement actual update checking
+            # This would typically involve:
+            # 1. Fetching version info from update server
+            # 2. Comparing with current version
+            # 3. Setting update_available flag
+            
+            self.last_check = "checked"
+            return False
+            
+        except Exception as e:
+            self.logger.error(f"Update check failed: {e}")
+            return False
+    
+    async def perform_update(self) -> bool:
+        """Perform driver update."""
+        try:
+            if not self.update_available:
+                self.logger.info("No updates available")
+                return False
+            
+            # Placeholder for actual update logic
+            self.logger.info("Performing update...")
+            
+            # TODO: Implement actual update process
+            # This would typically involve:
+            # 1. Downloading new version
+            # 2. Validating download
+            # 3. Installing update
+            # 4. Restarting driver
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Update failed: {e}")
+            return False
+    
+    async def _health_check(self) -> Dict[str, Any]:
+        """Update manager health check."""
+        return {
+            "status": "ok",
+            "last_check": self.last_check,
+            "update_available": self.update_available,
+            "auto_update": self.config.auto_update
+        }

unrealon_driver/utils/__init__.py

@@ -0,0 +1,9 @@
+"""
+Utility functions for UnrealOn Driver.
+"""
+
+from .time import utc_now
+
+__all__ = [
+    "utc_now",
+]

unrealon_driver/utils/time.py

@@ -0,0 +1,10 @@
+"""
+Time utilities for UnrealOn Driver.
+"""
+
+from datetime import datetime, timezone
+
+
+def utc_now() -> datetime:
+    """Get current UTC time."""
+    return datetime.now(timezone.utc)