cancan-microstack 0.0.1__py3-none-any.whl

cancan_microstack/services/infrasrv/interface/api/internal_instance_api.py

@@ -0,0 +1,265 @@
+"""
+infrasrv 内部实例管理 API
+
+供 controllersrv 调用，用于多实例管理
+"""
+from typing import Optional
+import http
+
+from linglong_web import build_success_response
+from cancan_microstack.public.schemas.common import APIResponse
+from cancan_microstack.public.error import HTTPException
+from cancan_microstack.public.const.error import ErrorCode
+from cancan_microstack.public.const.service_consts import InstanceStatus
+from linglong_web.utils import logger
+from cancan_microstack.services.infrasrv.infrastructure.db.operate.service_instance_op import (
+    insert_instance,
+    update_instance,
+    delete_instance_by_id,
+    get_instance_by_id,
+    list_instances_by_service,
+    count_instances_by_service,
+    get_instances_by_status,
+)
+from cancan_microstack.services.infrasrv.infrastructure.db.operate.service_info_op import (
+    update_service_replicas,
+)
+from cancan_microstack.public.schemas.infra.service_instance import ServiceInstanceCreate, ServiceInstanceUpdate
+
+
+async def internal_create_instance_handler(
+        service_name: str,
+        instance_id: str,
+        container_name: str,
+        compose_service_name: str,
+        host: str,
+        port: int,
+        internal_port: int = 8080,
+        status: str = InstanceStatus.STARTING,
+        expected_status: str = InstanceStatus.RUNNING,
+        instance_metadata: Optional[dict] = None,
+) -> APIResponse[dict | None]:
+    """
+    创建实例记录
+    
+    Args:
+        service_name: 服务名称
+        instance_id: 实例ID
+        container_name: 容器名称
+        compose_service_name: Docker Compose 服务名
+        host: 宿主机地址
+        port: 服务端口
+        internal_port: 容器内部端口
+        status: 实例状态
+        expected_status: 期望状态
+        instance_metadata: 实例元数据
+    """
+    instance_data = ServiceInstanceCreate(
+        service_name=service_name,
+        instance_id=instance_id,
+        container_name=container_name,
+        compose_service_name=compose_service_name,
+        host=host,
+        port=port,
+        internal_port=internal_port,
+        status=status,
+        expected_status=expected_status,
+        instance_metadata=instance_metadata or {}
+    )
+
+    await insert_instance(instance_data)
+
+    logger.info(f"Instance created: {instance_id}")
+    return build_success_response(data={"instance_id": instance_id})
+
+
+async def internal_update_instance_handler(
+        instance_id: str,
+        status: Optional[str] = None,
+        health_status: Optional[str] = None,
+        started_at: Optional[str] = None,
+        stopped_at: Optional[str] = None,
+        last_heartbeat: Optional[str] = None,
+        consecutive_failures: Optional[int] = None,
+        instance_metadata: Optional[dict] = None,
+) -> APIResponse[dict | None]:
+    """
+    更新实例信息
+    
+    Args:
+        instance_id: 实例ID
+        status: 实例状态
+        health_status: 健康状态
+        started_at: 启动时间
+        stopped_at: 停止时间
+        last_heartbeat: 最后心跳时间
+        consecutive_failures: 连续失败次数
+        instance_metadata: 实例元数据
+    """
+    # 注意：last_heartbeat 映射到 last_health_check
+    update_data = ServiceInstanceUpdate(
+        status=status,
+        health_status=health_status,
+        started_at=started_at,
+        stopped_at=stopped_at,
+        last_health_check=last_heartbeat,
+        consecutive_failures=consecutive_failures,
+        instance_metadata=instance_metadata
+    )
+
+    await update_instance(instance_id, update_data)
+
+    logger.debug(f"Instance updated: {instance_id}")
+    return build_success_response(data={"instance_id": instance_id})
+
+
+async def internal_delete_instance_handler(instance_id: str) -> APIResponse[dict | None]:
+    """
+    删除实例记录
+    
+    Args:
+        instance_id: 实例ID
+    """
+    await delete_instance_by_id(instance_id)
+
+    logger.info(f"Instance deleted: {instance_id}")
+    return build_success_response(data={"instance_id": instance_id})
+
+
+async def internal_get_instance_handler(instance_id: str) -> APIResponse[dict | None]:
+    """
+    获取实例信息
+    
+    Args:
+        instance_id: 实例ID
+    """
+    instance = await get_instance_by_id(instance_id)
+
+    if not instance:
+        raise HTTPException(
+            status_code=http.HTTPStatus.NOT_FOUND.value,
+            error_code=ErrorCode.HANDLER_NOT_FOUND,
+            msg="Instance not found",
+        )
+
+    return build_success_response(data=instance.model_dump())
+
+
+async def internal_list_instances_handler(
+        service_name: Optional[str] = None,
+        status: Optional[str] = None,
+) -> APIResponse[dict]:
+    """
+    列出实例
+    
+    Args:
+        service_name: 服务名称（可选）
+        status: 状态过滤（可选）
+    """
+    if status:
+        instances = await get_instances_by_status(status)
+        if service_name:
+            instances = [i for i in instances if i.service_name == service_name]
+    elif service_name:
+        instances = await list_instances_by_service(service_name)
+    else:
+        # 获取所有实例
+        instances = await get_instances_by_status(InstanceStatus.RUNNING)
+        instances.extend(await get_instances_by_status(InstanceStatus.STOPPED))
+        instances.extend(await get_instances_by_status(InstanceStatus.STARTING))
+        instances.extend(await get_instances_by_status(InstanceStatus.STOPPING))
+
+    return build_success_response(
+        data={
+            "instances": [i.model_dump() for i in instances],
+            "count": len(instances),
+        }
+    )
+
+
+async def internal_count_instances_handler(
+        service_name: str,
+        status: Optional[str] = None,
+) -> APIResponse[dict]:
+    """
+    统计实例数量
+    
+    Args:
+        service_name: 服务名称
+        status: 状态过滤（可选）
+    """
+    count = await count_instances_by_service(service_name, status)
+
+    return build_success_response(data={"count": count})
+
+
+async def internal_get_next_port_handler(
+        service_name: str,
+        start_port: int,
+        end_port: int,
+) -> APIResponse[dict | None]:
+    """
+    获取服务的下一个可用端口
+    
+    Args:
+        service_name: 服务名称
+        start_port: 起始端口
+        end_port: 结束端口
+    """
+    # 获取服务的所有实例
+    instances = await list_instances_by_service(service_name)
+
+    # 获取已使用的端口
+    used_ports = {inst.port for inst in instances if inst.port}
+
+    # 查找第一个可用端口
+    for port in range(start_port, end_port + 1):
+        if port not in used_ports:
+            logger.debug(f"Allocated port {port} for service {service_name}")
+            return build_success_response(data={"port": port})
+
+    # 没有可用端口
+    logger.warning(f"No available ports for service {service_name} in range {start_port}-{end_port}")
+    raise HTTPException(
+        status_code=http.HTTPStatus.SERVICE_UNAVAILABLE.value,
+        error_code=ErrorCode.SYSTEM_ERROR,
+        msg="No available ports",
+    )
+
+
+async def internal_update_service_replicas_handler(
+        service_name: str,
+        desired_replicas: int,
+        actual_replicas: int,
+        last_scale_at: Optional[str] = None,
+) -> APIResponse[dict]:
+    """
+    记录服务的副本数信息（仅记录期望状态，不实际扩缩容）
+
+    ⚠️ 重要：本接口仅把 desired_replicas / actual_replicas 写入 service_info 表，
+    用于记录"期望副本数（desired state）"和上游上报的"实际副本数"。
+    它**不会真正增减运行中的容器**——infrasrv 没有扩缩容执行能力，
+    controllersrv 也未实现 scale 动作。要真正改变运行实例数，需由外部编排
+    （如手动 docker-compose scale）完成后，再由上游调用本接口回填 actual_replicas。
+
+    Args:
+        service_name: 服务名称
+        desired_replicas: 期望副本数（仅记录，不触发扩缩容）
+        actual_replicas: 实际副本数（由上游上报回填，本接口不会去核对真实容器数）
+        last_scale_at: 最后扩缩容时间 (API 参数保留，但 op 层在 desired_replicas 变更时自动写入)
+    """
+    service_info = await update_service_replicas(
+        service_name=service_name,
+        desired_replicas=desired_replicas,
+        actual_replicas=actual_replicas,
+    )
+
+    if not service_info:
+        raise HTTPException(
+            status_code=http.HTTPStatus.NOT_FOUND.value,
+            error_code=ErrorCode.HANDLER_NOT_FOUND,
+            msg=f"Service info not found for {service_name}"
+        )
+
+    logger.info(f"Service replicas updated: {service_name} (desired={desired_replicas}, actual={actual_replicas})")
+    return build_success_response(data=service_info.model_dump())

