agentscope-runtime 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

agentscope_runtime/sandbox/manager/container_clients/docker_client.py

@@ -1,14 +1,17 @@
 # -*- coding: utf-8 -*-
 import traceback
 import logging
-import platform
 import socket
-import subprocess
 
 import docker
 
 from .base_client import BaseClient
-from ..collections import RedisSetCollection, InMemorySetCollection
+from ..collections import (
+    RedisSetCollection,
+    InMemorySetCollection,
+    RedisMapping,
+    InMemoryMapping,
+)
 
 
 logger = logging.getLogger(__name__)
@@ -34,138 +37,6 @@ def is_port_available(port):
             return False
 
 
-def sweep_port(port):
-    """Sweep all processes found listening on a given port.
-
-    Args:
-        port (int): The port number.
-
-    Returns:
-        bool: True if successful, False if failed.
-    """
-    try:
-        system = platform.system().lower()
-        if system == "windows":
-            return _sweep_port_windows(port)
-        else:
-            return _sweep_port_unix(port)
-    except Exception as e:
-        logger.error(
-            f"An error occurred while killing processes on port {port}: {e}",
-        )
-        return False
-
-
-def _sweep_port_unix(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
-        # TODO: support windows
-        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 True
-
-        # 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
-
-
-def _sweep_port_windows(port):
-    """
-    Windows implementation using netstat and taskkill
-    """
-    try:
-        # Use netstat to find the processes using the port
-        result = subprocess.run(
-            ["netstat", "-ano"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-
-        # Parse the output to find processes using the specific port
-        lines = result.stdout.strip().split("\n")
-        pids_to_kill = set()
-
-        for line in lines:
-            if f":{port}" in line and "LISTENING" in line:
-                parts = line.split()
-                if len(parts) >= 5:
-                    pid = parts[-1]  # PID is usually the last column
-                    if pid.isdigit():  # Ensure it's a valid PID
-                        pids_to_kill.add(pid)
-
-        if not pids_to_kill:
-            return True
-
-        # Kill the processes
-        killed_count = 0
-        for pid in pids_to_kill:
-            try:
-                result = subprocess.run(
-                    ["taskkill", "/PID", pid, "/F"],
-                    capture_output=True,
-                    text=True,
-                    check=False,
-                )
-                if result.returncode == 0:
-                    killed_count += 1
-            except Exception as e:
-                logger.debug(f"Failed to kill process {pid}: {e}")
-                continue
-
-        if not is_port_available(port):
-            logger.warning(
-                f"Port {port} is still in use after killing processes.",
-            )
-
-        return True
-
-    except subprocess.CalledProcessError as e:
-        logger.error(f"netstat command failed: {e}")
-        return False
-    except Exception as e:
-        logger.error(f"Error in Windows port sweep: {e}")
-        return False
-
-
 class DockerClient(BaseClient):
     def __init__(self, config=None):
         self.config = config
@@ -193,8 +64,13 @@ class DockerClient(BaseClient):
                 redis_client,
                 set_name=self.config.redis_port_key,
             )
+            self.ports_cache = RedisMapping(
+                redis_client,
+                prefix=self.config.redis_port_key,
+            )
         else:
             self.port_set = InMemorySetCollection()
+            self.ports_cache = InMemoryMapping()
 
         try:
             self.client = docker.from_env()
@@ -208,40 +84,6 @@ class DockerClient(BaseClient):
                 "export DOCKER_HOST=unix://$HOME/.colima/docker.sock",
             ) from e
 
-    def _try_pull_from_acr(self, image):
-        """
-        Attempt to pull the image from the Alibaba Cloud Container Registry
-        (ACR) and retag it.
-        """
-        try:
-            acr_registry = "agentscope-registry.ap-southeast-1.cr.aliyuncs.com"
-            acr_image = f"{acr_registry}/{image}"
-
-            logger.info(
-                f"Attempting to pull from ACR: {acr_image}, it might take "
-                f"several minutes.",
-            )
-            self.client.images.pull(acr_image)
-            logger.info(f"Successfully pulled image from ACR: {acr_image}")
-
-            # Retag the image
-            acr_img_obj = self.client.images.get(acr_image)
-            acr_img_obj.tag(image)
-            logger.debug(f"Successfully tagged image as: {image}")
-
-            # Optionally remove the original tag to save space
-            try:
-                self.client.images.remove(acr_image)
-                logger.debug(f"Removed original tag: {acr_image}")
-            except Exception as e:
-                logger.debug(f"Failed to remove original tag: {e}")
-            return True
-        except Exception as e:
-            logger.error(
-                f"Failed to pull from ACR: {e}, {traceback.format_exc()}",
-            )
-            return False
-
     def create(
         self,
         image,
@@ -279,22 +121,11 @@ class DockerClient(BaseClient):
                     )
                     self.client.images.pull(image)
                     logger.debug(
-                        f"Image '{image}' successfully pulled from default "
-                        f"registry.",
-                    )
-                    pull_success = True
-                except docker.errors.APIError as e:
-                    logger.warning(
-                        f"Failed to pull from default registry: {e}",
+                        f"Image '{image}' successfully pulled.",
                     )
-                    logger.warning("Trying to pull from ACR fallback...")
-
-                    pull_success = self._try_pull_from_acr(image)
-
-                if not pull_success:
+                except Exception as e:
                     logger.error(
-                        f"Failed to pull image '{image}' from both "
-                        f"default and ACR",
+                        f"Failed to pull image '{image}': {str(e)}",
                     )
                     return None, None, None
 
@@ -314,6 +145,9 @@ class DockerClient(BaseClient):
             )
             container.reload()
             _id = container.id
