agentscope-runtime 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

agentscope_runtime/sandbox/manager/sandbox_manager.py

@@ -2,40 +2,37 @@
 # pylint: disable=redefined-outer-name, protected-access, too-many-branches
 import logging
 import os
+import json
 import secrets
 import inspect
-import socket
 import traceback
 
 from functools import wraps
 from typing import Optional, Dict
-from uuid import uuid4
+from urllib.parse import urlparse, urlunparse
 
+import shortuuid
 import requests
 
 from ..model import (
     ContainerModel,
     SandboxManagerEnvConfig,
-    DEFAULT_LOCAL_MANAGER_CONFIG,
 )
 from ..enums import SandboxType
 from ..registry import SandboxRegistry
 from ..client import SandboxHttpClient, TrainingSandboxClient
 
-from ..manager.utils import is_port_available, sweep_port
 from ..manager.collections import (
     RedisMapping,
-    RedisSetCollection,
     RedisQueue,
     InMemoryMapping,
     InMemoryQueue,
-    InMemorySetCollection,
 )
 from ..manager.storage import (
     LocalStorage,
     OSSStorage,
 )
-from ..manager.container_clients import DockerClient
+from ..manager.container_clients import DockerClient, KubernetesClient
 from ..constant import BROWSER_SESSION_ID
 
 logging.basicConfig(level=logging.INFO)
