agentscope-runtime 0.1.0__py3-none-any.whl

agentscope_runtime/sandbox/manager/server/app.py

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=protected-access, unused-argument
+import inspect
+import logging
+import traceback
+
+from fastapi import FastAPI, HTTPException, Request, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+from ...manager.server.config import settings
+from ...manager.server.models import (
+    ErrorResponse,
+    HealthResponse,
+)
+from ...manager.sandbox_manager import SandboxManager
+from ...model.manager_config import SandboxManagerEnvConfig
+from ....version import __version__
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create FastAPI app
+app = FastAPI(
+    title="Runtime Manager Service",
+    description="Service for managing runtime containers",
+    version=__version__,
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Security scheme
+security = HTTPBearer(auto_error=False)
+
+# Global SandboxManager instance
+_runtime_manager = None
+_config = SandboxManagerEnvConfig(
+    container_prefix_key=settings.CONTAINER_PREFIX_KEY,
+    file_system=settings.FILE_SYSTEM,
+    redis_enabled=settings.REDIS_ENABLED,
+    container_deployment=settings.CONTAINER_DEPLOYMENT,
+    default_mount_dir=settings.DEFAULT_MOUNT_DIR,
+    storage_folder=settings.STORAGE_FOLDER,
+    port_range=settings.PORT_RANGE,
+    pool_size=settings.POOL_SIZE,
+    oss_endpoint=settings.OSS_ENDPOINT,
+    oss_access_key_id=settings.OSS_ACCESS_KEY_ID,
+    oss_access_key_secret=settings.OSS_ACCESS_KEY_SECRET,
+    oss_bucket_name=settings.OSS_BUCKET_NAME,
+    redis_server=settings.REDIS_SERVER,
+    redis_port=settings.REDIS_PORT,
+    redis_db=settings.REDIS_DB,
+    redis_user=settings.REDIS_USER,
+    redis_password=settings.REDIS_PASSWORD,
+    redis_port_key=settings.REDIS_PORT_KEY,
+    redis_container_pool_key=settings.REDIS_CONTAINER_POOL_KEY,
+)
+
+
+def verify_token(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+):
+    """Verify Bearer token"""
+    if not hasattr(settings, "BEARER_TOKEN") or not settings.BEARER_TOKEN:
+        logger.warning("BEARER_TOKEN not configured, skipping authentication")
+        return credentials
+
+    if credentials is None:
+        logger.error("Authentication required but no token provided")
+        raise HTTPException(
+            status_code=401,
+            detail="Authentication required",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    if credentials.credentials != settings.BEARER_TOKEN:
+        logger.error(
+            f"Invalid token provided: {credentials.credentials[:10]}...",
+        )
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return credentials
+
+
+def get_runtime_manager():
+    """Get or create the global SandboxManager instance"""
+    global _runtime_manager
+    if _runtime_manager is None:
+        _runtime_manager = SandboxManager(
+            config=_config,
+            default_type=settings.DEFAULT_SANDBOX_TYPE,
+        )
+    return _runtime_manager
+
+
+def create_endpoint(method):
+    async def endpoint(
+        request: Request,
+        token: HTTPAuthorizationCredentials = Depends(verify_token),
+    ):
+        try:
+            data = await request.json()
+            logger.info(
+                f"Calling {method.__name__} with data: {data}",
+            )
+            result = method(**data)
+            if hasattr(result, "model_dump_json"):
+                return JSONResponse(content={"data": result.model_dump_json()})
+            return JSONResponse(content={"data": result})
+        except Exception as e:
+            logger.error(
+                f"Error in {method.__name__}: {str(e)},"
+                f" {traceback.format_exc()}",
+            )
+            raise HTTPException(status_code=500, detail=str(e)) from e
+
+    return endpoint
+
+
+def register_routes(_app, instance):
+    for _, method in inspect.getmembers(
+        instance,
+        predicate=inspect.ismethod,
+    ):
+        if getattr(method, "_is_remote_wrapper", False):
+            http_method = method._http_method.lower()
+            path = method._path
+
+            endpoint = create_endpoint(method)
+
+            if http_method == "get":
+                _app.get(path)(endpoint)
+            elif http_method == "post":
+                _app.post(path)(endpoint)
+            elif http_method == "delete":
+                _app.delete(path)(endpoint)
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the SandboxManager on startup"""
+    get_runtime_manager()
+    register_routes(app, _runtime_manager)
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup resources on shutdown"""
+    global _runtime_manager
+    if _runtime_manager and settings.AUTO_CLEANUP:
+        _runtime_manager.cleanup()
+        _runtime_manager = None
+
+
+@app.get(
+    "/health",
+    response_model=HealthResponse,
+    responses={500: {"model": ErrorResponse}},
+)
+async def health_check():
+    """Health check endpoint"""
+    return HealthResponse(
+        status="healthy",
+        version=_runtime_manager.default_type.value,
+    )
+
+
+def main():
+    """Main entry point for the Runtime Manager Service"""
+    import uvicorn
+
+    uvicorn.run(
+        "agentscope_runtime.sandbox.manager.server.app:app",
+        host=settings.HOST,
+        port=settings.PORT,
+        workers=settings.WORKERS,
+        reload=settings.DEBUG,
+    )
+
+
+if __name__ == "__main__":
+    main()

agentscope_runtime/sandbox/manager/server/config.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+import os
+from typing import Optional, Tuple, Literal
+from pydantic_settings import BaseSettings
+from pydantic import field_validator
+from dotenv import load_dotenv
+
+env_file = ".env"
+env_example_file = ".env.example"
+
+# Load the appropriate .env file
+if os.path.exists(env_file):
+    load_dotenv(env_file)
+elif os.path.exists(env_example_file):
+    load_dotenv(env_example_file)
+
+
+class Settings(BaseSettings):
+    """Runtime Manager Service Settings"""
+
+    # Service settings
+    HOST: str = "127.0.0.1"
+    PORT: int = 8000
+    WORKERS: int = 1
+    DEBUG: bool = False
+    BEARER_TOKEN: Optional[str] = None
+
+    # Runtime Manager settings
+    DEFAULT_SANDBOX_TYPE: str = "base"
+    WORKDIR: str = "/workspace"
+    POOL_SIZE: int = 1
+    AUTO_CLEANUP: bool = True
+    CONTAINER_PREFIX_KEY: str = "runtime_sandbox_container_"
+    CONTAINER_DEPLOYMENT: Literal["docker", "cloud"] = "docker"
+    DEFAULT_MOUNT_DIR: str = "sessions_mount_dir"
+    STORAGE_FOLDER: str = "runtime_sandbox_storage"
+    PORT_RANGE: Tuple[int, int] = (49152, 59152)
+
+    # Redis settings
+    REDIS_ENABLED: bool = False
+    REDIS_SERVER: str = "localhost"
+    REDIS_PORT: int = 6379
+    REDIS_DB: int = 0
+    REDIS_USER: Optional[str] = None
+    REDIS_PASSWORD: Optional[str] = None
+    REDIS_PORT_KEY: str = "_runtime_sandbox_container_occupied_ports"
+    REDIS_CONTAINER_POOL_KEY: str = "_runtime_sandbox_container_container_pool"
+
+    # OSS settings
+    FILE_SYSTEM: Literal["local", "oss"] = "local"
+    OSS_ENDPOINT: str = "http://oss-cn-hangzhou.aliyuncs.com"
+    OSS_ACCESS_KEY_ID: str = "your-access-key-id"
+    OSS_ACCESS_KEY_SECRET: str = "your-access-key-secret"
+    OSS_BUCKET_NAME: str = "your-bucket-name"
+
+    class Config:
+        env_file = env_file if os.path.exists(env_file) else env_example_file
+        case_sensitive = True
+
+    @field_validator("WORKERS", mode="before")
+    @classmethod
+    def validate_workers(cls, value, info):
+        if not info.data.get("REDIS_ENABLED", False):
+            return 1
+        return value
+
+
+settings = Settings()

agentscope_runtime/sandbox/manager/server/models.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+from typing import Optional
+from pydantic import BaseModel
+
+
+class ErrorResponse(BaseModel):
+    """Error response model"""
+
+    error: str
+    detail: Optional[str] = None
+
+
+class HealthResponse(BaseModel):
+    """Health check response model"""
+
+    status: str
+    version: str

agentscope_runtime/sandbox/manager/storage/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+from .data_storage import DataStorage
+from .local_storage import LocalStorage
+from .oss_storage import OSSStorage
+
+__all__ = [
+    "DataStorage",
+    "LocalStorage",
+    "OSSStorage",
+]

agentscope_runtime/sandbox/manager/storage/data_storage.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+import abc
+
+
+class DataStorage(abc.ABC):
+    @abc.abstractmethod
+    def download_folder(self, source_path, destination_path):
+        """Download a folder from storage to a local path."""
+
+    @abc.abstractmethod
+    def upload_folder(self, source_path, destination_path):
+        """Upload a local folder to storage."""
+
+    @abc.abstractmethod
+    def path_join(self, *args):
+        """Joins multiple path components into a single path string."""

agentscope_runtime/sandbox/manager/storage/local_storage.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+import os
+import shutil
+
+from .data_storage import DataStorage
+
+
+class LocalStorage(DataStorage):
+    def download_folder(self, source_path, destination_path):
+        """Copy a folder from source_path to destination_path."""
+        abs_source_path = os.path.abspath(source_path)
+        abs_destination_path = os.path.abspath(destination_path)
+
+        if abs_source_path == abs_destination_path:
+            return
+
+        if not os.path.exists(source_path):
+            return
+
+        # Ensure the destination path exists
+        os.makedirs(destination_path, exist_ok=True)
+
+        # Copy the directory structure and files
+        for root, _, files in os.walk(source_path):
+            relative_path = os.path.relpath(root, source_path)
+            dest_dir = os.path.join(destination_path, relative_path)
+
+            # Ensure the destination directory exists
+            os.makedirs(dest_dir, exist_ok=True)
+
+            # Copy files
+            for file in files:
+                src_file = os.path.join(root, file)
+                dest_file = os.path.join(dest_dir, file)
+                shutil.copy2(src_file, dest_file)
+
+    def upload_folder(self, source_path, destination_path):
+        """Copy a folder from source_path to destination_path."""
+        # This is essentially a symmetric operation of download_folder
+        self.download_folder(source_path, destination_path)
+
+    def path_join(self, *args):
+        """Join path components."""
+        return os.path.join(*args)

agentscope_runtime/sandbox/manager/storage/oss_storage.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+import os
+import hashlib
+import oss2
+
+from .data_storage import DataStorage
+
+
+def calculate_md5(file_path):
+    """Calculate the MD5 checksum of a file."""
+    with open(file_path, "rb") as f:
+        md5 = hashlib.md5()
+        while chunk := f.read(8192):
+            md5.update(chunk)
+    return md5.hexdigest()
+
+
+class OSSStorage(DataStorage):
+    def __init__(
+        self,
+        access_key_id,
+        access_key_secret,
+        endpoint,
+        bucket_name,
+    ):
+        self.auth = oss2.Auth(access_key_id, access_key_secret)
+        self.bucket = oss2.Bucket(self.auth, endpoint, bucket_name)
+
+    def download_folder(self, source_path, destination_path):
+        """Download a folder from OSS to the local filesystem."""
+        if not os.path.exists(destination_path):
+            os.makedirs(destination_path)
+
+        for obj in oss2.ObjectIterator(self.bucket, prefix=source_path):
+            local_path = os.path.join(
+                destination_path,
+                os.path.relpath(obj.key, source_path),
+            )
+
+            if obj.is_prefix():
+                # Create local directory
+                os.makedirs(local_path, exist_ok=True)
+            else:
+                # Download file
+                os.makedirs(os.path.dirname(local_path), exist_ok=True)
+                self.bucket.get_object_to_file(obj.key, local_path)
+
+    def upload_folder(self, source_path, destination_path):
+        """Upload a local folder to OSS."""
+        for root, dirs, files in os.walk(source_path):
+            # Upload directory structure
+            for d in dirs:
+                dir_path = os.path.join(root, d)
+                oss_dir_path = os.path.join(
+                    destination_path,
+                    os.path.relpath(dir_path, source_path),
+                )
+                # Maintain structure with an empty object
+                self.bucket.put_object(oss_dir_path + "/", b"")
+
+            # Upload files
+            for file in files:
+                local_file_path = os.path.join(root, file)
+                oss_file_path = os.path.join(
+                    destination_path,
+                    os.path.relpath(local_file_path, source_path),
+                )
+
+                local_md5 = calculate_md5(local_file_path)
+
+                try:
+                    oss_md5 = (
+                        self.bucket.head_object(oss_file_path)
+                        .headers["ETag"]
+                        .strip('"')
+                    )
+                except oss2.exceptions.NoSuchKey:
+                    oss_md5 = None
+
+                # Upload if MD5 does not match or file does not exist
+                if local_md5 != oss_md5:
+                    self.bucket.put_object_from_file(
+                        oss_file_path,
+                        local_file_path,
+                    )
+
+    def path_join(self, *args):
+        """Join path components for OSS."""
+        return "/".join(args)

agentscope_runtime/sandbox/manager/utils.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+import socket
+import subprocess
+import logging
+
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def is_port_available(port):
+    """
+    Check if a given port is available (not in use) on the local system.
+
+    Args:
+        port (int): The port number to check.
+
+    Returns:
+        bool: True if the port is available, False if it is in use.
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            s.bind(("", port))
+            # Port is available
+            return True
+        except OSError:
+            # Port is in use
+            return False
+
+
+def sweep_port(port):
+    """
+    Sweep all processes found listening on a given port.
+
+    Args:
+        port (int): The port number.
+
+    Returns:
+        int: Number of processes swept (terminated).
+    """
+    try:
+        # Use lsof to find the processes using the port
+        result = subprocess.run(
+            ["lsof", "-i", f":{port}"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        # Parse the output
+        lines = result.stdout.strip().split("\n")
+        if len(lines) <= 1:
+            # No process is using the port
+            return 0
+
+        # Iterate over each line (excluding the header) and kill each process
+        killed_count = 0
+        for line in lines[1:]:
+            parts = line.split()
+            if len(parts) > 1:
+                pid = parts[1]
+
+                # Kill the process using the PID
+                subprocess.run(["kill", "-9", pid], check=False)
+                killed_count += 1
+
+        if not is_port_available(port):
+            logger.warning(
+                f"Port {port} is still in use after killing processes.",
+            )
+
+        return True
+
+    except Exception as e:
+        logger.error(
+            f"An error occurred while killing processes on port {port}: {e}",
+        )
+        return False