cancan-microstack 0.0.1__py3-none-any.whl

cancan_microstack/services/infrasrv/domain/workflow/workflow_domain.py

@@ -0,0 +1,164 @@
+"""
+工作流领域服务
+Workflow Domain Service
+
+负责工作流的核心业务逻辑和规则验证，包括分布式锁保护的更新操作。
+Handles workflow core business logic and rule validation, including update operations protected by distributed locks.
+"""
+import uuid
+from typing import Optional
+from contextlib import asynccontextmanager
+
+import redis.asyncio as redis
+
+from cancan_microstack.public.const.redis import RedisKey
+from cancan_microstack.public.error import HTTPException
+from cancan_microstack.public.schemas.infra import workflow as wt
+from linglong_web import Rmanager
+from cancan_microstack.services.infrasrv.infrastructure.db.operate import workflow_op
+from linglong_web.utils import logger
+
+
+class WorkflowDomain:
+    """
+    工作流领域服务
+    Workflow domain service for core business logic.
+    """
+
+    # Redis 锁的过期时间（秒）
+    # Redis lock expiration time in seconds
+    LOCK_EXPIRE_SECONDS = 60 * 5  # 5分钟
+
+    def _get_workflow_lock(self, workflow_id: uuid.UUID):
+        """
+        基于 Redis 连接池创建分布式锁对象
+        Create distributed lock object using Redis connection pool
+        """
+        if not Rmanager.RedisPool:
+            raise HTTPException(status_code=500, msg="Redis pool is not initialized")
+
+        redis_client = redis.Redis(connection_pool=Rmanager.RedisPool)
+        lock_key = f"{RedisKey.WORKFLOW_UPDATE_PREFIX}{workflow_id}"
+        return redis_client.lock(lock_key, timeout=self.LOCK_EXPIRE_SECONDS)
+
+    @asynccontextmanager
+    async def _acquire_workflow_lock(self, workflow_id: uuid.UUID):
+        """
+        获取工作流的分布式锁
+        Acquire distributed lock for a workflow.
+
+        Args:
+            workflow_id: 工作流 ID / Workflow ID
+
+        Yields:
+            None
+
+        Raises:
+            HTTPException: 如果获取锁超时 / If lock acquisition times out
+        """
+        lock = self._get_workflow_lock(workflow_id)
+
+        # blocking=True 结合 blocking_timeout 确保不会无限等待
+        # blocking=True with blocking_timeout ensures we don't wait forever
+        lock_acquired = await lock.acquire(blocking=True, blocking_timeout=self.LOCK_EXPIRE_SECONDS)
+
+        if not lock_acquired:
+            logger.warning(f"Failed to acquire lock for workflow {workflow_id}")
+            raise HTTPException(
+                status_code=409,
+                msg=f"Workflow {workflow_id} is being modified by another process, please retry later"
+            )
+
+        try:
+            logger.debug(f"Acquired lock for workflow {workflow_id}")
+            yield
+        finally:
+            if lock.locked():
+                await lock.release()
+                logger.debug(f"Released lock for workflow {workflow_id}")
+
+    async def update_workflow_definition(
+            self,
+            workflow_id: uuid.UUID,
+            data: wt.WorkflowDefinitionUpdate
+    ) -> Optional[wt.WorkflowDefinition]:
+        """
+        更新工作流定义（带分布式锁保护）
+        Update workflow definition with distributed lock protection.
+
+        Args:
+            workflow_id: 工作流 ID / Workflow ID
+            data: 更新数据 / Update data
+
+        Returns:
+            更新后的工作流定义，如果不存在则返回 None
+            Updated workflow definition, or None if not found
+
+        Raises:
+            HTTPException: 如果无法获取锁 / If lock cannot be acquired
+        """
+        # 使用分布式锁保护更新操作
+        # Protect update operation with distributed lock
+        async with self._acquire_workflow_lock(workflow_id):
+            logger.info(f"Updating workflow definition {workflow_id} with lock protection")
+
+            # 调用基础设施层执行数据库更新
+            # Call infrastructure layer to execute database update
+            updated = await workflow_op.update_workflow_definition(workflow_id, data)
+
+            if not updated:
+                logger.warning(f"Workflow {workflow_id} not found during update")
+                return None
+
+            logger.info(f"Successfully updated workflow definition {workflow_id}")
+            return updated
+
+    async def rollback_workflow_definition(
+            self,
+            workflow_id: uuid.UUID,
+            target_version: int,
+            reason: Optional[str] = None,
+    ) -> Optional[wt.WorkflowDefinition]:
+        """
+        回滚工作流定义（带分布式锁保护）
+        Roll back workflow definition with distributed lock protection.
+
+        Args:
+            workflow_id: 工作流 ID / Workflow ID
+            target_version: 目标版本号 / Target version number
+            reason: 回滚原因 / Rollback reason
+
+        Returns:
+            回滚后的工作流定义 / Workflow definition after rollback
+        """
+        async with self._acquire_workflow_lock(workflow_id):
+            logger.info(
+                "Rolling back workflow %s to version %s with lock protection",
+                workflow_id,
+                target_version,
+            )
+
+            updated = await workflow_op.rollback_workflow_definition(
+                workflow_id,
+                target_version=target_version,
+                reason=reason,
+            )
+
+            if not updated:
+                logger.warning(
+                    "Workflow %s rollback failed, version %s not found",
+                    workflow_id,
+                    target_version,
+                )
+                return None
+
+            logger.info(
+                "Workflow %s rolled back to version %s successfully",
+                workflow_id,
+                target_version,
+            )
+            return updated
+
+
+# 全局实例 / Global instance
+workflow_domain = WorkflowDomain()