@@ -85,7 +82,7 @@ def remote_wrapper(
 class SandboxManager:
     def __init__(
         self,
-        config: SandboxManagerEnvConfig = DEFAULT_LOCAL_MANAGER_CONFIG,
+        config: Optional[SandboxManagerEnvConfig] = None,
         base_url=None,
         bearer_token=None,
         default_type: SandboxType | str = SandboxType.BASE,
@@ -100,19 +97,28 @@ class SandboxManager:
                 self.http_session.headers.update(
                     {"Authorization": f"Bearer {bearer_token}"},
                 )
+            # Remote mode, return directly
+            return
         else:
             self.http_session = None
             self.base_url = None
 
+        if not config:
+            config = SandboxManagerEnvConfig(
+                file_system="local",
+                redis_enabled=False,
+                container_deployment="docker",
+                pool_size=0,
+                default_mount_dir="sessions_mount_dir",
+            )
+
         self.default_type = SandboxType(default_type)
         self.workdir = "/workspace"
 
         self.config = config
         self.pool_size = self.config.pool_size
         self.prefix = self.config.container_prefix_key
-        self.default_mount_dir = (
-            self.config.default_mount_dir or "sessions_mount_dir"
-        )
+        self.default_mount_dir = self.config.default_mount_dir
         self.storage_folder = (
             self.config.storage_folder or self.default_mount_dir
         )
@@ -136,32 +142,26 @@ class SandboxManager:
                 ) from e
 
             self.container_mapping = RedisMapping(redis_client)
-            self.port_set = RedisSetCollection(
-                redis_client,
-                set_name=self.config.redis_port_key,
-            )
             self.pool_queue = RedisQueue(
                 redis_client,
                 self.config.redis_container_pool_key,
             )
         else:
             self.container_mapping = InMemoryMapping()
-            self.port_set = InMemorySetCollection()
             self.pool_queue = InMemoryQueue()
 
         self.container_deployment = self.config.container_deployment
 
         if base_url is None:
             if self.container_deployment == "docker":
-                self.client = DockerClient()
+                self.client = DockerClient(config=self.config)
+            elif self.container_deployment == "k8s":
+                self.client = KubernetesClient(config=self.config)
             else:
-                # TODO: support k8s deployment
                 raise NotImplementedError("Not implemented")
         else:
             self.client = None
 
-        self.port_range = range(*self.config.port_range)
-
         self.file_system = self.config.file_system
         if self.file_system == "oss":
             self.storage = OSSStorage(
@@ -207,8 +207,35 @@ class SandboxManager:
         try:
             response.raise_for_status()
         except requests.exceptions.HTTPError as e:
-            logger.error(f"Error making request: {e}")
-            return {"data": f"Error: {e}"}
+            error_components = [
+                f"HTTP {response.status_code} Error: {str(e)}",
+            ]
+
+            try:
+                server_response = response.json()
+                if "detail" in server_response:
+                    error_components.append(
+                        f"Server Detail: {server_response['detail']}",
+                    )
+                elif "error" in server_response:
+                    error_components.append(
+                        f"Server Error: {server_response['error']}",
+                    )
+                else:
+                    error_components.append(
+                        f"Server Response: {server_response}",
+                    )
+            except (ValueError, json.JSONDecodeError):
+                if response.text:
+                    error_components.append(
+                        f"Server Response: {response.text}",
+                    )
+
+            error = " | ".join(error_components)
+
+            logger.error(f"Error making request: {error}")
+
+            return {"data": f"Error: {error}"}
 
         return response.json()
 
@@ -235,34 +262,6 @@ class SandboxManager:
                 logger.error(f"Error initializing runtime pool: {e}")
                 break
 
-    def _find_free_ports(self, n):
-        free_ports = []
-
-        for port in self.port_range:
-            if len(free_ports) >= n:
-                break  # We have found enough ports
-
-            if not self.port_set.add(port):
-                continue
-
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                try:
-                    s.bind(("", port))
-                    free_ports.append(port)  # Port is available
-
-                except OSError:
-                    # Bind failed, port is in use
-                    self.port_set.remove(port)
-                    # Try the next one
-                    continue
-
-        if len(free_ports) < n:
-            raise RuntimeError(
-                "Not enough free ports available in the specified range.",
-            )
-
-        return free_ports
-
     @remote_wrapper()
     def cleanup(self):
         logger.debug(
@@ -414,22 +413,28 @@ class SandboxManager:
                 )
                 return None
 
-        session_id = str(uuid4())
+        alphabet = "0123456789abcdefghijklmnopqrstuvwxyz"
+        short_uuid = shortuuid.ShortUUID(alphabet=alphabet).uuid()
+        session_id = str(short_uuid)
 
-        if mount_dir is None:
-            mount_dir = os.path.join(self.default_mount_dir, session_id)
-            os.makedirs(mount_dir, exist_ok=True)
+        if not mount_dir:
+            if self.default_mount_dir:
+                mount_dir = os.path.join(self.default_mount_dir, session_id)
+                os.makedirs(mount_dir, exist_ok=True)
 
-        if not os.path.isabs(mount_dir):
-            mount_dir = os.path.abspath(mount_dir)
+        if mount_dir:
+            if not os.path.isabs(mount_dir):
+                mount_dir = os.path.abspath(mount_dir)
 
         if storage_path is None:
-            storage_path = self.storage.path_join(
-                self.storage_folder,
-                session_id,
-            )
+            if self.storage_folder:
+                storage_path = self.storage.path_join(
+                    self.storage_folder,
+                    session_id,
+                )
 
-        self.storage.download_folder(storage_path, mount_dir)
+        if mount_dir and storage_path:
+            self.storage.download_folder(storage_path, mount_dir)
 
         try:
             # Check for an existing container with the same name
@@ -439,34 +444,33 @@ class SandboxManager:
                     f"Container with name {container_name} already exists.",
                 )
 
-            free_ports = self._find_free_ports(1)
-
-            ports = {
-                "80/tcp": free_ports[0],  # nginx
-            }
-
             # Generate a random secret token
             runtime_token = secrets.token_hex(16)
 
             # Prepare volume bindings if a mount directory is provided
-            volume_bindings = {
-                mount_dir: {
-                    "bind": self.workdir,
-                    "mode": "rw",
-                },
-            }
+            if mount_dir:
+                volume_bindings = {
+                    mount_dir: {
+                        "bind": self.workdir,
+                        "mode": "rw",
+                    },
+                }
+            else:
+                volume_bindings = {}
 
-            if not self.client.create(
+            _id, ports, ip = self.client.create(
                 image,
                 name=container_name,
-                ports=ports,
+                ports=["80/tcp"],  # Nginx
                 volumes=volume_bindings,
                 environment={
                     "SECRET_TOKEN": runtime_token,
                     **environment,
                 },
                 runtime_config=config.runtime_config,
-            ):
+            )
+
+            if _id is None:
                 return None
 
             # Check the container status
@@ -478,24 +482,22 @@ class SandboxManager:
                 )
                 return None
 
