cancan-microstack 0.0.1__py3-none-any.whl

cancan_microstack/services/infrasrv/infrastructure/ddl_manager.py

@@ -0,0 +1,31 @@
+"""InfraSrv DDL 管理入口
+InfraSrv entry point wiring the shared AutoDDLManager with service config.
+"""
+from pathlib import Path
+
+from linglong_web import LinglongConfig
+from linglong_web import (
+    AutoDDLManager,
+    DDLManagerConfig,
+)
+
+from cancan_microstack.runtime.resources import resolve_workspace_or_asset
+
+
+def _build_manager() -> AutoDDLManager:
+    """构建通用 DDL 管理器实例 / Build service-specific AutoDDLManager"""
+
+    trigger_file = resolve_workspace_or_asset("ddl/trigger.sql", "ddl/trigger.sql")
+
+    config = DDLManagerConfig(
+        script_path=Path(LinglongConfig.DDL_SCRIPT_PATH),
+        enable_auto_init=LinglongConfig.ENABLE_DDL_AUTO_INIT,
+        trigger_sql_paths=(trigger_file,),
+        required_extensions=LinglongConfig.DDL_REQUIRED_EXTENSIONS,
+    )
+    return AutoDDLManager(config)
+
+
+async def init_ddl() -> bool:
+    """初始化 DDL（供 AppServer 调用）/ Trigger schema auto-initialization"""
+    return await _build_manager().check_and_init_tables()

cancan_microstack/services/infrasrv/infrastructure/mongo/__init__.py

@@ -0,0 +1 @@
+"""infrasrv Mongo infrastructure package."""

cancan_microstack/services/infrasrv/infrastructure/mongo/log_repository.py

@@ -0,0 +1,129 @@
+"""MongoDB 日志存储仓库 / MongoDB repository for log documents."""
+import asyncio
+from datetime import datetime
+from typing import (
+    Any,
+    List,
+)
+
+from pymongo.asynchronous.collection import AsyncCollection
+from pymongo import ASCENDING, DESCENDING
+
+from cancan_microstack.public.schemas.logging.log_event import LogEventDocument
+from linglong_web import LinglongConfig
+from linglong_web import Rmanager
+from linglong_web.utils import logger
+
+
+class InfraLogRepository:
+    """封装 MongoDB 访问逻辑 / Encapsulate MongoDB operations for logs."""
+
+    def __init__(self) -> None:
+        """
+        初始化仓库。
+        它从全局资源管理器获取 MongoDB 客户端，并从配置中获取数据库和集合名称。
+        
+        Initializes the repository.
+        It reads database/collection names from the config; the MongoDB client is read
+        lazily at use time (see _init_collection), since resource initialization may happen
+        later in the server lifecycle.
+        """
+        # 注意：不要在 __init__ 缓存 Rmanager.MongoClient。
+        # 该仓库可能在资源初始化之前被创建，缓存 None 会导致整个进程拿不到 client。
+        # 与 opsbffsrv 的 LogQueryRepository 保持一致：在使用处惰性读取。
+        # Note: do NOT cache Rmanager.MongoClient at __init__ time. This repo may be created
+        # before resources are initialized; caching None would make the client unavailable forever.
+        # Aligned with opsbffsrv's LogQueryRepository: read it lazily at use time.
+        self._db_name = LinglongConfig.MONGODB_DB
+        self._collection_name = LinglongConfig.MONGODB_COLLECTION
+        self._collection: AsyncCollection | None = None
+        self._index_lock = asyncio.Lock()
+
+    async def _init_collection(self) -> AsyncCollection:
+        """
+        按需初始化集合对象并确保索引存在。
+        使用锁来防止并发的索引创建。
+
+        Initializes the collection object on-demand and ensures indexes exist.
+        Uses a lock to prevent concurrent index creation.
+        """
+        if self._collection is not None:
+            return self._collection
+
+        async with self._index_lock:
+            # Double-check after acquiring the lock
+            if self._collection is not None:
+                return self._collection
+
+            client = Rmanager.MongoClient
+            if not client:
+                raise RuntimeError("MongoDB client is not available in Rmanager.")
+
+            collection = client[self._db_name][self._collection_name]
+            await self._ensure_indexes(collection)
+            self._collection = collection
+            logger.info(
+                "InfraLogRepository collection '%s/%s' initialized.", self._db_name, self._collection_name
+            )
+            return self._collection
+
+    async def _get_collection(self) -> AsyncCollection:
+        """获取集合对象，如果需要则先进行初始化。/ Gets the collection object, initializing it if necessary."""
+        if self._collection is not None:
+            return self._collection
+        return await self._init_collection()
+
+    async def _ensure_indexes(self, collection: AsyncCollection) -> None:
+        """确保 MongoDB 集合上存在所有必需的索引。/ Ensures all required indexes exist on the MongoDB collection."""
+        await collection.create_index(
+            [("service_name", ASCENDING), ("timestamp", DESCENDING)],
+            name="idx_service_ts",
+        )
+        await collection.create_index(
+            [("level", ASCENDING), ("timestamp", DESCENDING)],
+            name="idx_level_ts",
+        )
+        await collection.create_index(
+            [("ip", ASCENDING), ("timestamp", DESCENDING)],
+            name="idx_ip_ts",
+        )
+        await collection.create_index(
+            [("func_name", ASCENDING), ("timestamp", DESCENDING)],
+            name="idx_func_ts",
+        )
+        await collection.create_index(
+            [("message", "text"), ("metadata_flattened", "text")],
+            name="idx_text_search",
+            default_language="english",
+        )
+
+    async def insert_event(self, document: LogEventDocument) -> None:
+        """向集合中插入一个新的日志文档。/ Inserts a new log document into the collection."""
+        collection = await self._get_collection()
+        payload = document.model_dump()
+        await collection.insert_one(payload)
+
+    async def cleanup_older_than(self, cutoff: datetime, batch_limit: int) -> int:
+        """删除早于给定截止时间的日志。/ Deletes logs older than a given cutoff time."""
+        collection = await self._get_collection()
+        cursor = (
+            collection.find({"timestamp": {"$lt": cutoff}}, projection={"_id": 1})
+            .sort("timestamp", ASCENDING)
+            .limit(batch_limit)
+        )
+        ids: List[Any] = [doc["_id"] async for doc in cursor]
+
+        if not ids:
+            return 0
+        result = await collection.delete_many({"_id": {"$in": ids}})
+        return int(result.deleted_count)
+
+    async def count_by_time_range(self, start: datetime, end: datetime) -> int:
+        """计算给定时间范围内的文档数量。/ Counts documents within a given time range."""
+        collection = await self._get_collection()
+        return await collection.count_documents({"timestamp": {"$gte": start, "$lte": end}})
+
+    @property
+    async def collection(self) -> AsyncCollection:
+        """提供对底层集合对象的异步属性访问。/ Provides async property access to the underlying collection object."""
+        return await self._get_collection()

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