cancan_microstack/services/infrasrv/infrastructure/api/controllersrv_api.py

@@ -0,0 +1,165 @@
+"""
+controllersrv API 客户端（用于 infrasrv）/ controllersrv API Client (for infrasrv)
+
+infrasrv 用于调用 controllersrv 的 API 客户端 / API client for infrasrv to call controllersrv
+继承自公共的 ControllerSrvApiClient / Inherits from common ControllerSrvApiClient
+"""
+import os
+from typing import (
+    List,
+    Optional,
+)
+
+from linglong_web.utils import logger
+from linglong_web import LinglongConfig
+
+from cancan_microstack.public.api.controllersrv_client import (
+    ControllerSrvApiClient,
+    ServiceOperationResponse,
+)
+from cancan_microstack.public.schemas.common import APIResponse
+from cancan_microstack.public.schemas.controllersrv.responses import (
+    EnqueueErrorResponse,
+    EnqueueSuccessResponse,
+    TaskStatusResponse,
+)
+from cancan_microstack.public.schemas.controllersrv.validation import ValidationResult
+from cancan_microstack.public.schemas.infra.service_management import ControllerSrvResult
+
+
+class ControllerSrvApi(ControllerSrvApiClient):
+    """
+    用于与 controllersrv 通信的 API 客户端（infrasrv 专用）
+    API client for communicating with controllersrv (for infrasrv)
+    
+    继承自公共的 ControllerSrvApiClient，添加特定于 infrasrv 的配置
+    Inherits from common ControllerSrvApiClient with infrasrv-specific configuration
+    """
+
+    def __init__(self):
+        """
+        初始化 API 客户端，使用 infrasrv 的配置
+        Initialize API client with infrasrv configuration
+        """
+        # 从配置获取 controllersrv 的地址 / Get controllersrv address from config
+        # 优先使用环境变量，确保在容器环境中能获取到正确的值
+        # 注意：该类可能会在 LinglongConfig 初始化前被 import。
+        # Note: This class may be imported before LinglongConfig is initialized.
+        config_host = getattr(LinglongConfig, "CONTROLLERSRV_HOST", None)
+        controllersrv_host = os.getenv(
+            "CONTROLLERSRV_HOST",
+            config_host or "http://host.containers.internal:22100",
+        )
+
+        base_url = f"{controllersrv_host}/v1/controllersrv"
+
+        # 调用父类初始化 / Call parent class initialization
+        super().__init__(base_url=base_url)
+        logger.info(f"ControllerSrvApi initialized (infrasrv) with base_url: {base_url}")
+
+    async def start_services(self, service_names: List[str], serial_number: str) -> ControllerSrvResult:
+        """
+        调用 controllersrv 启动服务 / Call controllersrv to start services
+        
+        Args:
+            service_names: 服务名称列表 / List of service names
+            serial_number: 操作序列号（operation_id）/ Operation serial number (operation_id)
+        
+        Returns:
+            操作结果 / Operation result
+        """
+        logger.info(f"[infrasrv → controllersrv] Starting services: {service_names}, serial_number: {serial_number}")
+        response = await super().start_services(service_names, serial_number)
+        return self._to_controller_result(response, operation="start")
+
+    async def stop_services(self, service_names: List[str], serial_number: str) -> ControllerSrvResult:
+        """
+        调用 controllersrv 停止服务 / Call controllersrv to stop services
+        
+        Args:
+            service_names: 服务名称列表 / List of service names
+            serial_number: 操作序列号（operation_id）/ Operation serial number (operation_id)
+        
+        Returns:
+            操作结果 / Operation result
+        """
+        logger.info(f"[infrasrv → controllersrv] Stopping services: {service_names}, serial_number: {serial_number}")
+        response = await super().stop_services(service_names, serial_number)
+        return self._to_controller_result(response, operation="stop")
+
+    async def restart_services(self, service_names: List[str], serial_number: str) -> ControllerSrvResult:
+        """
+        调用 controllersrv 重启服务 / Call controllersrv to restart services
+        
+        Args:
+            service_names: 服务名称列表 / List of service names
+            serial_number: 操作序列号（operation_id）/ Operation serial number (operation_id)
+        
+        Returns:
+            操作结果 / Operation result
+        """
+        logger.info(f"[infrasrv → controllersrv] Restarting services: {service_names}, serial_number: {serial_number}")
+        response = await super().restart_services(service_names, serial_number)
+        return self._to_controller_result(response, operation="restart")
+
+    async def get_operation_status(self, serial_number: str) -> Optional[TaskStatusResponse]:
+        """
+        查询 controllersrv 中任务的最新状态
+        Query latest task status from controllersrv
+        """
+
+        response = await super().get_operation_status(serial_number)
+        if response.success and isinstance(response.data, TaskStatusResponse):
+            return response.data
+
+        logger.warning(
+            "Failed to fetch controllersrv task status: serial=%s, error=%s",
+            serial_number,
+            response.error.msg if response.error else "unknown",
+        )
+        return None
+
+    def _to_controller_result(
+            self,
+            response: APIResponse[Optional[ServiceOperationResponse]],
+            operation: str,
+    ) -> ControllerSrvResult:
+        """将 controllersrv 响应转换为 ControllerSrvResult / Convert controllersrv response to ControllerSrvResult"""
+
+        data = response.data
+
+        if isinstance(data, EnqueueSuccessResponse):
+            message = data.message or f"{operation} operation accepted"
+            return ControllerSrvResult(success=True, message=message)
+
+        if isinstance(data, EnqueueErrorResponse):
+            message = data.message or f"{operation} operation rejected"
+            return ControllerSrvResult(success=False, message=message, error=message)
+
+        if isinstance(data, ValidationResult):
+            message = self._build_validation_message(data)
+            return ControllerSrvResult(success=False, message=message, error=message)
+
+        if response.success:
+            # controllersrv 成功但未返回详细数据 / controllersrv succeeded without detail
+            return ControllerSrvResult(success=True, message=f"{operation} operation accepted")
+
+        error_message = response.error.msg or f"controllersrv {operation} request failed"
+        return ControllerSrvResult(
+            success=False,
+            message=error_message,
+            error=error_message,
+        )
+
+    @staticmethod
+    def _build_validation_message(validation: ValidationResult) -> str:
+        """拼接服务校验失败原因 / Build validation failure message"""
+
+        parts: List[str] = []
+        if validation.invalid_services:
+            parts.append(f"Invalid services: {', '.join(validation.invalid_services)}")
+        if validation.non_operable_services:
+            parts.append(f"Non-operable services: {', '.join(validation.non_operable_services)}")
+        if validation.valid_services and not validation.valid:
+            parts.append(f"Valid subset: {', '.join(validation.valid_services)}")
+        return "; ".join(parts) if parts else "Service validation failed"