-            # Build the ContainerModel
-            container_attrs = self.client.inspect(container_name)
-
+            # TODO: update ContainerModel according to images & backend
             container_model = ContainerModel(
                 session_id=session_id,
-                container_id=container_attrs["Id"],  # Docker id pattern
+                container_id=_id,
                 container_name=container_name,
-                base_url=f"http://localhost:{ports['80/tcp']}/fastapi",
-                browser_url=f"http://localhost:{ports['80/tcp']}/steel-api"
+                base_url=f"http://{ip}:{ports[0]}/fastapi",
+                browser_url=f"http://{ip}:{ports[0]}/steel-api"
                 f"/{runtime_token}",
-                front_browser_ws=f"ws://localhost:"
-                f"{ports['80/tcp']}/steel-api/"
+                front_browser_ws=f"ws://{ip}:"
+                f"{ports[0]}/steel-api/"
                 f"{runtime_token}/v1/sessions/cast",
-                client_browser_ws=f"ws://localhost:"
-                f"{ports['80/tcp']}/steel-api/{runtime_token}/&sessionId"
+                client_browser_ws=f"ws://{ip}:"
+                f"{ports[0]}/steel-api/{runtime_token}/&sessionId"
                 f"={BROWSER_SESSION_ID}",
-                artifacts_sio=f"http://localhost" f":{ports['80/tcp']}/v1",
-                ports=free_ports,
+                artifacts_sio=f"http://{ip}:{ports[0]}/v1",
+                ports=[ports[0]],
                 mount_dir=str(mount_dir),
                 storage_path=storage_path,
                 runtime_token=runtime_token,
@@ -537,17 +539,14 @@ class SandboxManager:
             self.client.stop(container_info.container_id, timeout=1)
             self.client.remove(container_info.container_id, force=True)
 
-            # Release ports after the container is removed
-            for port in container_info.ports:
-                self.port_set.remove(port)
-
             logger.debug(f"Container for {identity} destroyed.")
 
             # Upload to storage
-            self.storage.upload_folder(
-                container_info.mount_dir,
-                container_info.storage_path,
-            )
+            if container_info.mount_dir and container_info.storage_path:
+                self.storage.upload_folder(
+                    container_info.mount_dir,
+                    container_info.storage_path,
+                )
 
             return True
         except Exception as e:
@@ -570,14 +569,6 @@ class SandboxManager:
 
             container_info = ContainerModel(**container_json)
 
-            # Check whether the ports are occupied by other processes
-            for port in container_info.ports:
-                if is_port_available(port):
-                    continue
-
-                # If the port is occupied, sweep it
-                sweep_port(port)
-
             self.client.start(container_info.container_id)
             status = self.client.get_status(container_info.container_id)
             if status != "running":
@@ -653,9 +644,24 @@ class SandboxManager:
         enable_browser = "browser" in container_model.version
 
         # TODO: remake docker name
-        if "appworld" in container_model.version:
+        if (
+            "sandbox-appworld" in container_model.version
+            or "sandbox-bfcl" in container_model.version
+        ):
+            parsed = urlparse(container_model.base_url)
+            base_url = urlunparse(
+                (
+                    parsed.scheme,
+                    parsed.netloc,
+                    "",
+                    "",
+                    "",
+                    "",
+                ),
+            )
+
             return TrainingSandboxClient(
-                base_url=f"http://localhost:{container_model.ports[0]}",
+                base_url=base_url,
             ).__enter__()
 
         return SandboxHttpClient(
@@ -685,10 +691,3 @@ class SandboxManager:
             server_configs=server_configs,
             overwrite=overwrite,
         )
-
-
-if __name__ == "__main__":
-    with SandboxManager() as manager:
-        name = manager.create("12345")
-        if name:
-            print(f"Created container: {name}")

agentscope_runtime/sandbox/manager/server/app.py

@@ -2,14 +2,15 @@
 # pylint: disable=protected-access, unused-argument
 import inspect
 import logging
-import traceback
+
+from typing import Optional
 
 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.config import get_settings
 from ...manager.server.models import (
     ErrorResponse,
     HealthResponse,
@@ -42,34 +43,47 @@ app.add_middleware(
 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,
-)
+_runtime_manager: Optional[SandboxManager] = None
+_config: Optional[SandboxManagerEnvConfig] = None
+
+
+def get_config() -> SandboxManagerEnvConfig:
+    """Return config"""
+    global _config
+    if _config is None:
+        settings = get_settings()
+        _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,
+            k8s_namespace=settings.K8S_NAMESPACE,
+            kubeconfig_path=settings.KUBECONFIG_PATH,
+        )
+    return _config
 
 
 def verify_token(
     credentials: HTTPAuthorizationCredentials = Depends(security),
 ):
     """Verify Bearer token"""
+    settings = get_settings()
+
     if not hasattr(settings, "BEARER_TOKEN") or not settings.BEARER_TOKEN:
         logger.warning("BEARER_TOKEN not configured, skipping authentication")
         return credentials
@@ -98,8 +112,10 @@ def get_runtime_manager():
     """Get or create the global SandboxManager instance"""
     global _runtime_manager
     if _runtime_manager is None:
+        settings = get_settings()
+        config = get_config()
         _runtime_manager = SandboxManager(
-            config=_config,
+            config=config,
             default_type=settings.DEFAULT_SANDBOX_TYPE,
         )
     return _runtime_manager
@@ -120,11 +136,12 @@ def create_endpoint(method):
                 return JSONResponse(content={"data": result.model_dump_json()})
             return JSONResponse(content={"data": result})
         except Exception as e:
-            logger.error(
+            error = (
                 f"Error in {method.__name__}: {str(e)},"
-                f" {traceback.format_exc()}",
+                # f" {traceback.format_exc()}"
             )
-            raise HTTPException(status_code=500, detail=str(e)) from e
+            logger.error(error)
+            raise HTTPException(status_code=500, detail=error) from e
 
     return endpoint
 
@@ -159,6 +176,7 @@ async def startup_event():
 async def shutdown_event():
     """Cleanup resources on shutdown"""
     global _runtime_manager
+    settings = get_settings()
     if _runtime_manager and settings.AUTO_CLEANUP:
         _runtime_manager.cleanup()
         _runtime_manager = None
@@ -177,10 +195,60 @@ async def health_check():
     )
 
 
+def setup_logging(log_level: str):
+    """Setup logging configuration based on log level"""
+    # Convert string to logging level
+    level_mapping = {
+        "DEBUG": logging.DEBUG,
+        "INFO": logging.INFO,
+        "WARNING": logging.WARNING,
+        "ERROR": logging.ERROR,
+        "CRITICAL": logging.CRITICAL,
+    }
+
+    level = level_mapping.get(log_level.upper(), logging.INFO)
+
+    # Reconfigure logging
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        force=True,  # This will reconfigure existing loggers
+    )
+
+    # Update the logger for this module
+    global logger
+    logger.setLevel(level)
+
+    logger.info(f"Logging level set to {log_level.upper()}")
+
+
 def main():
     """Main entry point for the Runtime Manager Service"""