cancan_microstack/services/infrasrv/interface/api/internal_operation_api.py

@@ -0,0 +1,206 @@
+"""
+内部操作管理 API
+
+提供给 controllersrv 使用的内部接口，用于管理操作记录
+"""
+from typing import Optional
+from datetime import datetime
+import http
+
+from pydantic import (
+    BaseModel,
+    Field,
+)
+from linglong_web import build_success_response
+from cancan_microstack.public.schemas.common import APIResponse
+from cancan_microstack.public.error import HTTPException
+from cancan_microstack.public.const.error import ErrorCode
+from cancan_microstack.services.infrasrv.infrastructure.db.operate.service_operation_op import (
+    create_operation,
+    get_operation_by_id,
+    update_operation,
+    query_operations,
+    get_timeout_operations,
+)
+from cancan_microstack.public.schemas.infra.service_operation import (
+    ServiceOperation,
+    ServiceOperationCreate,
+    ServiceOperationUpdate,
+    ServiceOperationQuery,
+)
+from linglong_web.utils.time import to_server_tz_iso
+
+
+def _serialize_operation(operation: Optional[ServiceOperation]) -> Optional[dict]:
+    """统一序列化操作记录，确保时间字段为东八区 ISO 字符串 / Serialize operation with Asia/Shanghai timestamps."""
+    if not operation:
+        return None
+    data = operation.model_dump()
+    for field_name in ("started_at", "completed_at", "last_retry_at", "created_time", "update_time"):
+        data[field_name] = to_server_tz_iso(getattr(operation, field_name, None))
+    return data
+
+
+class InternalOperationCreateRequest(BaseModel):
+    """内部操作创建请求"""
+    operation_id: str
+    operation_type: str
+    service_name: str
+    operation_params: dict = Field(default_factory=dict)
+    status: str = "pending"
+    initiated_by: str = "controllersrv"
+    initiated_from: str = "localhost"
+
+
+class InternalOperationUpdateRequest(BaseModel):
+    """内部操作更新请求"""
+    operation_id: str
+    status: Optional[str] = None
+    started_at: Optional[str] = None  # ISO format string
+    completed_at: Optional[str] = None  # ISO format string
+    result: Optional[dict] = None
+    error_message: Optional[str] = None
+
+
+async def internal_create_operation_handler(
+        request: InternalOperationCreateRequest,
+) -> APIResponse[dict | None]:
+    """
+    内部接口：创建操作记录
+    
+    Args:
+        request: 操作创建请求
+    
+    Returns:
+        创建结果
+    """
+    operation_data = ServiceOperationCreate(
+        operation_id=request.operation_id,
+        operation_type=request.operation_type,
+        service_name=request.service_name,
+        operation_params=request.operation_params,
+        status=request.status,
+        initiated_by=request.initiated_by,
+        initiated_from=request.initiated_from,
+    )
+
+    operation = await create_operation(operation_data)
+
+    return build_success_response(
+        data={
+            "operation": _serialize_operation(operation),
+        }
+    )
+
+
+async def internal_update_operation_handler(
+        request: InternalOperationUpdateRequest,
+) -> APIResponse[dict | None]:
+    """
+    内部接口：更新操作记录
+    
+    Args:
+        request: 操作更新请求
+    
+    Returns:
+        更新结果
+    """
+    update_data = ServiceOperationUpdate()
+
+    if request.status:
+        update_data.status = request.status
+
+    if request.started_at:
+        update_data.started_at = datetime.fromisoformat(request.started_at.replace('Z', '+00:00'))
+
+    if request.completed_at:
+        update_data.completed_at = datetime.fromisoformat(request.completed_at.replace('Z', '+00:00'))
+
+    if request.result:
+        update_data.result = request.result
+
+    if request.error_message:
+        update_data.error_message = request.error_message
+
+    operation = await update_operation(request.operation_id, update_data)
+
+    return build_success_response(
+        data={
+            "operation": _serialize_operation(operation),
+        }
+    )
+
+
+async def internal_get_operation_handler(operation_id: str) -> APIResponse[dict | None]:
+    """
+    内部接口：获取操作记录
+    
+    Args:
+        operation_id: 操作ID
+    
+    Returns:
+        操作记录
+    """
+    operation = await get_operation_by_id(operation_id)
+
+    if operation:
+        return build_success_response(
+            data={
+                "operation": _serialize_operation(operation),
+            }
+        )
+    else:
+        raise HTTPException(
+            status_code=http.HTTPStatus.NOT_FOUND.value,
+            error_code=ErrorCode.HANDLER_NOT_FOUND,
+            msg=f"Operation not found: {operation_id}",
+        )
+
+
+async def internal_list_operations_handler(
+        service_name: Optional[str] = None,
+        status: Optional[str] = None,
+        limit: int = 20,
+) -> APIResponse[dict]:
+    """
+    内部接口：查询操作列表
+    
+    Args:
+        service_name: 服务名称过滤
+        status: 状态过滤
+        limit: 返回数量限制
+    
+    Returns:
+        操作列表
+    """
+    query = ServiceOperationQuery(
+        service_name=service_name,
+        status=status,
+        limit=limit
+    )
+
+    operations = await query_operations(query)
+
+    return build_success_response(
+        data={
+            "operations": [_serialize_operation(op) for op in operations],
+            "count": len(operations),
+        }
+    )
+
+
+async def internal_check_timeouts_handler() -> APIResponse[dict]:
+    """
+    内部接口：检查超时操作
+    
+    Returns:
+        超时操作列表
+    """
+    timeout_operations = await get_timeout_operations()
+
+    return build_success_response(
+        data={
+            "timeout_operations": [_serialize_operation(op) for op in timeout_operations],
+            "count": len(timeout_operations),
+        }
+    )

