koishi-plugin-docker-control 0.0.1

package/lib/service/node.js

@@ -0,0 +1,509 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerNode = void 0;
+/**
+ * Docker 节点类 - 通过 SSH 执行 docker 命令
+ */
+const koishi_1 = require("koishi");
+const constants_1 = require("../constants");
+const connector_1 = require("./connector");
+const logger_1 = require("../utils/logger");
+// 容器事件类型映射
+const CONTAINER_ACTIONS = ['start', 'stop', 'restart', 'die', 'create', 'destroy', 'pause', 'unpause', 'health_status'];
+class DockerNode {
+    constructor(config, credential, debug = false) {
+        /** 节点状态 */
+        this.status = constants_1.NodeStatus.DISCONNECTED;
+        /** SSH 连接器 */
+        this.connector = null;
+        /** 监控定时器 (容器状态轮询) */
+        this.monitorTimer = null;
+        /** 事件监控定时器 (docker events) */
+        this.eventTimer = null;
+        /** 上次事件查询时间 */
+        this.lastEventTime = 0;
+        /** 上次容器状态快照 */
+        this.lastContainerStates = new Map();
+        /** 事件回调 */
+        this.eventCallbacks = new Set();
+        /** Debug 模式 */
+        this.debug = false;
+        /** 用于事件去重: 记录 "ID:Action:Time" -> Timestamp */
+        this.eventDedupMap = new Map();
+        /** [新增] 实例唯一标识，用于判断是否存在多实例冲突 */
+        this.instanceId = koishi_1.Random.id(4);
+        this.config = config;
+        this.credential = credential;
+        this.debug = debug;
+    }
+    /**
+     * 连接到 Docker (带重试)
+     */
+    async connect() {
+        if (this.status === constants_1.NodeStatus.CONNECTING) {
+            logger_1.nodeLogger.warn(`[${this.name}] 节点正在连接中，跳过`);
+            return;
+        }
+        this.status = constants_1.NodeStatus.CONNECTING;
+        let attempt = 0;
+        let lastError = null;
+        while (attempt < constants_1.MAX_RETRY_COUNT) {
+            attempt++;
+            logger_1.nodeLogger.info(`[${this.name}] 连接尝试 ${attempt}/${constants_1.MAX_RETRY_COUNT}...`);
+            try {
+                // 创建 connector
+                const connector = new connector_1.DockerConnector(this.config, { credentials: [this.credential], nodes: [this.config] });
+                this.connector = connector;
+                // 测试 SSH 连接和 docker 命令
+                await connector.exec('docker version --format "{{.Server.Version}}"');
+                // 标记连接可用，允许事件流自动重连
+                connector.setConnected(true);
+                this.status = constants_1.NodeStatus.CONNECTED;
+                logger_1.nodeLogger.info(`[${this.name}] 连接成功`);
+                // 启动监控
+                this.startMonitoring();
+                // 触发上线事件
+                this.emitEvent({
+                    Type: 'node',
+                    Action: 'online',
+                    Actor: { ID: this.config.id, Attributes: {} },
+                    scope: 'local',
+                    time: Date.now(),
+                    timeNano: Date.now() * 1e6,
+                });
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                logger_1.nodeLogger.warn(`[${this.name}] 连接失败: ${lastError.message}`);
+                // 清理连接
+                this.connector?.dispose();
+                this.connector = null;
+                // 如果还有重试次数，等待后重试
+                if (attempt < constants_1.MAX_RETRY_COUNT) {
+                    await new Promise(resolve => setTimeout(resolve, constants_1.RETRY_INTERVAL));
+                }
+            }
+        }
+        // 所有重试都失败
+        this.status = constants_1.NodeStatus.ERROR;
+        logger_1.nodeLogger.error(`[${this.name}] 连接失败，已重试 ${constants_1.MAX_RETRY_COUNT} 次`);
+    }
+    /**
+     * 断开连接
+     */
+    async disconnect() {
+        this.stopMonitoring();
+        this.clearTimers();
+        this.connector?.dispose();
+        this.connector = null;
+        this.status = constants_1.NodeStatus.DISCONNECTED;
+        logger_1.nodeLogger.info(`[${this.name}] 已断开连接`);
+    }
+    /**
+     * 重新连接
+     */
+    async reconnect() {
+        await this.disconnect();
+        await this.connect();
+    }
+    /**
+     * 列出容器
+     */
+    async listContainers(all = true) {
+        if (!this.connector || this.status !== constants_1.NodeStatus.CONNECTED) {
+            throw new Error(`节点 ${this.name} 未连接`);
+        }
+        const output = await this.connector.listContainers(all);
+        return this.parseContainerList(output);
+    }
+    /**
+     * 启动容器
+     */
+    async startContainer(containerId) {
+        if (!this.connector)
+            throw new Error('未连接');
+        await this.connector.startContainer(containerId);
+    }
+    /**
+     * 停止容器
+     */
+    async stopContainer(containerId, timeout = 10) {
+        if (!this.connector)
+            throw new Error('未连接');
+        await this.connector.stopContainer(containerId, timeout);
+    }
+    /**
+     * 重启容器
+     */
+    async restartContainer(containerId, timeout = 10) {
+        if (!this.connector)
+            throw new Error('未连接');
+        await this.connector.restartContainer(containerId, timeout);
+    }
+    /**
+     * 获取容器日志
+     */
+    async getContainerLogs(containerId, tail = 100) {
+        if (!this.connector)
+            throw new Error('未连接');
+        return this.connector.getLogs(containerId, tail);
+    }
+    /**
+     * 执行容器内命令
+     */
+    async execContainer(containerId, cmd) {
+        if (!this.connector)
+            throw new Error('未连接');
+        return this.connector.execContainer(containerId, cmd);
+    }
+    /**
+     * 解析 docker ps 输出
+     */
+    parseContainerList(output) {
+        if (!output.trim())
+            return [];
+        return output.split('\n').filter(Boolean).map(line => {
+            const parts = line.split('|');
+            return {
+                Id: parts[0] || '',
+                Names: [parts[1] || ''],
+                Image: parts[2] || '',
+                State: this.mapState(parts[3] || ''),
+                Status: parts[4] || '',
+                ImageID: '',
+                Command: '',
+                Created: 0,
+                Ports: [],
+                Labels: {},
+                HostConfig: { NetworkMode: '' },
+                NetworkSettings: { Networks: {} },
+            };
+        });
+    }
+    /**
+     * 映射容器状态
+     */
+    mapState(state) {
+        const s = state.toLowerCase();
+        if (s.includes('up') || s.includes('running'))
+            return 'running';
+        if (s.includes('exited') || s.includes('stopped'))
+            return 'stopped';
+        if (s.includes('paused'))
+            return 'paused';
+        if (s.includes('restarting'))
+            return 'restarting';
+        return 'created';
+    }
+    /**
+     * 启动监控 (容器状态轮询 + 事件流监听)
+     */
+    startMonitoring() {
+        this.stopMonitoring();
+        // 初始化容器状态快照
+        this.initializeContainerStates();
+        // 事件流监听：使用 docker events 流式获取
+        this.startEventStream();
+        // 状态监控：每 60 秒检查容器状态并检测变更
+        // (用于捕获可能遗漏的状态变化，以及启动时的初始状态)
+        this.monitorTimer = setInterval(async () => {
+            if (this.status !== constants_1.NodeStatus.CONNECTED)
+                return;
+            try {
+                const containers = await this.listContainers(true);
+                this.checkContainerStateChanges(containers);
+            }
+            catch (e) {
+                logger_1.nodeLogger.warn(`[${this.name}] 监控失败: ${e}`);
+            }
+        }, constants_1.CONTAINER_POLL_INTERVAL);
+        logger_1.nodeLogger.info(`[${this.name}] 监控已启动 (事件流 + 每 ${constants_1.CONTAINER_POLL_INTERVAL / 1000} 秒状态检查)`);
+    }
+    /**
+     * 启动 Docker 事件流监听
+     */
+    startEventStream() {
+        if (!this.connector)
+            return;
+        // 防止并发启动：使用 _startingStream 标志
+        if (this._startingStream) {
+            logger_1.nodeLogger.debug(`[${this.name}] 事件流正在启动中，跳过`);
+            return;
+        }
+        ;
+        this._startingStream = true;
+        // 检查是否已有活跃的流
+        if (this._activeStreamCount > 0) {
+            logger_1.nodeLogger.debug(`[${this.name}] 已有 ${this._activeStreamCount} 个活跃事件流，跳过启动`);
+            this._startingStream = false;
+            return;
+        }
+        ;
+        this._activeStreamCount = this._activeStreamCount || 0;
+        this._activeStreamCount++;
+        logger_1.nodeLogger.debug(`[${this.name}] 启动事件流 (活跃数: ${this._activeStreamCount})`);
+        this.connector.startEventStream((line) => {
+            this.handleEventLine(line);
+        }).then((stop) => {
+            ;
+            this._eventStreamStop = stop;
+            this._startingStream = false;
+            logger_1.nodeLogger.debug(`[${this.name}] 事件流回调已注册`);
+        }).catch((err) => {
+            ;
+            this._activeStreamCount--;
+            this._startingStream = false;
+            logger_1.nodeLogger.warn(`[${this.name}] 事件流启动失败: ${err.message}，5秒后重试`);
+            setTimeout(() => this.startEventStream(), 5000);
+        });
+    }
+    /**
+     * 处理事件流中的一行数据
+     */
+    handleEventLine(line) {
+        try {
+            const rawEvent = JSON.parse(line);
+            const { Type: type, Action: action, Actor: actor, time, timeNano } = rawEvent;
+            // 只处理容器相关事件
+            if (type !== 'container')
+                return;
+            if (!CONTAINER_ACTIONS.includes(action))
+                return;
+            const containerId = actor?.ID;
+            const containerName = actor?.Attributes?.name;
+            // [去重逻辑] 使用 timeNano (纳秒) 确保唯一性
+            const eventTimeNano = timeNano || (time ? time * 1e9 : Date.now() * 1e6);
+            const dedupKey = `${containerId}:${action}:${eventTimeNano}`;
+            const lastTime = this.eventDedupMap.get(dedupKey);
+            const now = Date.now();
+            // 100ms 内收到完全相同的事件则忽略
+            if (lastTime && (now - lastTime < 100)) {
+                return;
+            }
+            this.eventDedupMap.set(dedupKey, now);
+            // 清理
+            if (this.eventDedupMap.size > 200)
+                this.eventDedupMap.clear();
+            // 跳过无法识别名称的容器
+            if (!containerName || containerName === 'unknown')
+                return;
+            const image = actor?.Attributes?.image;
+            // [关键] 对于 die 和 stop，都标记为 stopped，保持状态同步
+            if (actor?.ID) {
+                const inferredState = (action === 'start' || action === 'restart') ? 'running' : 'stopped';
+                this.lastContainerStates.set(actor.ID, inferredState);
+            }
+            const event = {
+                Type: type,
+                Action: action,
+                Actor: {
+                    ID: actor?.ID || '',
+                    Attributes: {
+                        name: containerName,
+                        image: image || '',
+                    },
+                },
+                scope: 'local',
+                time: time ? time * 1000 : Date.now(),
+                timeNano: timeNano || Date.now() * 1e6,
+            };
+            logger_1.nodeLogger.debug(`[${this.name}#${this.instanceId}] 事件流: ${containerName} ${action}`);
+            this.emitEvent(event);
+        }
+        catch (e) {
+            // 忽略非 JSON 行
+        }
+    }
+    /**
+     * 初始化容器状态快照
+     */
+    async initializeContainerStates() {
+        try {
+            const containers = await this.listContainers(true);
+            this.lastContainerStates.clear();
+            for (const c of containers) {
+                this.lastContainerStates.set(c.Id, c.State);
+            }
+            this.lastEventTime = Date.now();
+            logger_1.nodeLogger.debug(`[${this.name}] 初始化状态快照: ${this.lastContainerStates.size} 个容器`);
+        }
+        catch (e) {
+            logger_1.nodeLogger.warn(`[${this.name}] 初始化状态快照失败: ${e}`);
+        }
+    }
+    /**
+     * 检测容器状态变更并发送通知
+     */
+    checkContainerStateChanges(containers) {
+        const runningCount = containers.filter(c => c.State === 'running').length;
+        logger_1.nodeLogger.debug(`[${this.name}] 监控: ${runningCount} 个容器运行中`);
+        for (const c of containers) {
+            const lastState = this.lastContainerStates.get(c.Id);
+            const currentState = c.State;
+            // 状态发生变化
+            if (lastState !== undefined && lastState !== currentState) {
+                const containerName = c.Names[0]?.replace('/', '') || c.Id.slice(0, 8);
+                // 推断操作类型
+                let action;
+                if (lastState !== 'running' && currentState === 'running') {
+                    action = 'start';
+                }
+                else if (lastState === 'running' && currentState !== 'running') {
+                    action = 'stop';
+                }
+                else {
+                    action = currentState;
+                }
+                logger_1.nodeLogger.info(`[${this.name}] 状态变更: ${containerName} ${lastState} -> ${currentState}`);
+                // 发送事件通知
+                const event = {
+                    Type: 'container',
+                    Action: action,
+                    Actor: {
+                        ID: c.Id,
+                        Attributes: {
+                            name: containerName,
+                            image: c.Image,
+                        },
+                    },
+                    scope: 'local',
+                    time: Date.now(),
+                    timeNano: Date.now() * 1e6,
+                };
+                this.emitEvent(event);
+            }
+            // 更新状态快照
+            this.lastContainerStates.set(c.Id, currentState);
+        }
+    }
+    /**
+     * 轮询 Docker 事件
+     */
+    async pollEvents() {
+        if (!this.connector)
+            return;
+        try {
+            // 查询指定时间之后的事件
+            // 查询指定时间之后的事件 - 使用 JSON 格式以避免解析问题
+            const since = new Date(this.lastEventTime).toISOString();
+            const output = await this.connector.exec(`docker events --since "${since}" --format "{{json .}}" --filter "type=container"`);
+            this.lastEventTime = Date.now();
+            if (!output.trim())
+                return;
+            const lines = output.split('\n').filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const rawEvent = JSON.parse(line);
+                    const { Type: type, Action: action, Actor: actor, time, timeNano } = rawEvent;
+                    // 只处理容器相关事件
+                    if (type !== 'container')
+                        continue;
+                    if (!CONTAINER_ACTIONS.includes(action))
+                        continue;
+                    const containerName = actor?.Attributes?.name;
+                    const image = actor?.Attributes?.image;
+                    // 跳过无法识别名称的容器
+                    if (!containerName || containerName === 'unknown')
+                        continue;
+                    const event = {
+                        Type: type,
+                        Action: action,
+                        Actor: {
+                            ID: actor?.ID || '',
+                            Attributes: {
+                                name: containerName,
+                                image: image || '',
+                            },
+                        },
+                        scope: 'local',
+                        time: time ? time * 1000 : Date.now(), // docker event time is usually unix timestamp (seconds)
+                        timeNano: timeNano || Date.now() * 1e6,
+                    };
+                    logger_1.nodeLogger.debug(`[${this.name}] 事件: ${containerName} ${action}`);
+                    this.emitEvent(event);
+                }
+                catch (e) {
+                    logger_1.nodeLogger.warn(`[${this.name}] 解析事件失败: ${e} (Line: ${line})`);
+                }
+            }
+        }
+        catch (e) {
+            // 忽略事件查询错误（可能是没有新事件）
+            logger_1.nodeLogger.warn(`[${this.name}] 事件轮询失败: ${e}`);
+        }
+    }
+    /**
+     * 停止监控
+     */
+    stopMonitoring() {
+        // 停止状态轮询
+        if (this.monitorTimer) {
+            clearInterval(this.monitorTimer);
+            this.monitorTimer = null;
+        }
+        // 停止事件流
+        if (this._eventStreamStop) {
+            ;
+            this._eventStreamStop();
+            this._eventStreamStop = null;
+        }
+        // 重置事件流计数
+        ;
+        this._activeStreamCount = 0;
+        this._startingStream = false;
+        // 停止重试定时器
+        if (this.eventTimer) {
+            clearTimeout(this.eventTimer);
+            this.eventTimer = null;
+        }
+        // 标记连接断开，防止自动重连
+        if (this.connector) {
+            this.connector.setConnected(false);
+        }
+    }
+    /**
+     * 订阅事件
+     */
+    onEvent(callback) {
+        this.eventCallbacks.add(callback);
+        return () => this.eventCallbacks.delete(callback);
+    }
+    /**
+     * 触发事件
+     */
+    emitEvent(event) {
+        for (const callback of this.eventCallbacks) {
+            try {
+                callback(event);
+            }
+            catch (e) {
+                logger_1.nodeLogger.error(`[${this.name}] 事件回调错误: ${e}`);
+            }
+        }
+    }
+    /**
+     * 清理定时器
+     */
+    clearTimers() {
+        if (this.monitorTimer) {
+            clearInterval(this.monitorTimer);
+            this.monitorTimer = null;
+        }
+        if (this.eventTimer) {
+            clearInterval(this.eventTimer);
+            this.eventTimer = null;
+        }
+    }
+    /**
+     * 销毁节点
+     */
+    async dispose() {
+        await this.disconnect();
+        this.eventCallbacks.clear();
+    }
+    get name() { return this.config.name; }
+    get id() { return this.config.id; }
+    get tags() { return this.config.tags; }
+}
+exports.DockerNode = DockerNode;

package/lib/service/notifier.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 通知器
+ * 负责组装消息模板并调用 Bot 发送
+ */
+import { Context } from 'koishi';
+import type { NotificationEventType, NotificationConfig } from '../types';
+export declare class Notifier {
+    /** Koishi Context */
+    private readonly ctx;
+    /** 通知配置 */
+    private readonly config;
+    constructor(ctx: Context, config: NotificationConfig);
+    /**
+     * 发送通知
+     */
+    send(eventType: NotificationEventType, data: any): Promise<void>;
+    /**
+     * 构建消息
+     */
+    private buildMessage;
+    /**
+     * 获取容器状态 Emoji
+     */
+    private getContainerEmoji;
+    /**
+     * 获取目标频道
+     */
+    private getTargetChannels;
+    /**
+     * 发送自定义消息
+     */
+    notifyCustom(content: string, targets?: string[]): Promise<void>;
+}