+
+            self.ports_cache.set(_id, list(port_mapping.values()))
+
             return _id, list(port_mapping.values()), "localhost"
         except Exception as e:
             logger.error(f"An error occurred: {e}, {traceback.format_exc()}")
@@ -326,16 +160,6 @@ class DockerClient(BaseClient):
                 container_id,
             )
 
-            # Check whether the ports are occupied by other processes
-            port_mapping = container.attrs["NetworkSettings"]["Ports"]
-            for _, mappings in port_mapping.items():
-                if mappings is not None:
-                    for mapping in mappings:
-                        host_port = int(mapping["HostPort"])
-                        if is_port_available(host_port):
-                            continue
-                        sweep_port(host_port["HostPort"])
-
             container.start()
             return True
         except Exception as e:
@@ -360,16 +184,16 @@ class DockerClient(BaseClient):
             container = self.client.containers.get(
                 container_id,
             )
-            # Remove ports
-            port_mapping = container.attrs["NetworkSettings"]["Ports"]
+            ports = self.ports_cache.get(container_id)
+            self.ports_cache.delete(container_id)
+
+            # Remove container
             container.remove(force=force)
 
-            # Iterate over each port and its mappings
-            for _, mappings in port_mapping.items():
-                if mappings is not None:
-                    for mapping in mappings:
-                        host_port = int(mapping["HostPort"])
-                        self.port_set.remove(host_port)
+            # Remove ports
+            if ports:
+                for host_port in ports:
+                    self.port_set.remove(host_port)
 
             return True
         except Exception as e:

agentscope_runtime/sandbox/manager/container_clients/kubernetes_client.py

@@ -92,11 +92,9 @@ class KubernetesClient(BaseClient):
         container_name = name or "main-container"
 
         # Container specification
