agentscope-runtime 0.1.3__py3-none-any.whl → 0.1.5b1__py3-none-any.whl

agentscope_runtime/engine/deployers/utils/service_utils/process_manager.py

@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+# pylint:disable=consider-using-with
+
+import asyncio
+import os
+import subprocess
+from typing import Optional
+
+import psutil
+
+
+class ProcessManager:
+    """Manager for detached process lifecycle."""
+
+    def __init__(self, shutdown_timeout: int = 30):
+        """Initialize process manager.
+
+        Args:
+            shutdown_timeout: Timeout in seconds for graceful shutdown
+        """
+        self.shutdown_timeout = shutdown_timeout
+
+    async def start_detached_process(
+        self,
+        script_path: str,
+        host: str = "127.0.0.1",
+        port: int = 8000,
+        env: Optional[dict] = None,
+    ) -> int:
+        """Start a detached process running the given script.
+
+        Args:
+            script_path: Path to the Python script to run
+            host: Host to bind to
+            port: Port to bind to
+            env: Additional environment variables
+
+        Returns:
+            Process PID
+
+        Raises:
+            RuntimeError: If process creation fails
+        """
+        try:
+            # Prepare environment
+            process_env = os.environ.copy()
+            if env:
+                process_env.update(env)
+
+            # Start detached process
+            process = subprocess.Popen(
+                [
+                    "python",
+                    script_path,
+                    "--host",
+                    host,
+                    "--port",
+                    str(port),
+                ],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+                start_new_session=True,  # Create new process group
+                env=process_env,
+                cwd=os.path.dirname(script_path),
+            )
+
+            # Verify process started successfully
+            await asyncio.sleep(0.1)  # Give process time to start
+            if process.poll() is not None:
+                raise RuntimeError("Process failed to start")
+
+            return process.pid
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to start detached process: {e}") from e
+
+    async def stop_process_gracefully(
+        self,
+        pid: int,
+        timeout: Optional[int] = None,
+    ) -> bool:
+        """Stop a process gracefully.
+
+        Args:
+            pid: Process ID to stop
+            timeout: Timeout for graceful shutdown (uses default if None)
+
+        Returns:
+            True if process was stopped successfully
+
+        Raises:
+            RuntimeError: If process termination fails
+        """
+        if timeout is None:
+            timeout = self.shutdown_timeout
+
+        try:
+            # Check if process exists
+            if not psutil.pid_exists(pid):
+                return True  # Already terminated
+
+            process = psutil.Process(pid)
+
+            # Send SIGTERM for graceful shutdown
+            process.terminate()
+
+            # Wait for process to terminate
+            try:
+                process.wait(timeout=timeout)
+                return True
+            except psutil.TimeoutExpired:
+                # Force kill if graceful shutdown failed
+                process.kill()
+                process.wait(timeout=5)  # Wait for kill to complete
+                return True
+
+        except psutil.NoSuchProcess:
+            return True  # Process already terminated
+        except psutil.AccessDenied as e:
+            raise RuntimeError(
+                f"Access denied when terminating process {pid}: {e}",
+            ) from e
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to terminate process {pid}: {e}",
+            ) from e
+
+    def is_process_running(self, pid: int) -> bool:
+        """Check if a process is running.
+
+        Args:
+            pid: Process ID to check
+
+        Returns:
+            True if process is running
+        """
+        try:
+            return psutil.pid_exists(pid)
+        except Exception:
+            return False
+
+    def create_pid_file(self, pid: int, file_path: str):
+        """Create a PID file.
+
+        Args:
+            pid: Process ID
+            file_path: Path to PID file
+
+        Raises:
+            OSError: If file creation fails
+        """
+        try:
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(str(pid))
+        except Exception as e:
+            raise OSError(f"Failed to create PID file {file_path}: {e}") from e
+
+    def read_pid_file(self, file_path: str) -> Optional[int]:
+        """Read PID from file.
+
+        Args:
+            file_path: Path to PID file
+
+        Returns:
+            Process ID or None if file doesn't exist or is invalid
+        """
+        try:
+            if not os.path.exists(file_path):
+                return None
+
+            with open(file_path, "r", encoding="utf-8") as f:
+                return int(f.read().strip())
+        except (ValueError, OSError):
+            return None
+
+    def cleanup_pid_file(self, file_path: str):
+        """Remove PID file.
+
+        Args:
+            file_path: Path to PID file
+        """
+        try:
+            if os.path.exists(file_path):
+                os.remove(file_path)
+        except OSError:
+            pass  # Ignore cleanup errors
+
+    async def find_process_by_port(self, port: int) -> Optional[int]:
+        """Find process listening on a specific port.
+
+        Args:
+            port: Port number
+
+        Returns:
+            Process ID or None if not found
+        """
+        try:
+            for conn in psutil.net_connections(kind="inet"):
+                if conn.laddr.port == port and conn.status == "LISTEN":
+                    if conn.pid:
+                        return conn.pid
+            return None
+        except Exception:
+            return None
+
+    def get_process_info(self, pid: int) -> Optional[dict]:
+        """Get information about a process.
+
+        Args:
+            pid: Process ID
+
+        Returns:
+            Dictionary with process information or None if process not found
+        """
+        try:
+            if not psutil.pid_exists(pid):
+                return None
+
+            process = psutil.Process(pid)
+            return {
+                "pid": pid,
+                "name": process.name(),
+                "status": process.status(),
+                "cpu_percent": process.cpu_percent(),
+                "memory_percent": process.memory_percent(),
+                "create_time": process.create_time(),
+                "cmdline": process.cmdline(),
+            }
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            return None
+
+    async def wait_for_port(
+        self,
+        host: str,
+        port: int,
+        timeout: int = 30,
+    ) -> bool:
+        """Wait for a service to become available on a port.
+
+        Args:
+            host: Host to check
+            port: Port to check
+            timeout: Maximum time to wait
+
+        Returns:
+            True if service becomes available, False if timeout
+        """
+        import socket
+
+        end_time = asyncio.get_event_loop().time() + timeout
+
+        while asyncio.get_event_loop().time() < end_time:
+            try:
+                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                    sock.settimeout(1)
+                    result = sock.connect_ex((host, port))
+                    if result == 0:
+                        return True
+            except Exception:
+                pass
+
+            await asyncio.sleep(0.5)
+
+        return False