+    import argparse
+    import os
     import uvicorn
 
+    parser = argparse.ArgumentParser(description="Runtime Manager Service")
+    parser.add_argument("--config", type=str, help="Path to config file")
+    parser.add_argument(
+        "--log-level",
+        type=str,
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="INFO",
+        help="Set the logging level (default: INFO)",
+    )
+    args = parser.parse_args()
+
+    # Setup logging based on command line argument
+    setup_logging(args.log_level)
+
+    if args.config and not os.path.exists(args.config):
+        raise FileNotFoundError(
+            f"Error: Config file {args.config} does not exist",
+        )
+
+    settings = get_settings(args.config)
+
     uvicorn.run(
         "agentscope_runtime.sandbox.manager.server.app:app",
         host=settings.HOST,

agentscope_runtime/sandbox/manager/server/config.py

@@ -2,18 +2,9 @@
 import os
 from typing import Optional, Tuple, Literal
 from pydantic_settings import BaseSettings
-from pydantic import field_validator
+from pydantic import field_validator, ConfigDict
 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"""
@@ -27,11 +18,10 @@ class Settings(BaseSettings):
 
     # 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"
+    CONTAINER_DEPLOYMENT: Literal["docker", "cloud", "k8s"] = "docker"
     DEFAULT_MOUNT_DIR: str = "sessions_mount_dir"
     STORAGE_FOLDER: str = "runtime_sandbox_storage"
     PORT_RANGE: Tuple[int, int] = (49152, 59152)
@@ -53,9 +43,14 @@ class Settings(BaseSettings):
     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
+    # K8S settings
+    K8S_NAMESPACE: str = "default"
+    KUBECONFIG_PATH: Optional[str] = None
+
+    model_config = ConfigDict(
+        case_sensitive=True,
+        extra="allow",
+    )
 
     @field_validator("WORKERS", mode="before")
     @classmethod
@@ -65,4 +60,21 @@ class Settings(BaseSettings):
         return value
 
 
-settings = Settings()
+_settings: Optional[Settings] = None
+
+
+def get_settings(config_file: Optional[str] = None) -> Settings:
+    global _settings
+
+    env_file = ".env"
+    env_example_file = ".env.example"
+
+    if _settings is None:
+        if config_file and os.path.exists(config_file):
+            load_dotenv(config_file, override=True)
+        elif os.path.exists(env_file):
+            load_dotenv(env_file)
+        elif os.path.exists(env_example_file):
+            load_dotenv(env_example_file)
+        _settings = Settings()
+    return _settings

agentscope_runtime/sandbox/model/__init__.py

@@ -1,12 +1,8 @@
 # -*- coding: utf-8 -*-
 from .container import ContainerModel
-from .manager_config import (
-    SandboxManagerEnvConfig,
-    DEFAULT_LOCAL_MANAGER_CONFIG,
-)
+from .manager_config import SandboxManagerEnvConfig
 
 __all__ = [
     "ContainerModel",
     "SandboxManagerEnvConfig",
-    "DEFAULT_LOCAL_MANAGER_CONFIG",
 ]

agentscope_runtime/sandbox/model/container.py

@@ -4,7 +4,6 @@ from typing import List
 from pydantic import BaseModel, Field
 
 
-# TODO: support k8s version
 class ContainerModel(BaseModel):
     session_id: str = Field(
         ...,
@@ -70,3 +69,6 @@ class ContainerModel(BaseModel):
         None,
         description="Image version of the container",
     )
+
+    class Config:
+        extra = "allow"