koishi-plugin-docker-control 0.0.1

package/lib/service/monitor.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonitorManager = void 0;
+const logger_1 = require("../utils/logger");
+class MonitorManager {
+    constructor(config = {}) {
+        this.config = config;
+        /** 容器状态映射: nodeId -> containerId -> State */
+        this.states = new Map();
+    }
+    /**
+     * 处理原始 Docker 事件
+     */
+    processEvent(node, event) {
+        if (event.Type !== 'container')
+            return;
+        const action = event.Action;
+        // 只关注核心生命周期事件
+        if (!['start', 'die', 'stop', 'restart'].includes(action))
+            return;
+        const containerId = event.Actor.ID;
+        const containerName = event.Actor.Attributes?.name || 'unknown';
+        // 获取容器状态存储
+        const state = this.getContainerState(node.id, containerId);
+        const now = Date.now();
+        // ---------------------------------------------------------
+        // 0. 屏蔽 restart 冗余事件
+        // 如果收到 restart，且距离上次 start 只有不到 3秒，说明是连在一起的，忽略 restart
+        // ---------------------------------------------------------
+        if (action === 'restart') {
+            if (state.lastStartTime && (now - state.lastStartTime < 3000)) {
+                logger_1.monitorLogger.debug(`[${node.name}] ${containerName} 忽略冗余 restart (刚启动)`);
+                return;
+            }
+        }
+        // 1. 记录历史用于抖动检测
+        state.history.push(now);
+        this.cleanHistory(state, now);
+        // 2. 抖动检测 (Flapping)
+        const threshold = this.config.flappingThreshold || 3;
+        if (state.history.length > threshold) {
+            logger_1.monitorLogger.warn(`[${node.name}] ${containerName} 频繁重启 (Flapping)`);
+            // 如果正在防抖等待中，立即清除定时器
+            if (state.stopTimer) {
+                clearTimeout(state.stopTimer);
+                state.stopTimer = undefined;
+            }
+            // 清空历史，避免重复触发 Flapping 报警
+            state.history = [];
+            // 发出 Flapping 事件
+            this.emit({
+                eventType: 'container.flapping',
+                action: 'flapping',
+                nodeId: node.id,
+                nodeName: node.name,
+                containerId,
+                containerName,
+                timestamp: now
+            });
+            return;
+        }
+        // 3. 防抖逻辑
+        const debounceWait = this.config.debounceWait || 60000;
+        if (action === 'die' || action === 'stop') {
+            // [关键修复] 如果已经有一个定时器在跑了，说明已经处理了 stop/die，
+            // 不要再重复打印日志或重置定时器了。
+            if (state.stopTimer) {
+                logger_1.monitorLogger.debug(`[${node.name}] ${containerName} 收到 ${action}，但已在等待停止确认中 (忽略)`);
+                return;
+            }
+            logger_1.monitorLogger.debug(`[${node.name}] ${containerName} 已停止 (${action})，等待 ${debounceWait}ms...`);
+            state.stopTimer = setTimeout(() => {
+                state.stopTimer = undefined;
+                // 只有定时器真正走完了，才发送通知
+                this.emit({
+                    eventType: `container.die`, // 统一使用 die
+                    action: 'die',
+                    nodeId: node.id,
+                    nodeName: node.name,
+                    containerId,
+                    containerName,
+                    timestamp: Date.now()
+                });
+            }, debounceWait);
+        }
+        else if (action === 'start' || action === 'restart') {
+            // [关键] 记录启动时间，用于屏蔽后续的 restart
+            state.lastStartTime = now;
+            if (state.stopTimer) {
+                // 在防抖时间内恢复：取消报警
+                clearTimeout(state.stopTimer);
+                state.stopTimer = undefined;
+                logger_1.monitorLogger.info(`[${node.name}] ${containerName} 在防抖时间内恢复，通知已抑制`);
+            }
+            else {
+                // 这是一个"干净"的启动（比如手动启动一个已停止很久的容器）
+                this.emit({
+                    eventType: `container.${action}`,
+                    action: action,
+                    nodeId: node.id,
+                    nodeName: node.name,
+                    containerId,
+                    containerName,
+                    timestamp: now
+                });
+            }
+        }
+    }
+    /**
+     * 注册处理后事件的回调
+     */
+    onProcessedEvent(callback) {
+        this.callback = callback;
+        return () => { this.callback = undefined; };
+    }
+    emit(event) {
+        if (this.callback) {
+            this.callback(event);
+        }
+    }
+    getContainerState(nodeId, containerId) {
+        if (!this.states.has(nodeId)) {
+            this.states.set(nodeId, new Map());
+        }
+        const nodeStates = this.states.get(nodeId);
+        if (!nodeStates.has(containerId)) {
+            nodeStates.set(containerId, {
+                history: []
+            });
+        }
+        return nodeStates.get(containerId);
+    }
+    cleanHistory(state, now) {
+        const window = this.config.flappingWindow || 300000; // 默认 5分钟
+        // 移除超出时间窗口的记录
+        state.history = state.history.filter(t => now - t <= window);
+    }
+}
+exports.MonitorManager = MonitorManager;