cancan_microstack/services/infrasrv/infrastructure/cache/service_registry_cache.py

@@ -0,0 +1,174 @@
+"""
+服务注册 Redis 缓存辅助类
+"""
+import orjson
+from typing import (
+    Optional,
+    List,
+)
+
+from cancan_microstack.public.const.redis import RedisKey
+from linglong_web import Rmanager
+from linglong_web.utils import logger
+
+
+class ServiceRegistryCache:
+    """服务注册缓存管理"""
+
+    # 缓存过期时间（秒）
+    CACHE_TTL_INSTANCE = 60  # 单个实例缓存60秒
+    CACHE_TTL_LIST = 30  # 列表缓存30秒
+
+    SERVICE_NAME = "infrasrv"
+
+    @classmethod
+    def _get_cache_key(cls, key_template: str, **kwargs) -> str:
+        """
+        生成缓存 key
+        
+        Args:
+            key_template: key 模板
+            **kwargs: 模板参数
+        
+        Returns:
+            完整的缓存 key
+        """
+        key = key_template.format(**kwargs)
+        return f"{cls.SERVICE_NAME}:{RedisKey.SERVICE_REGISTRY_PREFIX}{key}"
+
+    @classmethod
+    async def get_instance(cls, service_name: str, instance_id: str) -> Optional[dict]:
+        """
+        从缓存获取服务实例
+        
+        Args:
+            service_name: 服务名称
+            instance_id: 实例ID
+        
+        Returns:
+            服务实例数据，不存在则返回 None
+        """
+        key = cls._get_cache_key(RedisKey.SERVICE_REGISTRY_INSTANCE, service_name=service_name, instance_id=instance_id)
+
+        try:
+            cached_data = await Rmanager.redis().get(key)
+            if cached_data:
+                return orjson.loads(cached_data)
+        except Exception as e:
+            logger.error(f"Failed to get cache for instance {service_name}:{instance_id}: {e}")
+
+        return None
+
+    @classmethod
+    async def set_instance(cls, service_name: str, instance_id: str, data: dict) -> None:
+        """
+        缓存服务实例
+        
+        Args:
+            service_name: 服务名称
+            instance_id: 实例ID
+            data: 实例数据
+        """
+        key = cls._get_cache_key(RedisKey.SERVICE_REGISTRY_INSTANCE, service_name=service_name, instance_id=instance_id)
+
+        try:
+            await Rmanager.redis().setex(
+                key,
+                cls.CACHE_TTL_INSTANCE,
+                orjson.dumps(data)
+            )
+        except Exception as e:
+            logger.error(f"Failed to cache instance {service_name}:{instance_id}: {e}")
+
+    @classmethod
+    async def delete_instance(cls, service_name: str, instance_id: str) -> None:
+        """
+        删除服务实例缓存
+        
+        Args:
+            service_name: 服务名称
+            instance_id: 实例ID
+        """
+        key = cls._get_cache_key(RedisKey.SERVICE_REGISTRY_INSTANCE, service_name=service_name, instance_id=instance_id)
+
+        try:
+            await Rmanager.redis().delete(key)
+        except Exception as e:
+            logger.error(f"Failed to delete cache for instance {service_name}:{instance_id}: {e}")
+
+    @classmethod
+    async def get_service_instances(cls, service_name: str) -> Optional[List[dict]]:
+        """
+        从缓存获取服务的所有实例
+        
+        Args:
+            service_name: 服务名称
+        
+        Returns:
+            实例列表，不存在则返回 None
+        """
+        key = cls._get_cache_key(RedisKey.SERVICE_REGISTRY_SERVICE_INSTANCES, service_name=service_name)
+
+        try:
+            cached_data = await Rmanager.redis().get(key)
+            if cached_data:
+                return orjson.loads(cached_data)
+        except Exception as e:
+            logger.error(f"Failed to get cache for service instances {service_name}: {e}")
+
+        return None
+
+    @classmethod
+    async def set_service_instances(cls, service_name: str, data: List[dict]) -> None:
+        """
+        缓存服务的所有实例
+        
+        Args:
+            service_name: 服务名称
+            data: 实例列表
+        """
+        key = cls._get_cache_key(RedisKey.SERVICE_REGISTRY_SERVICE_INSTANCES, service_name=service_name)
+
+        try:
+            await Rmanager.redis().setex(
+                key,
+                cls.CACHE_TTL_LIST,
+                orjson.dumps(data)
+            )
+        except Exception as e:
+            logger.error(f"Failed to cache service instances {service_name}: {e}")
+
+    @classmethod
+    async def delete_service_instances(cls, service_name: str) -> None:
+        """
+        删除服务实例列表缓存
+        
+        Args:
+            service_name: 服务名称
+        """
+        key = cls._get_cache_key(RedisKey.SERVICE_REGISTRY_SERVICE_INSTANCES, service_name=service_name)
+
+        try:
+            await Rmanager.redis().delete(key)
+        except Exception as e:
+            logger.error(f"Failed to delete cache for service instances {service_name}: {e}")
+
+    @classmethod
+    async def invalidate_all(cls) -> None:
+        """清空所有服务注册相关缓存"""
+        try:
+            # 使用 SCAN 查找所有匹配的 key
+            pattern = f"{cls.SERVICE_NAME}:{RedisKey.SERVICE_REGISTRY_PREFIX}*"
+            cursor = 0
+
+            while True:
+                cursor, keys = await Rmanager.redis().scan(cursor, match=pattern, count=100)
+                if keys:
+                    await Rmanager.redis().delete(*keys)
+
+                if cursor == 0:
+                    break
+
+            logger.info("All service registry cache invalidated")
+        except Exception as e:
+            logger.error(f"Failed to invalidate all cache: {e}")