cancan_microstack/services/infrasrv/interface/api/service_config.py

@@ -0,0 +1,50 @@
+from linglong_web import build_success_response
+from cancan_microstack.public.schemas.common import APIResponse
+from cancan_microstack.services.infrasrv.application.service_config import ServiceConfigApp
+
+_service_config_app = ServiceConfigApp()
+
+
+async def get_service_config_handler(service_name: str) -> APIResponse[dict | None]:
+    """
+    获取服务配置
+    供业务服务启动时拉取配置使用
+    """
+    data = await _service_config_app.get_service_config(service_name)
+    return build_success_response(data=data)
+
+
+async def insert_service_config_handler(service_name: str, conf_data: dict) -> APIResponse[dict]:
+    """
+    插入服务配置
+    供配置管理使用
+    """
+    await _service_config_app.insert_service_config(service_name, conf_data)
+    return build_success_response(data={"message": "Service config inserted successfully"})
+
+
+async def update_service_config_handler(service_name: str, conf_data: dict) -> APIResponse[dict]:
+    """
+    更新服务配置
+    供配置管理使用
+    """
+    await _service_config_app.update_service_config(service_name, conf_data)
+    return build_success_response(data={"message": "Service config updated successfully"})
+
+
+async def get_all_service_configs_handler() -> APIResponse[dict]:
+    """
+    获取所有服务配置
+    供配置管理使用
+    """
+    data = await _service_config_app.get_all_service_configs()
+    return build_success_response(data=data)
+
+
+async def delete_service_config_handler(service_name: str, conf_key: str) -> APIResponse[dict]:
+    """
+    删除服务配置
+    供配置管理使用
+    """
+    await _service_config_app.delete_service_config(service_name, conf_key)
+    return build_success_response(data={"message": "Service config deleted successfully"})