package/lib/service/node.d.ts

@@ -0,0 +1,119 @@
+import type { NodeConfig, ContainerInfo, DockerEvent, NodeStatusType, CredentialConfig } from '../types';
+export declare class DockerNode {
+    /** 节点配置 */
+    readonly config: NodeConfig;
+    /** 节点状态 */
+    status: NodeStatusType;
+    /** SSH 连接器 */
+    private connector;
+    /** 监控定时器 (容器状态轮询) */
+    private monitorTimer;
+    /** 事件监控定时器 (docker events) */
+    private eventTimer;
+    /** 上次事件查询时间 */
+    private lastEventTime;
+    /** 上次容器状态快照 */
+    private lastContainerStates;
+    /** 事件回调 */
+    private eventCallbacks;
+    /** Debug 模式 */
+    private debug;
+    /** 凭证配置 */
+    private credential;
+    /** 用于事件去重: 记录 "ID:Action:Time" -> Timestamp */
+    private eventDedupMap;
+    /** [新增] 实例唯一标识，用于判断是否存在多实例冲突 */
+    private instanceId;
+    constructor(config: NodeConfig, credential: CredentialConfig, debug?: boolean);
+    /**
+     * 连接到 Docker (带重试)
+     */
+    connect(): Promise<void>;
+    /**
+     * 断开连接
+     */
+    disconnect(): Promise<void>;
+    /**
+     * 重新连接
+     */
+    reconnect(): Promise<void>;
+    /**
+     * 列出容器
+     */
+    listContainers(all?: boolean): Promise<ContainerInfo[]>;
+    /**
+     * 启动容器
+     */
+    startContainer(containerId: string): Promise<void>;
+    /**
+     * 停止容器
+     */
+    stopContainer(containerId: string, timeout?: number): Promise<void>;
+    /**
+     * 重启容器
+     */
+    restartContainer(containerId: string, timeout?: number): Promise<void>;
+    /**
+     * 获取容器日志
+     */
+    getContainerLogs(containerId: string, tail?: number): Promise<string>;
+    /**
+     * 执行容器内命令
+     */
+    execContainer(containerId: string, cmd: string): Promise<string>;
+    /**
+     * 解析 docker ps 输出
+     */
+    private parseContainerList;
+    /**
+     * 映射容器状态
+     */
+    private mapState;
+    /**
+     * 启动监控 (容器状态轮询 + 事件流监听)
+     */
+    private startMonitoring;
+    /**
+     * 启动 Docker 事件流监听
+     */
+    private startEventStream;
+    /**
+     * 处理事件流中的一行数据
+     */
+    private handleEventLine;
+    /**
+     * 初始化容器状态快照
+     */
+    private initializeContainerStates;
+    /**
+     * 检测容器状态变更并发送通知
+     */
+    private checkContainerStateChanges;
+    /**
+     * 轮询 Docker 事件
+     */
+    private pollEvents;
+    /**
+     * 停止监控
+     */
+    private stopMonitoring;
+    /**
+     * 订阅事件
+     */
+    onEvent(callback: (event: DockerEvent) => void): () => void;
+    /**
+     * 触发事件
+     */
+    private emitEvent;
+    /**
+     * 清理定时器
+     */
+    private clearTimers;
+    /**
+     * 销毁节点
+     */
+    dispose(): Promise<void>;
+    get name(): string;
+    get id(): string;
+    get tags(): string[];
+}