cancan_microstack/services/infrasrv/infrastructure/db/model/execution_log_tbl.py

@@ -0,0 +1,53 @@
+"""
+执行审计日志表模型 / Execution Audit Log Table Model
+"""
+import uuid
+from sqlalchemy import (
+    Column,
+    String,
+    Integer,
+    Text,
+    SmallInteger,
+    TIMESTAMP,
+    ForeignKey,
+)
+from sqlalchemy.dialects.postgresql import (
+    JSONB,
+    UUID,
+)
+from sqlalchemy.sql import func
+from linglong_web import TableBase
+
+
+class ExecutionLogTbl(TableBase):
+    """
+    执行审计日志表 execution log
+    """
+    __tablename__ = 'execution_log_tbl'
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    node_instance_id = Column(UUID(as_uuid=True), ForeignKey('node_instance_tbl.id'), nullable=False)
+
+    attempt_no = Column(Integer, nullable=False)  # 第几次尝试
+
+    # 动作快照 (请求前)
+    request_snapshot = Column(JSONB)
+
+    # 结果快照 (响应后)
+    response_snapshot = Column(JSONB)
+
+    status = Column(String(20))  # SUCCESS, FAILURE, TIMEOUT (可以是字符串，比Enum灵活点)
+    error_detail = Column(Text)
+
+    start_time = Column(TIMESTAMP(timezone=True), default=func.current_timestamp())
+    end_time = Column(TIMESTAMP(timezone=True))
+    duration_ms = Column(Integer)
+
+    # 标准字段 (与 SQL schema 保持一致)
+    flag = Column(SmallInteger, default=0)
+    created_time = Column(TIMESTAMP(timezone=True), default=func.current_timestamp())
+    update_time = Column(TIMESTAMP(timezone=True), default=func.current_timestamp(), onupdate=func.current_timestamp())
+
+    __table_args__ = (
+        {'extend_existing': True},
+    )