cancan_microstack/services/infrasrv/interface/api/service_logs_api.py

@@ -0,0 +1,49 @@
+"""
+服务行为日志查询 API - 为 opsbffsrv 提供日志查询接口
+"""
+
+from typing import Optional
+
+from linglong_web.utils import logger
+from linglong_web import build_success_response
+from cancan_microstack.public.schemas.common import APIResponse
+from cancan_microstack.public.error import ParamError
+from cancan_microstack.services.infrasrv.application.service_logs_app import ServiceLogsApp
+
+_service_logs_app = ServiceLogsApp()
+
+
+async def get_service_logs_handler(
+        service_name: Optional[str] = None,
+        action_type: Optional[str] = None,
+        action_status: Optional[str] = None,
+        limit: int = 100,
+) -> APIResponse[list[dict]]:
+    """
+    查询服务行为日志
+    
+    Args:
+        service_name: 服务名称（可选）
+        action_type: 操作类型（可选）
+        action_status: 操作状态（可选）
+        limit: 返回数量限制
+    
+    Returns:
+        统一响应格式
+    """
+    logger.info(
+        f"Query service logs: service_name={service_name}, "
+        f"action_type={action_type}, action_status={action_status}, limit={limit}"
+    )
+
+    if limit < 1 or limit > 1000:
+        raise ParamError("limit must be between 1 and 1000")
+
+    logs = await _service_logs_app.query_logs(
+        service_name=service_name,
+        action_type=action_type,
+        action_status=action_status,
+        limit=limit
+    )
+
+    return build_success_response(data=[log.model_dump() for log in logs])