agentscope_runtime/engine/deployers/utils/service_utils/service_config.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+"""Service configuration models for dynamic service loading."""
+
+from enum import Enum
+from typing import Dict, Any, Optional
+
+from pydantic import BaseModel
+
+
+class ServiceType(str, Enum):
+    """Types of services that can be configured."""
+
+    MEMORY = "memory"
+    SESSION_HISTORY = "session_history"
+    SANDBOX = "sandbox"
+    RAG = "rag"
+
+
+class ServiceProvider(str, Enum):
+    """Service implementation providers."""
+
+    IN_MEMORY = "in_memory"
+    REDIS = "redis"
+    # Extensible for other providers
+
+
+class ServiceConfig(BaseModel):
+    """Configuration for a single service."""
+
+    provider: ServiceProvider
+    config: Optional[Dict[str, Any]] = {}
+
+
+class ServicesConfig(BaseModel):
+    """Configuration for all services."""
+
+    memory: ServiceConfig = ServiceConfig(provider=ServiceProvider.IN_MEMORY)
+    session_history: ServiceConfig = ServiceConfig(
+        provider=ServiceProvider.IN_MEMORY,
+    )
+    sandbox: Optional[ServiceConfig] = None
+    rag: Optional[ServiceConfig] = None
+
+
+# Default configuration
+DEFAULT_SERVICES_CONFIG = ServicesConfig()
+
+
+def create_redis_services_config(
+    host: str = "localhost",
+    port: int = 6379,
+    memory_db: int = 0,
+    session_db: int = 1,
+) -> ServicesConfig:
+    """Create a ServicesConfig with Redis providers.
+
+    Args:
+        host: Redis host
+        port: Redis port
+        memory_db: Redis database for memory service
+        session_db: Redis database for session history service
+
+    Returns:
+        ServicesConfig: Configuration with Redis services
+    """
+    return ServicesConfig(
+        memory=ServiceConfig(
+            provider=ServiceProvider.REDIS,
+            config={"host": host, "port": port, "db": memory_db},
+        ),
+        session_history=ServiceConfig(
+            provider=ServiceProvider.REDIS,
+            config={"host": host, "port": port, "db": session_db},
+        ),
+    )

agentscope_runtime/engine/deployers/utils/service_utils/service_factory.py