cancan_microstack/services/infrasrv/infrastructure/db/model/node_instance_tbl.py

@@ -0,0 +1,55 @@
+"""
+节点运行实例表模型 / Node Run Instance Table Model
+"""
+import uuid
+from sqlalchemy import (
+    Column,
+    String,
+    Integer,
+    Text,
+    SmallInteger,
+    TIMESTAMP,
+    ForeignKey,
+)
+from sqlalchemy.dialects.postgresql import (
+    JSONB,
+    UUID,
+)
+from sqlalchemy.sql import func
+from linglong_web import TableBase
+from cancan_microstack.public.const.workflow_consts import NodeStatusEnum
+
+
+class NodeInstanceTbl(TableBase):
+    """
+    节点运行实例表 node instance
+    """
+    __tablename__ = 'node_instance_tbl'
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    run_id = Column(UUID(as_uuid=True), ForeignKey('workflow_run_tbl.id'), nullable=False)
+
+    # 对应 JSON 图中的 key (如 "step_1")
+    node_id = Column(String(50), nullable=False)
+
+    # 循环轮次 (默认为 1)
+    loop_index = Column(Integer, default=1, nullable=False)
+
+    status = Column(String(20), default=NodeStatusEnum.PENDING.value, index=True)
+
+    # 数据流转
+    input_data = Column(JSONB, default=dict)  # 进入该节点时的入参
+    final_output = Column(JSONB, default=dict)  # 该节点产出的结果
+
+    # 统计
+    attempt_count = Column(Integer, default=0)
+    error_msg = Column(Text)
+
+    # 标准字段 (与 SQL schema 保持一致)
+    flag = Column(SmallInteger, default=0)
+    created_time = Column(TIMESTAMP(timezone=True), default=func.current_timestamp())
+    update_time = Column(TIMESTAMP(timezone=True), default=func.current_timestamp(), onupdate=func.current_timestamp())
+
+    __table_args__ = (
+        {'extend_existing': True},
+    )

