cancan-microstack 0.0.1__py3-none-any.whl

cancan_microstack/services/controllersrv/domain/docker_compose/docker_compose_domain.py

@@ -0,0 +1,278 @@
+"""
+Docker Compose 管理领域层（重构版 - 使用 UnifiedExecutor）
+
+职责：
+1. 使用 UnifiedExecutor 进行容器操作
+2. API 操作：用于查询容器、镜像、网络等（快速、结构化）
+3. Compose 操作：用于服务编排（启动、停止、扩缩容等）
+4. 不包含业务验证逻辑
+"""
+import asyncio
+from typing import (
+    List,
+    Optional,
+)
+
+from linglong_web.utils import logger
+from cancan_microstack.public.error import HTTPException
+from cancan_microstack.public.const.controllersrv_consts import ControllersrvErrorCode
+from cancan_microstack.public.schemas.controllersrv.docker_models import (
+    ContainerHealthDetail,
+    ContainerState,
+    HealthCheck,
+)
+from cancan_microstack.public.const.docker_consts import (
+    DockerLabel,
+    DockerInspectKey,
+)
+from dragonfly_container.core import UnifiedExecutor
+from cancan_microstack.public.schemas.controllersrv.compose_models import (
+    CommandResult,
+    ServiceListResult,
+    ContainerHealthResult,
+    ComposeStatusResult,
+)
+
+
+class DockerComposeDomain:
+    """
+    Docker Compose 领域层（直接使用 Dragonfly Container UnifiedExecutor）
+    
+    直接使用 UnifiedExecutor 进行容器管理和服务编排
+    - API 操作：用于查询和单容器控制（基于 SDK）
+    - Compose 操作：用于多服务编排（基于 CLI）
+    """
+
+    def __init__(self, executor: UnifiedExecutor):
+        """
+        初始化领域层
+        
+        Args:
+            executor: Dragonfly Container UnifiedExecutor 实例
+        """
+        self.executor = executor
+        logger.info(
+            f"DockerComposeDomain initialized with UnifiedExecutor: "
+            f"engine={executor.api.engine_type}"
+        )
+
+    async def execute_command(
+            self,
+            cmd: List[str],
+            timeout: int,
+            operation_name: str
+    ) -> CommandResult:
+        """
+        执行命令
+        
+        Args:
+            cmd: 命令列表
+            timeout: 超时时间（秒）
+            operation_name: 操作名称（用于日志）
+        
+        Returns:
+            执行结果对象
+        """
+        logger.info(f"[{operation_name}] Executing: {' '.join(cmd)}")
+
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+
+            try:
+                stdout, stderr = await asyncio.wait_for(
+                    process.communicate(),
+                    timeout=timeout
+                )
+            except asyncio.TimeoutError:
+                process.kill()
+                await process.wait()
+                raise Exception(f"Command timeout after {timeout}s")
+
+            success = process.returncode == 0
+            output = stdout.decode('utf-8', errors='ignore').strip()
+            error = stderr.decode('utf-8', errors='ignore').strip()
+
+            if success:
+                logger.info(f"[{operation_name}] Command succeeded")
+            else:
+                logger.error(
+                    f"[{operation_name}] Command failed with code {process.returncode}: {error}"
+                )
+
+            return CommandResult(
+                success=success,
+                output=output,
+                error=error,
+                returncode=process.returncode,
+            )
+
+        except Exception as e:
+            logger.error(f"[{operation_name}] Command execution error: {e}", exc_info=True)
+            return CommandResult(
+                success=False,
+                output="",
+                error=str(e),
+                returncode=-1,
+            )
+
+    async def check_compose_running(self) -> bool:
+        """
+        检查 Docker Compose 是否正在运行（使用 API）
+        
+        Returns:
+            True 表示有容器在运行
+        """
+        try:
+            # 使用 API 查询当前项目的容器
+            containers = await self.executor.list_containers()
+
+            if containers:
+                logger.info(f"Docker Compose is running: {len(containers)} containers found")
+                return True
+
+            logger.info("Docker Compose is not running: no containers found")
+            return False
+
+        except Exception as e:
+            logger.error(f"Failed to check compose status: {e}", exc_info=True)
+            return False
+
+    async def get_service_status(self, service_names: Optional[List[str]] = None) -> ServiceListResult:
+        """
+        获取服务状态（使用 API）
+        
+        Args:
+            service_names: 服务名称列表，None 表示获取所有服务状态
+        
+        Returns:
+            服务状态结果对象
+        """
+        # 使用 API 查询容器
+        containers = await self.executor.list_containers(all=True)
+
+        # 如果指定了服务名称，则过滤
+        if service_names:
+            # 过滤出指定服务的容器
+            # 容器名称格式通常是 project_service_1
+            filtered_containers = []
+            for container in containers:
+                # 检查标签中的 com.docker.compose.service
+                service = container.labels.get(DockerLabel.SERVICE, "")
+                if service in service_names:
+                    filtered_containers.append(container)
+            containers = filtered_containers
+
+        # 构建服务列表（格式化输出，类似 docker-compose ps）
+        services = []
+        for container in containers:
+            service_name = container.labels.get(DockerLabel.SERVICE, "unknown")
+            services.append(
+                f"{container.name}\t{service_name}\t{container.status}\t{container.image}"
+            )
+
+        return ServiceListResult(
+            success=True,
+            services=services
+        )
+
+    async def list_services(self) -> ServiceListResult:
+        """
+        列出所有服务（使用 API 从容器标签中提取）
+        
+        Returns:
+            服务列表结果对象
+        """
+        # 使用 API 查询所有容器（包括已停止的）
+        containers = await self.executor.list_containers(all=True)
+
+        # 从容器标签中提取唯一的服务名称
+        services = set()
+        for container in containers:
+            service_name = container.labels.get(DockerLabel.SERVICE, "")
+            if service_name:
+                services.add(service_name)
+
+        return ServiceListResult(
+            success=True,
+            services=sorted(list(services))
+        )
+
+    async def get_container_health(self, service_name: str) -> ContainerHealthResult:
+        """
+        获取容器健康状态（使用 API）
+        
+        Args:
+            service_name: 服务名称
+        
+        Returns:
+            容器健康状态结果对象
+        """
+        # 使用 API 查询所有容器
+        all_containers = await self.executor.list_containers(all=True)
+
+        # 过滤出指定服务的容器
+        service_containers = []
+        for container in all_containers:
+            if container.labels.get(DockerLabel.SERVICE) == service_name:
+                service_containers.append(container)
+
+        if not service_containers:
+            raise HTTPException(
+                error_code=ControllersrvErrorCode.SERVICE_NOT_FOUND,
+                msg=f"No containers found for service: {service_name}"
+            )
+
+        # 获取每个容器的详细信息
+        containers = []
+        for container in service_containers:
+            try:
+                # 使用 API 获取详细信息
+                detail = await self.executor.inspect_container(container.id)
+                state_data = detail.get(DockerInspectKey.STATE, {})
+                health_data = state_data.get(DockerInspectKey.HEALTH, {})
+
+                containers.append(
+                    ContainerHealthDetail(
+                        id=container.id,
+                        name=container.name,
+                        state=ContainerState.model_validate(state_data) if state_data else None,
+                        health=HealthCheck.model_validate(health_data) if health_data else None,
+                    )
+                )
+            except Exception as e:
+                logger.error(f"Failed to inspect container {container.id}: {e}")
+                # 使用基础信息作为备用
+                containers.append(
+                    ContainerHealthDetail(
+                        id=container.id,
+                        name=container.name,
+                        state=None,
+                        health=None,
+                    )
+                )
+
+        return ContainerHealthResult(success=True, containers=containers)
+
+    async def get_compose_status(self) -> ComposeStatusResult:
+        """
+        获取 Docker Compose 整体状态（使用 API）
+        
+        Returns:
+            Docker Compose 状态结果对象
+        """
+        is_running = await self.check_compose_running()
+        services_info = await self.list_services()
+        status_info = await self.get_service_status()
+
+        return ComposeStatusResult(
+            is_running=is_running,
+            project_name=self.executor.project_name,
+            compose_file=self.executor.compose.compose_file,
+            engine_type=str(self.executor.api.engine_type),
+            available_services=services_info.services,
+            running_services=status_info.services,
+        )