-        # TODO: use image from docker registry first
         container = client.V1Container(
             name=container_name,
-            image=f"agentscope-registry.ap-southeast-1.cr.aliyuncs.com"
-            f"/{image}",
+            image=image,
             image_pull_policy=runtime_config.get(
                 "image_pull_policy",
                 "IfNotPresent",

agentscope_runtime/sandbox/manager/sandbox_manager.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
-# pylint: disable=redefined-outer-name, protected-access, too-many-branches
+# pylint: disable=redefined-outer-name, protected-access
+# pylint: disable=too-many-branches, too-many-statements
 import logging
 import os
 import json
@@ -14,6 +15,8 @@ from urllib.parse import urlparse, urlunparse
 import shortuuid
 import requests
 
+from .container_clients.docker_client import DockerClient
+from .container_clients.kubernetes_client import KubernetesClient
 from ..model import (
     ContainerModel,
     SandboxManagerEnvConfig,
@@ -32,7 +35,6 @@ from ..manager.storage import (
     LocalStorage,
     OSSStorage,
 )
-from ..manager.container_clients import DockerClient, KubernetesClient
 from ..constant import BROWSER_SESSION_ID
 
 logging.basicConfig(level=logging.INFO)
@@ -119,6 +121,7 @@ class SandboxManager:
         self.pool_size = self.config.pool_size
         self.prefix = self.config.container_prefix_key
         self.default_mount_dir = self.config.default_mount_dir
+        self.readonly_mounts = self.config.readonly_mounts
         self.storage_folder = (
             self.config.storage_folder or self.default_mount_dir
         )
@@ -157,6 +160,10 @@ class SandboxManager:
                 self.client = DockerClient(config=self.config)
             elif self.container_deployment == "k8s":
                 self.client = KubernetesClient(config=self.config)
+            elif self.container_deployment == "agentrun":
+                from .container_clients.agentrun_client import AgentRunClient
+
+                self.client = AgentRunClient(config=self.config)
             else:
                 raise NotImplementedError("Not implemented")
         else:
@@ -380,7 +387,7 @@ class SandboxManager:
     def create(
         self,
         sandbox_type=None,
-        mount_dir=None,
+        mount_dir=None,  # TODO: remove to avoid leaking
         storage_path=None,
         environment: Optional[Dict] = None,
     ):
@@ -422,7 +429,7 @@ class SandboxManager:
                 mount_dir = os.path.join(self.default_mount_dir, session_id)
                 os.makedirs(mount_dir, exist_ok=True)
 
-        if mount_dir:
+        if mount_dir and self.container_deployment != "agentrun":
             if not os.path.isabs(mount_dir):
                 mount_dir = os.path.abspath(mount_dir)
 
@@ -433,7 +440,11 @@ class SandboxManager:
                     session_id,
                 )
 
-        if mount_dir and storage_path:
+        if (
+            mount_dir
+            and storage_path
+            and self.container_deployment != "agentrun"
+        ):
             self.storage.download_folder(storage_path, mount_dir)
 
         try:
@@ -448,7 +459,7 @@ class SandboxManager:
             runtime_token = secrets.token_hex(16)
 
             # Prepare volume bindings if a mount directory is provided
-            if mount_dir:
+            if mount_dir and self.container_deployment != "agentrun":
                 volume_bindings = {
                     mount_dir: {
                         "bind": self.workdir,
@@ -458,7 +469,16 @@ class SandboxManager:
             else:
                 volume_bindings = {}
 
-            _id, ports, ip = self.client.create(
+            if self.readonly_mounts:
+                for host_path, container_path in self.readonly_mounts.items():
+                    if not os.path.isabs(host_path):
+                        host_path = os.path.abspath(host_path)
+                    volume_bindings[host_path] = {
+                        "bind": container_path,
+                        "mode": "ro",
+                    }
+
+            _id, ports, ip, *rest = self.client.create(
                 image,
                 name=container_name,
                 ports=["80/tcp"],  # Nginx
@@ -470,6 +490,12 @@ class SandboxManager:
                 runtime_config=config.runtime_config,
             )
 
+            http_protocol = "http"
+            ws_protocol = "ws"
+            if rest and rest[0] == "https":
+                http_protocol = "https"
+                ws_protocol = "wss"
+
             if _id is None:
                 return None
 
@@ -487,22 +513,23 @@ class SandboxManager:
                 session_id=session_id,
                 container_id=_id,
                 container_name=container_name,
-                base_url=f"http://{ip}:{ports[0]}/fastapi",
-                browser_url=f"http://{ip}:{ports[0]}/steel-api"
+                base_url=f"{http_protocol}://{ip}:{ports[0]}/fastapi",
+                browser_url=f"{http_protocol}://{ip}:{ports[0]}/steel-api"
                 f"/{runtime_token}",
-                front_browser_ws=f"ws://{ip}:"
+                front_browser_ws=f"{ws_protocol}://{ip}:"
                 f"{ports[0]}/steel-api/"
                 f"{runtime_token}/v1/sessions/cast",
-                client_browser_ws=f"ws://{ip}:"
+                client_browser_ws=f"{ws_protocol}://{ip}:"
                 f"{ports[0]}/steel-api/{runtime_token}/&sessionId"
                 f"={BROWSER_SESSION_ID}",
-                artifacts_sio=f"http://{ip}:{ports[0]}/v1",
+                artifacts_sio=f"{http_protocol}://{ip}:{ports[0]}/v1",
                 ports=[ports[0]],
                 mount_dir=str(mount_dir),
                 storage_path=storage_path,
                 runtime_token=runtime_token,
                 version=image,
             )
+
             # Register in mapping
             self.container_mapping.set(
                 container_model.container_name,
@@ -632,7 +659,7 @@ class SandboxManager:
                 self._generate_container_key(identity),
             )
         if container_model is None:
-            return None
+            raise RuntimeError(f"No container found with id: {identity}.")
         if hasattr(container_model, "model_dump_json"):
             container_model = container_model.model_dump_json()
 

agentscope_runtime/sandbox/manager/server/app.py

@@ -20,6 +20,7 @@ from ...manager.server.models import (
 )
 from ...manager.sandbox_manager import SandboxManager
 from ...model.manager_config import SandboxManagerEnvConfig
+from ...utils import dynamic_import
 from ....version import __version__
 
 # Configure logging
@@ -61,6 +62,7 @@ def get_config() -> SandboxManagerEnvConfig:
             redis_enabled=settings.REDIS_ENABLED,
             container_deployment=settings.CONTAINER_DEPLOYMENT,
             default_mount_dir=settings.DEFAULT_MOUNT_DIR,
+            readonly_mounts=settings.READONLY_MOUNTS,
             storage_folder=settings.STORAGE_FOLDER,
             port_range=settings.PORT_RANGE,
             pool_size=settings.POOL_SIZE,
@@ -77,6 +79,18 @@ def get_config() -> SandboxManagerEnvConfig:
             redis_container_pool_key=settings.REDIS_CONTAINER_POOL_KEY,
             k8s_namespace=settings.K8S_NAMESPACE,
             kubeconfig_path=settings.KUBECONFIG_PATH,
+            agent_run_access_key_id=settings.AGENT_RUN_ACCESS_KEY_ID,
+            agent_run_access_key_secret=settings.AGENT_RUN_ACCESS_KEY_SECRET,
+            agent_run_account_id=settings.AGENT_RUN_ACCOUNT_ID,
+            agent_run_region_id=settings.AGENT_RUN_REGION_ID,
+            agent_run_cpu=settings.AGENT_RUN_CPU,
+            agent_run_memory=settings.AGENT_RUN_MEMORY,
+            agent_run_vpc_id=settings.AGENT_RUN_VPC_ID,
+            agent_run_vswitch_ids=settings.AGENT_RUN_VSWITCH_IDS,
+            agent_run_security_group_id=settings.AGENT_RUN_SECURITY_GROUP_ID,
+            agent_run_prefix=settings.AGENT_RUN_PREFIX,
+            agentrun_log_project=settings.AGENT_RUN_LOG_PROJECT,
+            agentrun_log_store=settings.AGENT_RUN_LOG_STORE,
         )
     return _config
 
@@ -311,8 +325,21 @@ def main():
         default="INFO",
         help="Set the logging level (default: INFO)",
     )
+
+    parser.add_argument(
+        "--extension",
+        action="append",
+        help="Path to a Python file or module name to load as an extension",
+    )
+
     args = parser.parse_args()
 
+    if args.extension:
+        for ext in args.extension:
+            logger.info(f"Loading extension: {ext}")
+            mod = dynamic_import(ext)
+            logger.info(f"Extension loaded: {mod.__name__}")
+
     # Setup logging based on command line argument
     setup_logging(args.log_level)
 

agentscope_runtime/sandbox/manager/server/config.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 import os
-from typing import Optional, Tuple, Literal
+from typing import Optional, Tuple, Literal, Dict
 from pydantic_settings import BaseSettings
 from pydantic import field_validator, ConfigDict
 from dotenv import load_dotenv
@@ -21,8 +21,18 @@ class Settings(BaseSettings):
     POOL_SIZE: int = 1
     AUTO_CLEANUP: bool = True
     CONTAINER_PREFIX_KEY: str = "runtime_sandbox_container_"
-    CONTAINER_DEPLOYMENT: Literal["docker", "cloud", "k8s"] = "docker"
+    CONTAINER_DEPLOYMENT: Literal[
+        "docker",
+        "cloud",
+        "k8s",
+        "agentrun",
+    ] = "docker"
     DEFAULT_MOUNT_DIR: str = "sessions_mount_dir"
+    # Read-only mounts (host_path -> container_path)
+    # Example in .env:
+    # READONLY_MOUNTS={"\/opt\/shared": "\/mnt\/shared", "\/etc\/timezone":
+    # "\/etc\/timezone"}
+    READONLY_MOUNTS: Optional[Dict[str, str]] = None
     STORAGE_FOLDER: str = "runtime_sandbox_storage"
     PORT_RANGE: Tuple[int, int] = (49152, 59152)
 
@@ -47,6 +57,24 @@ class Settings(BaseSettings):
     K8S_NAMESPACE: str = "default"
     KUBECONFIG_PATH: Optional[str] = None
 
+    # AgentRun settings
+    AGENT_RUN_ACCOUNT_ID: Optional[str] = None
+    AGENT_RUN_ACCESS_KEY_ID: Optional[str] = None
+    AGENT_RUN_ACCESS_KEY_SECRET: Optional[str] = None
+    AGENT_RUN_REGION_ID: str = "cn-hangzhou"
+
+    AGENT_RUN_CPU: float = 2.0
+    AGENT_RUN_MEMORY: int = 2048
+
+    AGENT_RUN_VPC_ID: Optional[str] = None
+    AGENT_RUN_VSWITCH_IDS: Optional[list[str]] = None
+    AGENT_RUN_SECURITY_GROUP_ID: Optional[str] = None
+
+    AGENT_RUN_PREFIX: str = "agentscope-sandbox"
+
+    AGENT_RUN_LOG_PROJECT: Optional[str] = None
+    AGENT_RUN_LOG_STORE: Optional[str] = None
+
     model_config = ConfigDict(
         case_sensitive=True,
         extra="allow",

agentscope_runtime/sandbox/model/container.py

@@ -44,7 +44,7 @@ class ContainerModel(BaseModel):
         ...,
         description="Socketio URL for the artifacts used by frontend",
     )
-    ports: List[int] = Field(
+    ports: List[int | str] = Field(
         ...,
         description="List of occupied port numbers",
     )