@@ -0,0 +1,29 @@
+"""
+健康检查 API
+
+支持多实例健康检查
+"""
+from linglong_web import build_success_response
+from cancan_microstack.public.schemas.common import APIResponse
+from cancan_microstack.services.infrasrv.application.health_check_app import HealthCheckApp
+
+_health_check_app = HealthCheckApp()
+
+
+async def health_check_all_instances_handler() -> APIResponse[dict | None]:
+    """
+    对所有实例进行健康检查
+    
+    功能：
+    - 支持多实例检查
+    - 操作窗口期豁免
+    - 区分正常/异常关闭
+    - 自动重启不健康实例
+    
+    Returns:
+        健康检查结果汇总
+    """
+    result = await _health_check_app.check_all_instances()
+
+    # 在 handler 层将 Pydantic model 序列化为 dict/JSON
+    return build_success_response(data=result.model_dump())

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

@@ -0,0 +1,284 @@
+"""
+钩子监控API接口
+
+提供钩子执行指标、历史记录和状态的查询接口
+"""
+from datetime import datetime
+from typing import Dict
+
+from linglong_web import build_success_response
+from cancan_microstack.public.schemas.common import APIResponse
+from cancan_microstack.public.const.hook_enums import HookType
+from linglong_web.utils import logger
+from cancan_microstack.services.infrasrv.domain.hooks.hook_registry import get_hook_manager
+from cancan_microstack.services.infrasrv.domain.hooks.metrics import get_metrics
+from cancan_microstack.public.schemas.hook_metrics import (
+    MetricData,
+    MetricValue,
+    HookExecutionHistoryItem,
+    HookTypeStatus,
+    HooksByPriority,
+    HookInfo,
+    MetricSummary,
+    HookPerformance,
+    OverallPerformanceStats,
+)
+
+
+async def get_hook_metrics_handler() -> APIResponse[Dict[str, dict]]:
+    """
+    获取钩子指标 / Get hook metrics
+    
+    Returns:
+        钩子执行指标 / Hook execution metrics
+    """
+    metrics = get_metrics()
+    all_metrics = metrics.get_all_metrics()
+
+    # 转换为 Pydantic 模型 / Convert to Pydantic models
+    metrics_data: Dict[str, MetricData] = {}
+    for metric in all_metrics:
+        if metric.name not in metrics_data:
+            metrics_data[metric.name] = MetricData(
+                name=metric.name,
+                type=metric.metric_type,
+                description=metric.description,
+                values=[]
+            )
+
+        metrics_data[metric.name].values.append(
+            MetricValue(
+                value=metric.value,
+                labels=metric.labels,
+                timestamp=metric.timestamp
+            )
+        )
+
+    # 转换为字典用于响应 / Convert to dict for response
+    result = {name: data.model_dump() for name, data in metrics_data.items()}
+
+    return build_success_response(data=result)
+
+
+async def get_hook_history_handler(request) -> APIResponse[dict]:
+    """
+    获取钩子执行历史 / Get hook execution history
+    
+    Query Parameters:
+        hook_name: 钩子名称过滤（可选）/ Hook name filter (optional)
+        limit: 返回记录数限制（默认100）/ Limit of records to return (default 100)
+    
+    Returns:
+        钩子执行历史记录 / Hook execution history records
+    """
+    query_params = request.query_params
+    hook_name = query_params.get("hook_name")
+    limit = int(query_params.get("limit", 100))
+
+    hook_manager = get_hook_manager()
+    history = hook_manager.get_execution_history(
+        service_name=None,
+        hook_name=hook_name,
+        limit=limit
+    )
+
+    # 转换为 Pydantic 模型 / Convert to Pydantic models
+    history_items = [
+        HookExecutionHistoryItem(
+            hook_name=result.hook_name,
+            result=result.result,
+            message=result.message,
+            execution_time=result.execution_time,
+            has_modified_service_info=False  # 这个字段需要从 result 中获取，如果有的话
+        )
+        for result in history
+    ]
+
+    return build_success_response(
+        data={
+            "total": len(history_items),
+            "history": [item.model_dump() for item in history_items],
+        }
+    )
+
+
+async def get_hook_status_handler() -> APIResponse[dict]:
+    """
+    获取钩子状态 / Get hook status
+    
+    Returns:
+        钩子状态信息 / Hook status information
+    """
+    hook_manager = get_hook_manager()
+
+    # 获取所有钩子类型 / Get all hook types
+    hook_types = [HookType.PRE_REGISTER, HookType.POST_REGISTER, HookType.PRE_DEREGISTER, HookType.POST_DEREGISTER]
+
+    status_data: Dict[str, HookTypeStatus] = {}
+    total_hooks = 0
+
+    for hook_type in hook_types:
+        hooks = hook_manager.get_hooks(hook_type)
+        total_hooks += len(hooks)
+
+        # 按优先级分组 / Group by priority
+        hooks_by_priority = HooksByPriority()
+
+        for hook in hooks:
+            hook_info = HookInfo(
+                name=hook.name,
+                priority=hook.priority.name,
+                type=hook.__class__.__name__
+            )
+
+            # 根据优先级添加到对应列表 / Add to corresponding list by priority
+            priority_name = hook.priority.name
+            if priority_name == "HIGHEST":
+                hooks_by_priority.CRITICAL.append(hook_info)
+            elif priority_name == "HIGH":
+                hooks_by_priority.HIGH.append(hook_info)
+            elif priority_name in ("MEDIUM", "NORMAL"):
+                hooks_by_priority.MEDIUM.append(hook_info)
+            else:  # LOW, LOWEST
+                hooks_by_priority.LOW.append(hook_info)
+
+        status_data[hook_type] = HookTypeStatus(
+            count=len(hooks),
+            hooks_by_priority=hooks_by_priority
+        )
+
+    # 获取指标摘要 / Get metrics summary
+    metrics = get_metrics()
+    all_metrics = metrics.get_all_metrics()
+
+    metrics_summary: Dict[str, MetricSummary] = {}
+    for metric in all_metrics:
+        if metric.name not in metrics_summary:
+            metrics_summary[metric.name] = MetricSummary(
+                type=metric.metric_type,
+                description=metric.description,
+                latest_value=metric.value,
+                latest_timestamp=metric.timestamp
+            )
+
+    return build_success_response(
+        data={
+            "total_hooks": total_hooks,
+            "hook_types": {k: v.model_dump() for k, v in status_data.items()},
+            "metrics_summary": {k: v.model_dump() for k, v in metrics_summary.items()},
+            "timestamp": datetime.now().isoformat(),
+        }
+    )
+
+
+async def reset_hook_metrics_handler() -> APIResponse[dict]:
+    """
+    重置钩子指标 / Reset hook metrics
+    
+    Returns:
+        操作结果 / Operation result
+    """
+    metrics = get_metrics()
+    all_metrics = metrics.get_all_metrics()
+
+    # 重置所有计数器指标 / Reset all counter metrics
+    reset_count = 0
+    for metric in all_metrics:
+        if metric.metric_type.value == "counter":
+            metrics.reset_metric(metric.name)
+            reset_count += 1
+
+    # 清空钩子执行历史 / Clear hook execution history
+    hook_manager = get_hook_manager()
+    hook_manager.clear_history()
+
+    logger.info(f"Reset {reset_count} metrics and cleared hook history")
+
+    return build_success_response(
+        data={
+            "reset_metrics_count": reset_count,
+            "history_cleared": True,
+        }
+    )
+
+
+async def get_hook_performance_handler(request) -> APIResponse[dict]:
+    """
+    获取钩子性能统计 / Get hook performance statistics
+    
+    Query Parameters:
+        hook_name: 钩子名称过滤（可选）/ Hook name filter (optional)
+        time_range: 时间范围（小时，默认24）/ Time range (hours, default 24)
+    
+    Returns:
+        钩子性能统计 / Hook performance statistics
+    """
+    query_params = request.query_params
+    hook_name = query_params.get("hook_name")
+    time_range = int(query_params.get("time_range", 24))
+
+    hook_manager = get_hook_manager()
+    history = hook_manager.get_execution_history(
+        service_name=None,
+        hook_name=hook_name,
+        limit=1000  # 获取更多历史记录 / Get more history records
+    )
+
+    # 由于 history 中的记录没有时间戳字段，我们直接使用所有记录 / Use all records since history doesn't have timestamp field
+    filtered_history = [
+        result for result in history
+        if result.execution_time > 0
+    ]
+
+    if not filtered_history:
+        return build_success_response(
+            data={
+                "message": "No performance data available in the specified time range",
+                "time_range_hours": time_range,
+            }
+        )
+
+    # 按钩子名称分组 / Group by hook name
+    performance_by_hook: Dict[str, HookPerformance] = {}
+    for result in filtered_history:
+        hook_name_key = result.hook_name
+        if hook_name_key not in performance_by_hook:
+            performance_by_hook[hook_name_key] = HookPerformance()
+
+        perf = performance_by_hook[hook_name_key]
+        perf.total_executions += 1
+        perf.total_execution_time += result.execution_time
+
+        if result.result.value == "success":
+            perf.successful_executions += 1
+        else:
+            perf.failed_executions += 1
+
+        if result.execution_time < perf.min_execution_time:
+            perf.min_execution_time = result.execution_time
+
+        if result.execution_time > perf.max_execution_time:
+            perf.max_execution_time = result.execution_time
+
+        # 计算平均执行时间 / Calculate average execution time
+        perf.avg_execution_time = perf.total_execution_time / perf.total_executions
+
+    # 计算总体统计 / Calculate overall statistics
+    total_executions = sum(perf.total_executions for perf in performance_by_hook.values())
+    total_successful = sum(perf.successful_executions for perf in performance_by_hook.values())
+    total_failed = sum(perf.failed_executions for perf in performance_by_hook.values())
+
+    overall_stats = OverallPerformanceStats(
+        total_executions=total_executions,
+        successful_executions=total_successful,
+        failed_executions=total_failed,
+        success_rate=(total_successful / total_executions * 100) if total_executions > 0 else 0
+    )
+
+    return build_success_response(
+        data={
+            "time_range_hours": time_range,
+            "overall_stats": overall_stats.model_dump(),
+            "performance_by_hook": {k: v.model_dump() for k, v in performance_by_hook.items()},
+        }
+    )

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

