agentscope-runtime 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

agentscope_runtime/{sandbox/manager → common}/container_clients/kubernetes_client.py

@@ -1,11 +1,12 @@
 # -*- coding: utf-8 -*-
-# pylint: disable=too-many-branches
-import os
+# pylint: disable=too-many-branches,too-many-statements
 import time
 import hashlib
 import traceback
 import logging
 
+from typing import Optional, Tuple
+
 from kubernetes import client
 from kubernetes import config as k8s_config
 from kubernetes.client.rest import ApiException
@@ -16,10 +17,15 @@ logger = logging.getLogger(__name__)
 
 
 class KubernetesClient(BaseClient):
-    def __init__(self, config=None):
+    def __init__(
+        self,
+        config=None,
+        image_registry: Optional[str] = None,
+    ):
         self.config = config
         namespace = self.config.k8s_namespace
         kubeconfig = self.config.kubeconfig_path
+        self.image_registry = image_registry
         try:
             if kubeconfig:
                 k8s_config.load_kube_config(config_file=kubeconfig)
@@ -31,6 +37,7 @@ class KubernetesClient(BaseClient):
                 except k8s_config.ConfigException:
                     k8s_config.load_kube_config()
             self.v1 = client.CoreV1Api()
+            self.apps_v1 = client.AppsV1Api()  # For Deployments
             self.namespace = namespace
             # Test connection
             self.v1.list_namespace()
@@ -45,6 +52,61 @@ class KubernetesClient(BaseClient):
                 "• For in-cluster: ensure proper RBAC permissions",
             ) from e
 