cancan_microstack/services/controllersrv/domain/service_validator.py

@@ -0,0 +1,327 @@
+"""
+服务验证模块
+
+负责验证服务名称是否合法、是否可操作
+"""
+import yaml
+from typing import (
+    List,
+    Set,
+    Optional,
+    Dict,
+    Any,
+)
+from pathlib import Path
+from linglong_web.utils import logger
+from cancan_microstack.public.const.controllersrv_consts import (
+    ServiceCategory,
+    INFRASTRUCTURE_SERVICES,
+    FRAMEWORK_SERVICES,
+    ValidationResultKey,
+)
+from dragonfly_container.core import UnifiedExecutor
+
+
+class ServiceValidator:
+    """
+    服务验证器
+    
+    职责：
+    1. 从 docker-compose.yml 读取所有服务定义
+    2. 区分基础设施服务、框架服务、业务服务
+    3. 验证服务名称是否合法、是否可操作
+    
+    使用 Dragonfly Container 的 UnifiedExecutor 来获取服务信息
+    """
+
+    def __init__(self, compose_file: str, executor: Optional[UnifiedExecutor] = None):
+        """
+        初始化验证器
+        
+        Args:
+            compose_file: docker-compose.yml 文件路径
+            executor: Dragonfly Container UnifiedExecutor 实例（可选，用于获取动态服务信息）
+        """
+        self.compose_file = compose_file
+        self.executor = executor
+        self._all_services: Set[str] = set()
+        self._operable_services: Set[str] = set()
+        self._service_category_map: Dict[str, ServiceCategory] = {}
+
+        # 加载服务定义
+        self._load_services()
+
+    def _load_services(self):
+        """
+        从 docker-compose.yml 加载服务定义
+        
+        使用 Dragonfly Container 的 UnifiedExecutor 获取配置（如果可用），
+        否则直接解析 YAML 文件
+        """
+        try:
+            compose_path = Path(self.compose_file)
+            if not compose_path.exists():
+                logger.error(f"Docker Compose file not found: {self.compose_file}")
+                return
+
+            # 优先使用 executor 获取配置（如果可用）
+            if self.executor:
+                services = self._get_services_from_executor()
+            else:
+                services = None
+
+            # 如果 executor 不可用或获取失败，回退到直接读取 YAML
+            if not services:
+                logger.info("Using direct YAML parse to get services")
+                services = self._get_services_from_yaml()
+
+            self._all_services = set(services.keys())
+
+            # 分类服务
+            for service_name in self._all_services:
+                category = self._categorize_service(service_name)
+                self._service_category_map[service_name] = category
+
+                # 只有业务服务可操作
+                if category == ServiceCategory.BUSINESS:
+                    self._operable_services.add(service_name)
+
+            logger.info(
+                f"Loaded services from compose file: "
+                f"total={len(self._all_services)}, "
+                f"operable={len(self._operable_services)}"
+            )
+            logger.info(f"Operable services: {sorted(self._operable_services)}")
+
+        except Exception as e:
+            logger.error(f"Failed to load services from compose file: {e}", exc_info=True)
+
+    def _get_services_from_executor(self) -> Dict[str, Any]:
+        """
+        使用 Dragonfly Container UnifiedExecutor 获取服务列表
+        
+        使用 executor 的 build_config_command 方法构建命令，然后执行
+        
+        Returns:
+            服务字典，失败返回空字典
+        """
+        import subprocess
+
+        try:
+            if not self.executor:
+                return {}
+
+            # 使用 executor 构建 config 命令
+            cmd = self.executor.compose.build_config_command()
+            logger.debug(f"Getting services using executor: {' '.join(cmd)}")
+
+            compose_path = Path(self.compose_file)
+            work_dir = compose_path.parent
+
+            result = subprocess.run(
+                cmd,
+                cwd=work_dir,
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+
+            if result.returncode != 0:
+                logger.warning(f"Compose config command failed: {result.stderr}")
+                return {}
+
+            # 解析输出的 YAML
+            config_data = yaml.safe_load(result.stdout)
+            services = config_data.get('services', {})
+            logger.debug(f"Got {len(services)} services from executor")
+            return services
+
+        except subprocess.TimeoutExpired:
+            logger.warning("Compose config command timeout")
+            return {}
+        except Exception as e:
+            logger.debug(f"Failed to get services from executor: {e}")
+            return {}
+
+    def _get_services_from_yaml(self) -> Dict[str, Any]:
+        """
+        直接从 YAML 文件读取服务（回退方案）
+        
+        Returns:
+            服务字典
+        """
+        with open(self.compose_file, 'r', encoding='utf-8') as f:
+            compose_data = yaml.safe_load(f)
+
+        return compose_data.get('services', {})
+
+    def _categorize_service(self, service_name: str) -> ServiceCategory:
+        """
+        对服务进行分类
+        
+        Args:
+            service_name: 服务名称
+        
+        Returns:
+            服务分类
+        """
+        # 标准化服务名称（去掉 .service 后缀）
+        base_name = service_name.replace('.service', '')
+        full_name = f"{base_name}.service"
+
+        # 检查是否是基础设施服务
+        if base_name in INFRASTRUCTURE_SERVICES or full_name in INFRASTRUCTURE_SERVICES:
+            return ServiceCategory.INFRASTRUCTURE
+
+        # 检查是否是框架服务
+        if base_name in FRAMEWORK_SERVICES or full_name in FRAMEWORK_SERVICES:
+            return ServiceCategory.FRAMEWORK
+
+        # 其他都是业务服务
+        return ServiceCategory.BUSINESS
+
+    def is_valid_service(self, service_name: str) -> bool:
+        """
+        检查服务名称是否在 docker-compose.yml 中定义
+        
+        Args:
+            service_name: 服务名称
+        
+        Returns:
+            是否有效
+        """
+        # 标准化服务名称
+        base_name = service_name.replace('.service', '')
+        full_name = f"{base_name}.service"
+
+        return service_name in self._all_services or \
+            base_name in self._all_services or \
+            full_name in self._all_services
+
+    def is_operable_service(self, service_name: str) -> bool:
+        """
+        检查服务是否可操作（仅业务服务可操作）
+        
+        Args:
+            service_name: 服务名称
+        
+        Returns:
+            是否可操作
+        """
+        # 标准化服务名称
+        base_name = service_name.replace('.service', '')
+        full_name = f"{base_name}.service"
+
+        return service_name in self._operable_services or \
+            base_name in self._operable_services or \
+            full_name in self._operable_services
+
+    def get_service_category(self, service_name: str) -> Optional[ServiceCategory]:
+        """
+        获取服务分类
+        
+        Args:
+            service_name: 服务名称
+        
+        Returns:
+            服务分类，不存在返回 None
+        """
+        # 标准化服务名称
+        base_name = service_name.replace('.service', '')
+        full_name = f"{base_name}.service"
+
+        return self._service_category_map.get(service_name) or \
+            self._service_category_map.get(base_name) or \
+            self._service_category_map.get(full_name)
+
+    def validate_service_names(self, service_names: List[str]) -> Dict[str, Any]:
+        """
+        批量验证服务名称
+        
+        Args:
+            service_names: 服务名称列表
+        
+        Returns:
+            验证结果字典：
+            {
+                "valid": bool,
+                "invalid_services": [],
+                "non_operable_services": [],
+                "valid_services": []
+            }
+        """
+        invalid_services = []
+        non_operable_services = []
+        valid_services = []
+
+        for service_name in service_names:
+            # 检查是否存在
+            if not self.is_valid_service(service_name):
+                invalid_services.append(service_name)
+                continue
+
+            # 检查是否可操作
+            if not self.is_operable_service(service_name):
+                non_operable_services.append(service_name)
+                continue
+
+            valid_services.append(service_name)
+
+        return {
+            ValidationResultKey.VALID: len(invalid_services) == 0 and len(non_operable_services) == 0,
+            ValidationResultKey.INVALID_SERVICES: invalid_services,
+            ValidationResultKey.NON_OPERABLE_SERVICES: non_operable_services,
+            ValidationResultKey.VALID_SERVICES: valid_services,
+        }
+
+    def get_all_services(self) -> List[str]:
+        """获取所有服务列表"""
+        return sorted(self._all_services)
+
+    def get_operable_services(self) -> List[str]:
+        """获取所有可操作的服务列表"""
+        return sorted(self._operable_services)
+
+    def get_services_by_category(self, category: ServiceCategory) -> List[str]:
+        """
+        按分类获取服务列表
+        
+        Args:
+            category: 服务分类
+        
+        Returns:
+            服务名称列表
+        """
+        return sorted([
+            name for name, cat in self._service_category_map.items()
+            if cat == category
+        ])
+
+
+# 全局验证器实例
+_global_validator: Optional[ServiceValidator] = None
+
+
+def get_service_validator() -> Optional[ServiceValidator]:
+    """获取全局服务验证器实例"""
+    return _global_validator
+
+
+def init_service_validator(compose_file: str, executor: Optional[UnifiedExecutor] = None):
+    """
+    初始化全局服务验证器
+    
+    Args:
+        compose_file: docker-compose.yml 文件路径
+        executor: Dragonfly Container UnifiedExecutor 实例（可选）
+    """
+    global _global_validator
+    _global_validator = ServiceValidator(compose_file, executor)
+    logger.info("Global service validator initialized")
+
+
+def reset_service_validator():
+    """重置全局服务验证器（主要用于测试）"""
+    global _global_validator
+    _global_validator = None
+    logger.info("Global service validator reset")

cancan_microstack/services/controllersrv/domain/task/__init__.py

@@ -0,0 +1,17 @@
+"""
+任务管理模块
+
+提供任务队列和 Worker 功能
+"""
+from cancan_microstack.services.controllersrv.domain.task.task_queue import (
+    Task,
+    TaskQueue,
+    get_task_queue,
+    reset_task_queue,
+)
+from cancan_microstack.services.controllersrv.domain.task.task_worker import (
+    TaskWorker,
+    get_task_worker,
+    set_task_worker,
+    reset_task_worker,
+)