@@ -0,0 +1,49 @@
+"""
+Internal API for infrasrv
+These endpoints are called by other internal services (like opsbffsrv)
+Not exposed to frontend
+"""
+import http
+from typing import Any
+
+from linglong_web import build_success_response
+
+from cancan_microstack.public.const.error import ErrorCode
+from cancan_microstack.public.error import HTTPException
+from cancan_microstack.public.schemas.common import APIResponse
+from cancan_microstack.services.infrasrv.application.service_registry import ServiceRegistryApp
+
+_service_registry_app = ServiceRegistryApp()
+
+
+def _resolve_service_name(service_name: str | None, payload: dict[str, Any] | None) -> str:
+    """
+    解析 service_name 参数，兼容 query 和 JSON body
+    Resolve service_name from either query param or JSON payload
+    """
+    if service_name:
+        return service_name
+
+    if payload and isinstance(payload.get("service_name"), str):
+        service_name_from_payload = payload.get("service_name", "").strip()
+        if service_name_from_payload:
+            return service_name_from_payload
+
+    raise HTTPException(
+        status_code=http.HTTPStatus.BAD_REQUEST.value,
+        error_code=ErrorCode.MISSING_REQUIRED_PARAM,
+        msg="service_name is required",
+    )
+
+
+async def internal_trigger_config_push_handler(
+    service_name: str | None = None,
+    payload: dict[str, Any] | None = None,
+) -> APIResponse[dict | None]:
+    """
+    内部接口：触发配置推送
+    由 opsbffsrv 调用，在配置更新后触发 infrasrv 向服务实例推送新配置
+    """
+    resolved_service_name = _resolve_service_name(service_name=service_name, payload=payload)
+    result = await _service_registry_app.push_config_to_service(resolved_service_name)
+    return build_success_response(data=result)