+    def _is_local_cluster(self):
+        """
+        Determine if we're connected to a local Kubernetes cluster.
+
+        Returns:
+            bool: True if connected to a local cluster, False otherwise
+        """
+        try:
+            # Get the current context configuration
+            contexts, current_context = k8s_config.list_kube_config_contexts(
+                config_file=self.config.kubeconfig_path
+                if hasattr(self.config, "kubeconfig_path")
+                and self.config.kubeconfig_path
+                else None,
+            )
+
+            if current_context and current_context.get("context"):
+                cluster_name = current_context["context"].get("cluster", "")
+                server = None
+
+                # Get cluster server URL
+                for cluster in contexts.get("clusters", []):
+                    if cluster["name"] == cluster_name:
+                        server = cluster.get("cluster", {}).get("server", "")
+                        break
+
+                if server:
+                    # Check for common local cluster patterns
+                    local_patterns = [
+                        "localhost",
+                        "127.0.0.1",
+                        "0.0.0.0",
+                        "docker-desktop",
+                        "kind-",  # kind clusters
+                        "minikube",  # minikube
+                        "k3d-",  # k3d clusters
+                        "colima",  # colima
+                    ]
+
+                    server_lower = server.lower()
+                    cluster_lower = cluster_name.lower()
+
+                    for pattern in local_patterns:
+                        if pattern in server_lower or pattern in cluster_lower:
+                            return True
+
+            return False
+
+        except Exception as e:
+            logger.debug(
+                f"Could not determine cluster type, assuming remote: {e}",
+            )
+            # If we can't determine, assume remote for safety
+            return False
+
     def _parse_port_spec(self, port_spec):
         """
         Parse port specification.
@@ -92,6 +154,9 @@ class KubernetesClient(BaseClient):
         container_name = name or "main-container"
 
         # Container specification
+        if self.image_registry:
+            image = f"{self.image_registry}/{image}"
+
         container = client.V1Container(
             name=container_name,
             image=image,
@@ -562,9 +627,8 @@ class KubernetesClient(BaseClient):
     def _get_pod_node_ip(self, pod_name):
         """Get the IP of the node where the pod is running"""
 
-        # Check if we are running in Colima, where pod runs in VM
-        docker_host = os.getenv("DOCKER_HOST", "")
-        if "colima" in docker_host.lower():
+        # Check if we are using a local Kubernetes cluster
+        if self._is_local_cluster():
             return "localhost"
 
         try:
@@ -601,3 +665,479 @@ class KubernetesClient(BaseClient):
         except Exception as e:
             logger.error(f"Failed to get pod node IP: {e}")
             return None
+
+    def _create_deployment_spec(
+        self,
+        image,
+        name,
+        ports=None,
+        volumes=None,
+        environment=None,
+        runtime_config=None,
+        replicas=1,
+    ):
+        """Create a Kubernetes Deployment specification."""
+        if runtime_config is None:
+            runtime_config = {}
+
+        container_name = name or "main-container"
+
+        # Use image registry if configured
+        if not self.image_registry:
+            full_image = image
+        else:
+            full_image = f"{self.image_registry}/{image}"
+
+        # Create container spec (reuse the existing pod spec logic)
+        container = client.V1Container(
+            name=container_name,
+            image=full_image,
+            image_pull_policy=runtime_config.get(
+                "image_pull_policy",
+                "IfNotPresent",
+            ),
+        )
+
+        # Configure ports
+        if ports:
+            container_ports = []
+            for port_spec in ports:
+                port_info = self._parse_port_spec(port_spec)
+                if port_info:
+                    container_ports.append(
+                        client.V1ContainerPort(
+                            container_port=port_info["port"],
+                            protocol=port_info["protocol"],
+                        ),
+                    )
+            if container_ports:
+                container.ports = container_ports
+
+        # Configure environment variables
+        if environment:
+            env_vars = []
+            for key, value in environment.items():
+                env_vars.append(client.V1EnvVar(name=key, value=str(value)))
+            container.env = env_vars
+
+        # Configure volume mounts and volumes
+        volume_mounts = []
+        pod_volumes = []
+        if volumes:
+            for volume_idx, (host_path, mount_info) in enumerate(
+                volumes.items(),
+            ):
+                if isinstance(mount_info, dict):
+                    container_path = mount_info["bind"]
+                    mode = mount_info.get("mode", "rw")
+                else:
+                    container_path = mount_info
+                    mode = "rw"
+                volume_name = f"vol-{volume_idx}"
+
+                # Create volume mount
+                volume_mounts.append(
+                    client.V1VolumeMount(
+                        name=volume_name,
+                        mount_path=container_path,
+                        read_only=(mode == "ro"),
+                    ),
+                )
+                # Create host path volume
+                pod_volumes.append(
+                    client.V1Volume(
+                        name=volume_name,
+                        host_path=client.V1HostPathVolumeSource(
+                            path=host_path,
+                        ),
+                    ),
+                )
+
+        if volume_mounts:
+            container.volume_mounts = volume_mounts
+
+        # Apply runtime config to container
+        if "resources" in runtime_config:
+            container.resources = client.V1ResourceRequirements(
+                **runtime_config["resources"],
+            )
+
+        if "security_context" in runtime_config:
+            container.security_context = client.V1SecurityContext(
+                **runtime_config["security_context"],
+            )
+
+        # Pod template specification
+        pod_spec = client.V1PodSpec(
+            containers=[container],
+            restart_policy=runtime_config.get(
+                "restart_policy",
+                "Always",
+            ),  # Deployments typically use Always
+        )
+
+        if pod_volumes:
+            pod_spec.volumes = pod_volumes
+
+        if "node_selector" in runtime_config:
+            pod_spec.node_selector = runtime_config["node_selector"]
+
+        if "tolerations" in runtime_config:
+            pod_spec.tolerations = runtime_config["tolerations"]
+
+        # Handle image pull secrets
+        image_pull_secrets = runtime_config.get("image_pull_secrets", [])
+        if image_pull_secrets:
+            secrets = []
+            for secret_name in image_pull_secrets:
+                secrets.append(client.V1LocalObjectReference(name=secret_name))
+            pod_spec.image_pull_secrets = secrets
+
+        # Pod template
+        pod_template = client.V1PodTemplateSpec(
+            metadata=client.V1ObjectMeta(
+                labels={
+                    "app": name,
+                    "created-by": "kubernetes-client",
+                },
+            ),
+            spec=pod_spec,
+        )
+
+        # Deployment specification
+        deployment_spec = client.V1DeploymentSpec(
+            replicas=replicas,
+            selector=client.V1LabelSelector(
+                match_labels={"app": name},
+            ),
+            template=pod_template,
+        )
+
+        return deployment_spec
+
+    def _create_loadbalancer_service(self, deployment_name, port_list):
+        """Create a LoadBalancer service for the deployment."""
+        try:
+            service_name = f"{deployment_name}-lb-service"
+            selector = {"app": deployment_name}
+
+            # Construct multi-port configuration
+            service_ports = []
+            for port_info in port_list:
+                port = port_info["port"]
+                protocol = port_info["protocol"]
+                service_ports.append(
+                    client.V1ServicePort(
+                        name=f"port-{port}",
+                        port=port,
+                        target_port=port,
+                        protocol=protocol,
+                    ),
+                )
+
+            service_spec = client.V1ServiceSpec(
+                selector=selector,
+                ports=service_ports,
+                type="LoadBalancer",
+            )
+
+            service = client.V1Service(
+                api_version="v1",
+                kind="Service",
+                metadata=client.V1ObjectMeta(
+                    name=service_name,
+                    namespace=self.namespace,
+                ),
+                spec=service_spec,
+            )
+
+            # Create the service
+            self.v1.create_namespaced_service(
+                namespace=self.namespace,
+                body=service,
+            )
+
+            logger.debug(
+                f"LoadBalancer service '{service_name}' created successfully",
+            )
+            return True, service_name
+        except Exception as e:
+            logger.error(
+                f"Failed to create LoadBalancer service for deployment "
+                f"{deployment_name}: "
+                f"{e}, {traceback.format_exc()}",
+            )
+            return False, None
+
+    def create_deployment(
+        self,
+        image,
+        name=None,
+        ports=None,
+        volumes=None,
+        environment=None,
+        runtime_config=None,
+        replicas=1,
+        create_service=True,
+    ) -> Tuple[str, list, str] | Tuple[None, None, None]:
+        """
+        Create a new Kubernetes Deployment with LoadBalancer service.
+
+        Args:
+            image: Container image name
+            name: Deployment name (auto-generated if None)
+            ports: List of ports to expose
+            volumes: Volume mounts dictionary
+            environment: Environment variables dictionary
+            runtime_config: Runtime configuration dictionary
+            replicas: Number of replicas for the deployment
+            create_service: Whether to create LoadBalancer service
+
+        Returns:
+            Tuple of (deployment_name, ports, load_balancer_ip)
+        """
+        if not name:
+            name = f"deploy-{hashlib.md5(image.encode()).hexdigest()[:8]}"
+
+        try:
+            # Create deployment specification
+            deployment_spec = self._create_deployment_spec(
+                image,
+                name,
+                ports,
+                volumes,
+                environment,
+                runtime_config,
+                replicas,
+            )
+
+            # Create deployment metadata
+            metadata = client.V1ObjectMeta(
+                name=name,
+                namespace=self.namespace,
+                labels={
+                    "created-by": "kubernetes-client",
+                    "app": name,
+                },
+            )
+
+            # Create deployment object
+            deployment = client.V1Deployment(
+                api_version="apps/v1",
+                kind="Deployment",
+                metadata=metadata,
+                spec=deployment_spec,
+            )
+
+            # Create the deployment
+            self.apps_v1.create_namespaced_deployment(
+                namespace=self.namespace,
+                body=deployment,
+            )
+
+            logger.debug(
+                f"Deployment '{name}' created successfully in namespace "
+                f"'{self.namespace}' with {replicas} replicas",
+            )
+
+            service_info = None
+            load_balancer_ip = None
+
+            # Create LoadBalancer service if requested and ports are specified
+            if create_service and ports:
+                parsed_ports = []
+                for port_spec in ports:
+                    port_info = self._parse_port_spec(port_spec)
+                    if port_info:
+                        parsed_ports.append(port_info)
+
+                if parsed_ports:
+                    (
+                        service_created,
+                        service_name,
+                    ) = self._create_loadbalancer_service(
+                        name,
+                        parsed_ports,
+                    )
+                    if service_created:
+                        service_info = {
+                            "name": service_name,
+                            "type": "LoadBalancer",
+                            "ports": [p["port"] for p in parsed_ports],
+                        }
+                        # Wait a bit and try to get LoadBalancer IP
+                        time.sleep(2)
+                        load_balancer_ip = self._get_loadbalancer_ip(
+                            service_name,
+                        )
+
+            # Wait for deployment to be ready
+            if not self.wait_for_deployment_ready(name, timeout=120):
+                logger.warning(f"Deployment '{name}' may not be fully ready")
+
+            logger.debug(
+                f"Deployment '{name}' created successfully with service: "
+                f"{service_info}",
+            )
+
+            return (
+                name,
+                service_info["ports"] if service_info else [],
+                load_balancer_ip or "",
+            )
+
+        except Exception as e:
+            logger.error(
+                f"Failed to create deployment: {e}, {traceback.format_exc()}",
+            )
+            return None, None, None
+
+    def wait_for_deployment_ready(self, deployment_name, timeout=300):
+        """Wait for a deployment to be ready."""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            try:
+                deployment = self.apps_v1.read_namespaced_deployment(
+                    name=deployment_name,
+                    namespace=self.namespace,
+                )
+
+                # Check if deployment is ready
+                if (
+                    deployment.status.ready_replicas
+                    and deployment.status.ready_replicas
+                    == deployment.spec.replicas
+                ):
+                    return True
+
+                time.sleep(3)
+            except ApiException as e:
+                if e.status == 404:
+                    return False
+                time.sleep(3)
+        return False
+
+    def _get_loadbalancer_ip(self, service_name, timeout=30):
+        """Get LoadBalancer external IP address."""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            try:
+                service = self.v1.read_namespaced_service(
+                    name=service_name,
+                    namespace=self.namespace,
+                )
+
+                if (
+                    service.status.load_balancer
+                    and service.status.load_balancer.ingress
+                ):
+                    ingress = service.status.load_balancer.ingress[0]
+                    # Return IP or hostname
+                    return ingress.ip or ingress.hostname
+
+                time.sleep(2)
+            except Exception as e:
+                logger.debug(f"Waiting for LoadBalancer IP: {e}")
+                time.sleep(2)
+
+        logger.debug(
+            f"LoadBalancer IP not available for service {service_name}",
+        )
+        return None
+
+    def remove_deployment(self, deployment_name, remove_service=True):
+        """Remove a Kubernetes Deployment and optionally its service."""
+        try:
+            # Remove associated LoadBalancer service first if requested
+            if remove_service:
+                service_name = f"{deployment_name}-lb-service"
+                try:
+                    self.v1.delete_namespaced_service(
+                        name=service_name,
+                        namespace=self.namespace,
+                    )
+                    logger.debug(
+                        f"Removed LoadBalancer service {service_name}",
+                    )
+                except ApiException as e:
+                    if e.status != 404:
+                        logger.warning(
+                            f"Failed to remove service {service_name}: {e}",
+                        )
+
+            # Remove the deployment
+            self.apps_v1.delete_namespaced_deployment(
+                name=deployment_name,
+                namespace=self.namespace,
+                body=client.V1DeleteOptions(
+                    propagation_policy="Foreground",
+                ),
+            )
+
+            logger.debug(
+                f"Deployment '{deployment_name}' removed successfully",
+            )
+            return True
+
+        except ApiException as e:
+            if e.status == 404:
+                logger.warning(f"Deployment '{deployment_name}' not found")
+                return True
+            logger.error(f"Failed to remove deployment: {e.reason}")
+            return False
+        except Exception as e:
+            logger.error(f"An error occurred: {e}, {traceback.format_exc()}")
+            return False
+
+    def get_deployment_status(self, deployment_name):
+        """Get the current status of the specified deployment."""
+        try:
+            deployment = self.apps_v1.read_namespaced_deployment(
+                name=deployment_name,
+                namespace=self.namespace,
+            )
+
+            return {
+                "name": deployment_name,
+                "replicas": deployment.spec.replicas,
+                "ready_replicas": deployment.status.ready_replicas or 0,
+                "available_replicas": deployment.status.available_replicas
+                or 0,
+                "unavailable_replicas": deployment.status.unavailable_replicas
+                or 0,
+                "conditions": [
+                    {
+                        "type": condition.type,
+                        "status": condition.status,
+                        "reason": condition.reason,
+                        "message": condition.message,
+                    }
+                    for condition in (deployment.status.conditions or [])
+                ],
+            }
+        except ApiException as e:
+            if e.status == 404:
+                logger.warning(f"Deployment '{deployment_name}' not found")
+            else:
+                logger.error(f"Failed to get deployment status: {e.reason}")
+            return None
+        except Exception as e:
+            logger.error(f"An error occurred: {e}, {traceback.format_exc()}")
+            return None
+
+    def list_deployments(self, label_selector=None):
+        """List deployments in the namespace."""
+        try:
+            deployments = self.apps_v1.list_namespaced_deployment(
+                namespace=self.namespace,
+                label_selector=label_selector,
+            )
+            return [
+                deployment.metadata.name for deployment in deployments.items
+            ]
+        except ApiException as e:
+            logger.error(f"Failed to list deployments: {e.reason}")
+            return []
+        except Exception as e:
+            logger.error(f"An error occurred: {e}, {traceback.format_exc()}")
+            return []

agentscope_runtime/engine/__init__.py

@@ -7,3 +7,15 @@ from .services import (
 )
 from .deployers import DeployManager, LocalDeployManager
 from .runner import Runner
+from .app import AgentApp
+
+__all__ = [
+    "Service",
+    "SandboxService",
+    "MemoryService",
+    "SessionHistoryService",
+    "DeployManager",
+    "LocalDeployManager",
+    "Runner",
+    "AgentApp",
+]