cancan_microstack/services/infrasrv/infrastructure/db/model/service_action_log_tbl.py

@@ -0,0 +1,44 @@
+"""
+服务行为日志表 ORM 模型
+"""
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    Text,
+    SmallInteger,
+    TIMESTAMP,
+)
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.sql import func
+from linglong_web import TableBase
+
+
+class ServiceActionLogTbl(TableBase):
+    """服务行为日志表"""
+    __tablename__ = 'service_action_log_tbl'
+    
+    # 主键
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    
+    # 业务字段
+    service_name = Column(String(100), nullable=False)
+    instance_id = Column(String(50))
+    action_type = Column(String(50), nullable=False)
+    action_status = Column(String(20), nullable=False)
+    action_detail = Column(JSONB, default={})
+    error_message = Column(Text)
+    triggered_by = Column(String(50), default='system')
+    action_metadata = Column(JSONB, default={})
+    
+    # 标准字段
+    flag = Column(SmallInteger, default=0)
+    created_time = Column(TIMESTAMP(timezone=True), default=func.current_timestamp())
+    update_time = Column(TIMESTAMP(timezone=True), default=func.current_timestamp(), onupdate=func.current_timestamp())
+    
+    __table_args__ = (
+        {'extend_existing': True},
+    )
+    
+    def __repr__(self):
+        return f"ServiceActionLogTbl(id={self.id}, service={self.service_name}, action={self.action_type}, status={self.action_status})"