cancan_microstack/services/infrasrv/interface/api/service_management_api.py

@@ -0,0 +1,113 @@
+"""
+服务管理 API 接口层 / Service Management API Interface Layer
+
+提供统一的服务管理接口，供 opsbffsrv 调用 / Provides unified service management interface for opsbffsrv
+"""
+from linglong_web.utils import logger
+from linglong_web import build_success_response
+from linglong_web.utils.time import to_server_tz_iso
+from cancan_microstack.public.schemas.common import APIResponse
+from cancan_microstack.public.schemas.infra.service_management import (
+    ServiceManagementRequest,
+    ServiceManagementResponse,
+    ServiceManagementAPIResponse,
+)
+from cancan_microstack.public.const.operation_consts import (
+    OperationType,
+)
+from cancan_microstack.services.infrasrv.application.service_management_app import ServiceManagementApp
+
+# 全局应用层实例 / Global application layer instance
+_app = ServiceManagementApp()
+
+
+def _build_service_management_response(
+        response: ServiceManagementResponse,
+) -> APIResponse[dict]:
+    """将领域响应转换为标准 API 响应 / Convert domain response to standard API response."""
+
+    api_response = ServiceManagementAPIResponse(
+        operation_id=response.operation_id,
+        status=response.status,
+        service_name=response.service_name,
+        message=response.message,
+        result=response.result,
+        error_message=response.error_message,
+        # 出参统一转换为东八区，便于前端展示 / Convert timestamps to Asia/Shanghai for UI clarity
+        started_at=to_server_tz_iso(response.started_at),
+        completed_at=to_server_tz_iso(response.completed_at),
+    )
+    return build_success_response(data=api_response.model_dump())
+
+
+async def start_service_handler(
+        request: ServiceManagementRequest,
+) -> APIResponse[dict]:
+    """
+    启动服务 API Handler / Start Service API Handler
+    
+    Args:
+        request: 服务管理请求 / Service management request
+    
+    Returns:
+        统一响应格式 / Unified response format
+    """
+    logger.info(
+        f"[API] Received start service request: operation_id={request.operation_id}, service={request.service_name}")
+
+    # 确保操作类型正确 / Ensure correct operation type
+    request.operation_type = OperationType.START
+
+    # 调用应用层执行操作 / Call application layer to execute operation
+    response: ServiceManagementResponse = await _app.execute_service_management(request)
+
+    return _build_service_management_response(response)
+
+
+async def stop_service_handler(
+        request: ServiceManagementRequest,
+) -> APIResponse[dict]:
+    """
+    停止服务 API Handler / Stop Service API Handler
+    
+    Args:
+        request: 服务管理请求 / Service management request
+    
+    Returns:
+        统一响应格式 / Unified response format
+    """
+    logger.info(
+        f"[API] Received stop service request: operation_id={request.operation_id}, service={request.service_name}")
+
+    # 确保操作类型正确 / Ensure correct operation type
+    request.operation_type = OperationType.STOP
+
+    # 调用应用层执行操作 / Call application layer to execute operation
+    response: ServiceManagementResponse = await _app.execute_service_management(request)
+
+    return _build_service_management_response(response)
+
+
+async def restart_service_handler(
+        request: ServiceManagementRequest,
+) -> APIResponse[dict]:
+    """
+    重启服务 API Handler / Restart Service API Handler
+    
+    Args:
+        request: 服务管理请求 / Service management request
+    
+    Returns:
+        统一响应格式 / Unified response format
+    """
+    logger.info(
+        f"[API] Received restart service request: operation_id={request.operation_id}, service={request.service_name}")
+
+    # 确保操作类型正确 / Ensure correct operation type
+    request.operation_type = OperationType.RESTART
+
+    # 调用应用层执行操作 / Call application layer to execute operation
+    response: ServiceManagementResponse = await _app.execute_service_management(request)
+
+    return _build_service_management_response(response)
+