import json import asyncio from datetime import datetime from typing import Optional, Dict, Any, List from fastapi import APIRouter, Depends, Query, Body, Request from fastapi.responses import StreamingResponse from sqlalchemy.ext.asyncio import AsyncSession from redis.asyncio import Redis from app.core.database import get_db from app.core.redis import get_redis_client from app.core.auth import get_current_user from app.models.user import VasUser from app.utils.response import success from app.schemas.common import ApiResponse from app.schemas.node_configuration import ( NodeConfigurationSparseUpdateRequest, NodeConfigurationEnableRequest, NodeConfigurationRollbackRequest, NodeConfigurationListResponse, ClusterNodeCreate, ClusterNodeUpdate, ClusterNodeOut, ) from app.services.node_configuration_service import NodeConfigurationService public_router = APIRouter() protected_router = APIRouter() admin_required_router = APIRouter(prefix="/node-configurations", tags=["节点配置管理"]) @admin_required_router.get( "/runtime-status", summary="获取各Worker节点实时上报状态与心跳", response_model=ApiResponse[Dict[str, Any]], ) async def get_runtime_status( role: Optional[str] = Query(None, description="角色筛选: standalone / booker / sentinel"), node_id: Optional[str] = Query(None, description="节点 ID 筛选"), redis_client: Redis = Depends(get_redis_client), ): pattern = f"vs:status:{role or '*'}:{node_id or '*'}" keys = await redis_client.keys(pattern) nodes = [] now = datetime.utcnow() for k in keys: try: raw = await redis_client.get(k) if not raw: continue data = json.loads(raw) collected_at_str = data.get("collected_at", "") is_online = False age_sec = 999999 if collected_at_str: try: dt = datetime.strptime(collected_at_str, "%Y-%m-%d %H:%M:%S") age_sec = max(0, int((now - dt).total_seconds())) is_online = age_sec <= 60 except Exception: is_online = True nodes.append({ "role": data.get("role") or (k.split(":")[2] if len(k.split(":")) > 2 else ""), "node_id": data.get("node_id") or (k.split(":")[3] if len(k.split(":")) > 3 else ""), "is_online": is_online, "age_sec": age_sec, "installed_plugins": data.get("installed_plugins", []), "groups": data.get("groups", []), "collected_at": collected_at_str, }) except Exception: continue nodes.sort(key=lambda x: (x.get("role", ""), x.get("node_id", ""))) return success(data={"nodes": nodes, "timestamp": now.strftime("%Y-%m-%d %H:%M:%S")}) # ==================== 集群节点档案注册接口 (优先于 /{entry_type} 匹配) ==================== @admin_required_router.get( "/nodes/list", summary="获取已注册集群节点档案列表", response_model=ApiResponse[List[ClusterNodeOut]], ) async def list_cluster_nodes( status: Optional[int] = Query(None, description="状态筛选: 1启用 0停用"), keyword: Optional[str] = Query(None, description="关键词搜索 node_id / name / ip / region"), db: AsyncSession = Depends(get_db), ): nodes = await NodeConfigurationService.list_cluster_nodes( db=db, status=status, keyword=keyword ) return success(data=nodes) @admin_required_router.post( "/nodes/create", summary="登记/注册新集群节点档案", response_model=ApiResponse[ClusterNodeOut], ) async def create_cluster_node( payload: ClusterNodeCreate = Body(...), db: AsyncSession = Depends(get_db), current_user: VasUser = Depends(get_current_user), ): node = await NodeConfigurationService.create_cluster_node(db=db, data=payload) return success(data=node, message="Node registered successfully") @admin_required_router.post( "/nodes/update", summary="更新已注册集群节点档案", response_model=ApiResponse[ClusterNodeOut], ) async def update_cluster_node( node_id: str = Query(..., description="目标节点ID"), payload: ClusterNodeUpdate = Body(...), db: AsyncSession = Depends(get_db), current_user: VasUser = Depends(get_current_user), ): node = await NodeConfigurationService.update_cluster_node( db=db, node_id=node_id, data=payload ) return success(data=node, message="Node updated successfully") @admin_required_router.post( "/nodes/delete", summary="注销/删除集群节点档案", response_model=ApiResponse[bool], ) async def delete_cluster_node( node_id: str = Query(..., description="目标节点ID"), db: AsyncSession = Depends(get_db), current_user: VasUser = Depends(get_current_user), ): result = await NodeConfigurationService.delete_cluster_node(db=db, node_id=node_id) return success(data=result, message="Node deleted successfully") # ==================== Worker 节点实时日志流与历史查询接口 ==================== @admin_required_router.get( "/logs/stream", summary="流式获取 Worker 节点实时日志 (SSE)", ) async def stream_node_logs( request: Request, node_id: str = Query(..., description="节点 ID,如 node01"), role: str = Query(..., description="角色: sentinel / booker / standalone"), group_id: Optional[str] = Query(None, description="可选: 按 group_id 过滤"), level: Optional[str] = Query(None, description="可选: 按日志级别过滤 (INFO/WARN/ERROR)"), history_limit: int = Query(200, ge=0, le=1000, description="初始拉取的历史日志条目数"), redis_client: Redis = Depends(get_redis_client), ): """ 通过 Server-Sent Events (SSE) 流式返回 Worker 节点实时日志。 首先拉取 Redis Stream 最近的历史日志,随后持续挂起 xread 增量推送最新日志。 """ stream_key = f"vs:stream:logs:{node_id}:{role}" async def log_generator(): last_id = "0-0" # 1. 尝试拉取历史日志 if history_limit > 0: try: history_entries = await redis_client.xrevrange(stream_key, count=history_limit) if history_entries: # 翻转为时间正序 history_entries.reverse() for entry_id, fields in history_entries: last_id = entry_id msg_group = fields.get("group_id", "") msg_level = fields.get("level", "INFO") if group_id and msg_group and msg_group != group_id: continue if level and msg_level.upper() != level.upper(): continue payload = { "id": entry_id, "timestamp": fields.get("timestamp", ""), "level": msg_level, "group_id": msg_group, "role": fields.get("role", role), "node_id": fields.get("node_id", node_id), "message": fields.get("message", ""), } yield f"id: {entry_id}\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n" except Exception as e: yield f": error fetching history: {str(e)}\n\n" # 如果没有历史记录,尝试定位到当前最新末尾 if last_id == "0-0": try: latest = await redis_client.xrevrange(stream_key, count=1) if latest: last_id = latest[0][0] except Exception: pass # 2. 循环监听增量实时流 (XREAD) while not await request.is_disconnected(): try: data = await redis_client.xread({stream_key: last_id}, count=50, block=1000) if not data: # 发送注释心跳保持反向代理链路 yield ": ping\n\n" continue for s_key, entries in data: for entry_id, fields in entries: last_id = entry_id msg_group = fields.get("group_id", "") msg_level = fields.get("level", "INFO") if group_id and msg_group and msg_group != group_id: continue if level and msg_level.upper() != level.upper(): continue payload = { "id": entry_id, "timestamp": fields.get("timestamp", ""), "level": msg_level, "group_id": msg_group, "role": fields.get("role", role), "node_id": fields.get("node_id", node_id), "message": fields.get("message", ""), } yield f"id: {entry_id}\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n" except asyncio.CancelledError: break except Exception as e: yield f": error: {str(e)}\n\n" await asyncio.sleep(1) return StreamingResponse( log_generator(), media_type="text/event-stream", headers={ "Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no", }, ) @admin_required_router.get( "/logs/history", summary="查询 Worker 节点历史日志快照", response_model=ApiResponse[List[Dict[str, Any]]], ) async def get_node_logs_history( node_id: str = Query(..., description="节点 ID"), role: str = Query(..., description="角色: sentinel / booker / standalone"), group_id: Optional[str] = Query(None, description="可选: 按 group_id 过滤"), limit: int = Query(200, ge=1, le=1000, description="获取条数"), redis_client: Redis = Depends(get_redis_client), ): stream_key = f"vs:stream:logs:{node_id}:{role}" try: entries = await redis_client.xrevrange(stream_key, count=limit) results = [] if entries: entries.reverse() for entry_id, fields in entries: msg_group = fields.get("group_id", "") if group_id and msg_group and msg_group != group_id: continue results.append({ "id": entry_id, "timestamp": fields.get("timestamp", ""), "level": fields.get("level", "INFO"), "group_id": msg_group, "role": fields.get("role", role), "node_id": fields.get("node_id", node_id), "message": fields.get("message", ""), }) return success(data=results) except Exception as e: return success(data=[]) @admin_required_router.get( "/{entry_type}", summary="分页查询配置条目列表", response_model=ApiResponse[NodeConfigurationListResponse], ) async def list_node_configurations( entry_type: str, page: int = Query(1, ge=1, description="页码"), pageSize: int = Query(20, ge=1, le=100, description="每页数量", alias="pageSize"), identifier: Optional[str] = Query(None, description="任务标识模糊搜索"), node_id: Optional[str] = Query(None, description="节点唯一标识精确搜索"), order_id: Optional[str] = Query(None, description="订单ID (仅 standalone)"), db: AsyncSession = Depends(get_db), ): total, items = await NodeConfigurationService.list_entries( db=db, entry_type=entry_type, page=page, page_size=pageSize, identifier=identifier, node_id=node_id, order_id=order_id, ) return success( data={ "total": total, "page": page, "page_size": pageSize, "items": items, } ) @admin_required_router.get( "/{entry_type}/{entry_id}", summary="获取指定配置条目详情", response_model=ApiResponse[Dict[str, Any]], ) async def get_node_configuration_detail( entry_type: str, entry_id: int, db: AsyncSession = Depends(get_db), ): entry = await NodeConfigurationService.get_entry( db=db, entry_type=entry_type, entry_id=entry_id ) return success(data=entry) @admin_required_router.post( "/{entry_type}", summary="新建配置条目 (默认停用落库)", response_model=ApiResponse[Dict[str, Any]], ) async def create_node_configuration( entry_type: str, data: Dict[str, Any] = Body(...), current_user: Optional[VasUser] = Depends(get_current_user), db: AsyncSession = Depends(get_db), ): operator = ( current_user.email or current_user.nickname if current_user else "admin" ) entry = await NodeConfigurationService.create_entry( db=db, entry_type=entry_type, data=data, operator=operator, ) return success(data=entry, message="Node configuration created successfully") @admin_required_router.put( "/{entry_type}/{entry_id}", summary="稀疏更新配置条目 (支持点路径更新与字段清空)", response_model=ApiResponse[Dict[str, Any]], ) async def sparse_update_node_configuration( entry_type: str, entry_id: int, payload: NodeConfigurationSparseUpdateRequest = Body(...), current_user: Optional[VasUser] = Depends(get_current_user), db: AsyncSession = Depends(get_db), ): operator = ( current_user.email or current_user.nickname if current_user else "admin" ) entry = await NodeConfigurationService.sparse_update_entry( db=db, entry_type=entry_type, entry_id=entry_id, set_data=payload.set, clear_fields=payload.clear, base_version=payload.base_version, operator=operator, ) return success(data=entry, message="Node configuration updated successfully") @admin_required_router.put( "/{entry_type}/{entry_id}/enable", summary="启用 / 停用配置条目", response_model=ApiResponse[Dict[str, Any]], ) async def toggle_node_configuration_enable( entry_type: str, entry_id: int, payload: NodeConfigurationEnableRequest = Body(...), current_user: Optional[VasUser] = Depends(get_current_user), db: AsyncSession = Depends(get_db), ): operator = ( current_user.email or current_user.nickname if current_user else "admin" ) entry = await NodeConfigurationService.toggle_enable( db=db, entry_type=entry_type, entry_id=entry_id, enable=payload.enable, base_version=payload.base_version, operator=operator, ) return success(data=entry, message="Node configuration status toggled") @admin_required_router.delete( "/{entry_type}/{entry_id}", summary="删除配置条目 (最后一条需 confirm_purge=true)", response_model=ApiResponse[bool], ) async def delete_node_configuration( entry_type: str, entry_id: int, confirm_purge: bool = Query(False, description="最后一条数据确认删除标记"), db: AsyncSession = Depends(get_db), ): await NodeConfigurationService.delete_entry( db=db, entry_type=entry_type, entry_id=entry_id, confirm_purge=confirm_purge, ) return success(data=True, message="Node configuration deleted successfully") @admin_required_router.get( "/{entry_type}/{entry_id}/revisions", summary="获取配置条目修订历史记录", response_model=ApiResponse[List[Dict[str, Any]]], ) async def get_node_configuration_revisions( entry_type: str, entry_id: int, db: AsyncSession = Depends(get_db), ): revisions = await NodeConfigurationService.get_revisions( db=db, entry_type=entry_type, entry_id=entry_id ) return success(data=revisions) @admin_required_router.post( "/{entry_type}/{entry_id}/rollback", summary="回滚配置条目至指定历史修订版本", response_model=ApiResponse[Dict[str, Any]], ) async def rollback_node_configuration( entry_type: str, entry_id: int, payload: NodeConfigurationRollbackRequest = Body(...), current_user: Optional[VasUser] = Depends(get_current_user), db: AsyncSession = Depends(get_db), ): operator = ( current_user.email or current_user.nickname if current_user else "admin" ) entry = await NodeConfigurationService.rollback_revision( db=db, entry_type=entry_type, entry_id=entry_id, revision_id=payload.revision_id, base_version=payload.base_version, operator=operator, ) return success(data=entry, message="Node configuration rolled back successfully")