@@ -0,0 +1,220 @@
+# -*- coding: utf-8 -*-
+# pylint:disable=line-too-long
+
+from typing import Dict, Type, Any
+from .service_config import (
+    ServiceType,
+    ServiceProvider,
+    ServiceConfig,
+    ServicesConfig,
+)
+
+
+class ServiceFactory:
+    """Factory for creating service instances based on configuration."""
+
+    # Service registry mapping service types and providers to
+    # implementation classes
+    _service_registry: Dict[str, Dict[str, Type]] = {}
+
+    @classmethod
+    def _populate_registry(cls):
+        """Populate the service registry with available implementations."""
+        if cls._service_registry:
+            return  # Already populated
+
+        try:
+            # Import service implementations
+            from agentscope_runtime.engine.services.memory_service import (
+                InMemoryMemoryService,
+            )
+            from agentscope_runtime.engine.services.session_history_service import (  # noqa E501
+                InMemorySessionHistoryService,
+            )
+
+            # Register memory services
+            cls._service_registry[ServiceType.MEMORY] = {
+                ServiceProvider.IN_MEMORY: InMemoryMemoryService,
+            }
+
+            # Register session history services
+            cls._service_registry[ServiceType.SESSION_HISTORY] = {
+                ServiceProvider.IN_MEMORY: InMemorySessionHistoryService,
+            }
+
+            # Try to register Redis services if available
+
+            from agentscope_runtime.engine.services.redis_memory_service import (  # noqa E501
+                RedisMemoryService,
+            )
+            from agentscope_runtime.engine.services.redis_session_history_service import (  # noqa E501
+                RedisSessionHistoryService,
+            )
+
+            cls._service_registry[ServiceType.MEMORY][
+                ServiceProvider.REDIS
+            ] = RedisMemoryService
+            cls._service_registry[ServiceType.SESSION_HISTORY][
+                ServiceProvider.REDIS
+            ] = RedisSessionHistoryService
+
+            # Try to register other services if available
+            from agentscope_runtime.engine.services.sandbox_service import (
+                SandboxService,
+            )
+
+            # Assuming default implementation
+            cls._service_registry[ServiceType.SANDBOX] = {
+                ServiceProvider.IN_MEMORY: SandboxService,
+            }
+
+            from agentscope_runtime.engine.services.rag_service import (
+                RAGService,
+            )
+
+            # Assuming default implementation
+            cls._service_registry[ServiceType.RAG] = {
+                ServiceProvider.IN_MEMORY: RAGService,
+            }
+
+        except ImportError as e:
+            raise RuntimeError(
+                f"Failed to import required service classes: {e}",
+            ) from e
+
+    @classmethod
+    def create_service(
+        cls,
+        service_type: ServiceType,
+        config: ServiceConfig,
+    ) -> Any:
+        """Create a service instance based on type and configuration.
+
+        Args:
+            service_type: Type of service to create
+            config: Configuration for the service
+
+        Returns:
+            Service instance
+
+        Raises:
+            ValueError: If service type or provider is unknown
+            RuntimeError: If service creation fails
+        """
+        cls._populate_registry()
+
+        if service_type not in cls._service_registry:
+            raise ValueError(f"Unknown service type: {service_type}")
+
+        providers = cls._service_registry[service_type]
+        if config.provider not in providers:
+            available_providers = list(providers.keys())
+            raise ValueError(
+                f"Unknown provider '{config.provider}' for service '"
+                f"{service_type}'. Available providers: {available_providers}",
+            )
+
+        service_class = providers[config.provider]
+
+        try:
+            # Create service instance with configuration parameters
+            return service_class(**config.config)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to create {service_type} service with provider "
+                f"'{config.provider}': {e}",
+            ) from e
+
+    @classmethod
+    def register_service(
+        cls,
+        service_type: ServiceType,
+        provider: ServiceProvider,
+        service_class: Type,
+    ):
+        """Register a new service implementation.
+
+        Args:
+            service_type: Type of service
+            provider: Service provider
+            service_class: Implementation class
+        """
+        cls._populate_registry()
+
+        if service_type not in cls._service_registry:
+            cls._service_registry[service_type] = {}
+
+        cls._service_registry[service_type][provider] = service_class
+
+    @classmethod
+    def create_services_from_config(
+        cls,
+        config: ServicesConfig,
+    ) -> Dict[str, Any]:
+        """Create all services from a services configuration.
+
+        Args:
+            config: Services configuration
+
+        Returns:
+            Dict mapping service names to service instances
+
+        Raises:
+            RuntimeError: If any required service creation fails
+        """
+        services = {}
+
+        # Create required services
+        try:
+            services["memory"] = cls.create_service(
+                ServiceType.MEMORY,
+                config.memory,
+            )
+            services["session_history"] = cls.create_service(
+                ServiceType.SESSION_HISTORY,
+                config.session_history,
+            )
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to create required services: {e}",
+            ) from e
+
+        # Create optional services
+        if config.sandbox:
+            try:
+                services["sandbox"] = cls.create_service(
+                    ServiceType.SANDBOX,
+                    config.sandbox,
+                )
+            except Exception as e:
+                # Log warning but don't fail
+                print(f"Warning: Failed to create sandbox service: {e}")
+
+        if config.rag:
+            try:
+                services["rag"] = cls.create_service(
+                    ServiceType.RAG,
+                    config.rag,
+                )
+            except Exception as e:
+                # Log warning but don't fail
+                print(f"Warning: Failed to create RAG service: {e}")
+
+        return services
+
+    @classmethod
+    def get_available_providers(cls, service_type: ServiceType) -> list:
+        """Get list of available providers for a service type.
+
+        Args:
+            service_type: Type of service
+
+        Returns:
+            List of available provider names
+        """
+        cls._populate_registry()
+
+        if service_type not in cls._service_registry:
+            return []
+
+        return list(cls._service_registry[service_type].keys())