echoapi-cron-scheduler-batch 1.0.8 → 1.0.10

package/index.js

@@ -11,32 +11,79 @@ const { v4: uuidv4 } = require('uuid');
 const { execSync } = require('child_process');
 
 /**
- * CronScheduler - 企业级多进程自动化测试调度器
+ * CronScheduler - 企业级多进程自动化测试调度器 (生产增强版)
  */
 class CronScheduler {
-    constructor(config = {}) {
-        // 配置初始化
-        this.apiUrl = config.apiUrl || process?.env["OPENAPI_DOMAIN"] || "https://ee.apipost.cc";
-        this.dbFile = config.dbPath || path.resolve(process?.env?.TEMP_DIR || os.tmpdir(), 'echoapi-batch-tasks.sqlite');
-        this.workerNum = config.workerNum || os.cpus().length;
-
-        // 结果聚合收集器：用于收集同一批次下所有 Runner 的结果
-        this.resultCollector = new Map();
-
-        if (cluster.isPrimary) {
-            this.db = new Database(this.dbFile);
-            this._initDB();
-        }
+  constructor(config = {}) {
+    // 1. 配置初始化
+    this.apiUrl = config.apiUrl || process?.env["OPENAPI_DOMAIN"] || "https://ee.apipost.cc";
+
+    // 【优化】不要直接放 /tmp，在项目目录下创建持久化 data 目录
+    const dataDir = path.resolve(process?.env?.TEMP_DIR || os.tmpdir(), 'scheduler_data');
+    if (cluster.isPrimary && !fs.existsSync(dataDir)) {
+      fs.mkdirSync(dataDir, { recursive: true });
     }
 
-    /**
-     * 内部方法：初始化数据库表结构
-     */
-    _initDB() {
-        // 1. 任务配置表
+    this.dbFile = config.dbPath || path.join(dataDir, 'echoapi-batch-tasks.sqlite');
+    this.workerNum = config.workerNum || os.cpus().length;
+
+    // 结果聚合收集器 (仅在 Master 内存中存在)
+    this.resultCollector = new Map();
 
-        this.db.pragma('journal_mode = WAL');
-        this.db.prepare(`
+    // 2. 数据库连接与安全自检 (仅 Master 进程持有写连接)
+    if (cluster.isPrimary) {
+      this._connectDB();
+    }
+  }
+
+  /**
+   * 内部方法：建立数据库连接并增加损坏自动修复逻辑
+   */
+  _connectDB() {
+    try {
+      // 预检：如果是 0 字节损坏文件，直接删除
+      if (fs.existsSync(this.dbFile) && fs.statSync(this.dbFile).size === 0) {
+        fs.unlinkSync(this.dbFile);
+      }
+
+      this.db = new Database(this.dbFile, { timeout: 10000 });
+
+      // 【核心】执行完整性自检，解决 malformed 和 not a database 问题
+      const check = this.db.pragma('integrity_check');
+      if (check[0].integrity_check !== 'ok') {
+        throw new Error('SQLite integrity check failed');
+      }
+
+      this._initDB();
+      console.log(`[Database] Connection verified and initialized.`);
+    } catch (e) {
+      console.error(`[Database Critical] 数据库损坏(Malformed/NotADb): ${e.message}`);
+      if (this.db) this.db.close();
+
+      // 自动备份损坏文件，腾出位置重建
+      const backupPath = `${this.dbFile}.corrupted_${Date.now()}`;
+      if (fs.existsSync(this.dbFile)) {
+        fs.renameSync(this.dbFile, backupPath);
+      }
+
+      // 重建数据库
+      this.db = new Database(this.dbFile);
+      this._initDB();
+      console.warn(`[Database] 坏库已隔离至 ${backupPath}，新库已就绪。`);
+    }
+  }
+
+  /**
+   * 初始化表结构与性能参数
+   */
+  _initDB() {
+    // 性能调优：WAL 模式能极大减少多进程读取时的锁竞争
+    this.db.pragma('journal_mode = WAL');
+    this.db.pragma('synchronous = NORMAL');
+    this.db.pragma('busy_timeout = 5000');
+
+    // 1. 任务配置表
+    this.db.prepare(`
             CREATE TABLE IF NOT EXISTS jobs (
                 job_id TEXT PRIMARY KEY,
                 name TEXT,
@@ -44,13 +91,13 @@ class CronScheduler {
                 is_cancel INTEGER DEFAULT 0,
                 api_token TEXT,
                 project_id TEXT,
-                cases TEXT,           -- 存储 runners 数组 JSON
+                cases TEXT,
                 create_dtime INTEGER
             )
         `).run();
 
-        // 2. 新增：中间结果结果暂存表 (用于卸载 Master 内存压力)
-        this.db.prepare(`
+    // 2. 中间结果暂存表 (Master 写入，聚合后删除)
+    this.db.prepare(`
             CREATE TABLE IF NOT EXISTS task_results (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 execution_id TEXT,
@@ -58,649 +105,361 @@ class CronScheduler {
                 create_at INTEGER
             )
         `).run();
-        this.db.prepare(`CREATE INDEX IF NOT EXISTS idx_exec_id ON task_results(execution_id)`).run();
+    this.db.prepare(`CREATE INDEX IF NOT EXISTS idx_exec_id ON task_results(execution_id)`).run();
+  }
+
+  run() {
+    if (cluster.isPrimary) {
+      this._startMaster();
+    } else {
+      this._startWorker();
     }
-
-    /**
-     * 核心启动入口
-     */
-    run() {
-        if (cluster.isPrimary) {
-            this._startMaster();
-        } else {
-            this._startWorker();
-        }
-    }
-    /**
-   * Converts timestamp to ISO format
-   */
-    formatTimeToISO(time) {
-        const dayjs = require('dayjs');
-        const utc = require('dayjs/plugin/utc');
-        const timezone = require('dayjs/plugin/timezone');
-        dayjs.extend(utc);
-        dayjs.extend(timezone);
-        return dayjs(time).tz('Asia/Shanghai').format();
+  }
+
+  formatTimeToISO(time) {
+    if (!time) return null;
+    try {
+      const dayjs = require('dayjs');
+      const utc = require('dayjs/plugin/utc');
+      const timezone = require('dayjs/plugin/timezone');
+      dayjs.extend(utc);
+      dayjs.extend(timezone);
+      return dayjs(time).tz('Asia/Shanghai').format();
+    } catch (e) {
+      return new Date(time).toISOString();
     }
+  }
 
-    // ==========================================
-    // Master 进程逻辑：负责任务分发与结果聚合
-    // ==========================================
-
-    _startMaster() {
-        console.log(`[CronScheduler] Master process ${process.pid} is running.`);
-
-        // 衍生子进程
-        for (let i = 0; i < this.workerNum; i++) {
-            this._bindWorker(cluster.fork());
-        }
+  // ==========================================
+  // Master 进程逻辑：单点读写
+  // ==========================================
 
-        // 进程自动重启逻辑
-        cluster.on('exit', (worker) => {
-            console.warn(`[CronScheduler] Worker ${worker.process.pid} died. Forking a new one...`);
-            this._bindWorker(cluster.fork());
-        });
+  _startMaster() {
+    console.log(`[CronScheduler] Master ${process.pid} is running.`);
 
-        // 启动时自动加载数据库中的任务
-        this.loadJobs();
+    for (let i = 0; i < this.workerNum; i++) {
+      this._bindWorker(cluster.fork());
     }
 
-    _bindWorker(worker) {
-        worker.on('message', async (msg) => {
-            if (msg.action === 'UNIT_COMPLETED') {
-                const { executionId, data } = msg.payload;
-                const record = this.resultCollector.get(executionId);
-
-                if (record) {
-
-                    // record.received.push(_.assign(data, {
-                    //     source: 'scheduled',
-                    //     start_at: this.formatTimeToISO(data?.start_at),
-                    //     end_at: this.formatTimeToISO(data?.end_at)
-                    // }));
-                    // // 检查是否收齐了该 Job 下所有的 runners 结果
-                    // if (record.received.length >= record.total) {
-                    //     await this._reportAggregated(executionId, record);
-                    // }
-                    try {
-                        // 【关键优化】不再存入内存 Map，而是存入 SQLite 临时表
-                        this.db.prepare(`INSERT INTO task_results (execution_id, data, create_at) VALUES (?, ?, ?)`)
-                            .run(executionId, JSON.stringify(data), Date.now());
-
-                        record.received_count++;
-                        console.log(record.total, record.received_count, 'record.received_count');
-
-                        // 检查是否收齐
-                        if (record.received_count >= record.total) {
-                            await this._reportFromDB(executionId, record);
-                        }
-                    } catch (e) {
-                        console.error(`[Master Result Collect Error]`, e.message);
-                    }
-                }
-            }
-        });
-    }
+    cluster.on('exit', (worker, code) => {
+      console.warn(`[CronScheduler] Worker ${worker.process.pid} died (code:${code}). Forking...`);
+      this._bindWorker(cluster.fork());
+    });
 
-    /**
-     * 将聚合后的结果一次性推送到 OpenAPI
-     */
-    // async _reportAggregated(executionId, record) {
-    //     try {
-
-    //         const results = record.received;
-    //         const endTime = Date.now();
-
-    //         // --- 核心统计逻辑 ---
-    //         let stats = {
-    //             http_total: 0,
-    //             http_success: 0,
-    //             assert_total: 0,
-    //             assert_success: 0,
-    //             total_response_time: 0,
-    //             count: 0
-    //         };
-
-    //         results.forEach(item => {
-    //             // 累加 HTTP 统计
-    //             stats.http_total += (item.http?.total || 0);
-    //             stats.http_success += (item.http?.success || 0);
-
-    //             // 累加 断言 统计
-    //             stats.assert_total += (item.assert?.total || 0);
-    //             stats.assert_success += (item.assert?.success || 0);
-
-    //             // 累加 响应时间 用于计算平均值
-    //             stats.total_response_time += (item.total_response_time || 0);
-    //             stats.count++;
-    //         });
-
-    //         // 计算通过率 (保留两位小数)
-    //         const httpPassRate = stats.http_total > 0
-    //             ? ((stats.http_success / stats.http_total) * 100).toFixed(2)
-    //             : "0.00";
-
-    //         const assertPassRate = stats.assert_total > 0
-    //             ? ((stats.assert_success / stats.assert_total) * 100).toFixed(2)
-    //             : "0.00";
-
-    //         // 计算平均响应时间
-    //         const avgResponseTime = stats.count > 0
-    //             ? (stats.total_response_time / stats.count).toFixed(0)
-    //             : 0;
-
-    //         // --- 封装最终 Payload ---
-    //         const finalPayload = {
-    //             info: {
-    //                 job_id: record.job_info.job_id,
-    //                 report_name: record.job_info.name,
-    //                 project_id: record.job_info.project_id,
-    //                 execution_id: executionId,
-    //                 start_at: this.formatTimeToISO(record.job_info.start_time),
-    //                 end_at: this.formatTimeToISO(endTime),
-
-    //                 // 业务统计字段
-    //                 http_pass_rate: `${httpPassRate}%`,
-    //                 assert_pass_rate: `${assertPassRate}%`,
-    //                 avg_response_time: `${avgResponseTime}ms`,
-
-    //                 // 原始计数
-    //                 total_http: stats.http_total,
-    //                 success_http: stats.http_success,
-    //                 total_assert: stats.assert_total,
-    //                 success_assert: stats.assert_success,
-
-    //                 total_units: record.total,
-    //                 actual_units: results.length
-    //             },
-    //             results: results // 原始详细列表
-    //         };
-
-    //         // 写入本地备份，增加 try-catch 避免权限问题
-    //         try {
-    //             // fs.writeFileSync('last_report.json', JSON.stringify(finalPayload));
-    //         } catch (e) { }
-
-    //         console.log(`[CronScheduler] Batch job finished. ExecutionID: ${executionId}. Aggregating ${record.total} results...`);
-    //         // console.log(`[CronScheduler] TOKEN ${record.api_token}`);
-
-    //         const response = await axios.post(`${this.apiUrl}/open/hnzycfc/scheduled_task/report/add`, finalPayload, {
-    //             headers: {
-    //                 'Content-Type': 'application/json',
-    //                 'api-token': record.api_token
-    //             }
-    //         });
-    //         if (response?.data?.code != 0) {
-    //             console.log(`Execution Id  ${executionId} reporting error: ${response?.data?.msg}`);
-    //         } else {
-    //             console.log(`Execution Id ${executionId} reported success...`);
-    //         }
-    //     } catch (err) {
-    //         console.error(`[CronScheduler] Report aggregation failed:`, err.message);
-    //     } finally {
-    //         this.resultCollector.delete(executionId); // 清理内存
-    //         console.info(`[CronScheduler] Result collector cleared for ${executionId}`);
-    //     }
-    // }
-    /**
-     * 查看当前所有待执行（活跃）的任务及其详细信息
-     */
-    getPendingJobs() {
-        // 1. 从内存中获取 node-schedule 注册的所有 job_id
-        const activeTimerIds = Object.keys(schedule.scheduledJobs);
-
-        if (activeTimerIds.length === 0) {
-            return [];
-        }
-
-        // 2. 从数据库中查询这些活跃任务的详细配置
-        // 使用 IN 语句批量查询，效率更高
-        const placeholders = activeTimerIds.map(() => '?').join(',');
-        const query = `SELECT job_id, name, frequency, project_id, create_dtime FROM jobs WHERE job_id IN (${placeholders}) AND is_cancel < 1`;
-
-        try {
-            const jobs = this.db.prepare(query).all(...activeTimerIds);
-
-            // 3. 结合内存中的下次执行时间进行封装
-            return _.map(jobs, job => {
-                const cronRule = this.convertToCron(JSON5.parse(job.frequency));
-                const nextTime = this.getNextExecutionTime(cronRule);
-
-                return {
-                    job_id: job.job_id,
-                    name: job.name,
-                    project_id: job.project_id,
-                    cron: cronRule,
-                    next_run_at: typeof nextTime === 'number' ? new Date(nextTime).toLocaleString() : nextTime,
-                    timestamp: nextTime // 方便前端排序
-                };
-            }).sort((a, b) => (a.timestamp - b.timestamp)); // 按执行时间先后排序
-        } catch (e) {
-            console.error('[View Jobs Error]', e.message);
-            return [];
-        }
-    }
-
-    /**
-     * 增量更新定时器：解决时间漂移和重复触发的关键
-     */
-    upsertTimer(job_id, name, frequency, jobData) {
-        // 1. 如果已存在，先取消旧的内存定时器
-        if (schedule.scheduledJobs[job_id]) {
-            schedule.scheduledJobs[job_id].cancel();
-        }
+    this.loadJobs();
+  }
 
-        // 2. 如果任务未被取消 (is_cancel < 1)
-        if (jobData && jobData.is_cancel < 1) {
-            try {
-                const freq = typeof frequency === 'string' ? JSON5.parse(frequency) : frequency;
-                const cronRule = this.convertToCron(freq);
-
-                // 重新创建定时器
-                schedule.scheduleJob(job_id, cronRule, () => {
-                    const now = new Date().toLocaleString();
-                    console.log(`[Timer Triggered] ${name} (${job_id}) at ${now}`);
-
-                    // 触发时重新从数据库获取最新数据，确保分发的是最新的 runners
-                    const currentJob = this.db.prepare(`SELECT * FROM jobs WHERE job_id = ?`).get(job_id);
-                    if (currentJob && currentJob.is_cancel < 1) {
-                        this._dispatch(currentJob);
-                    }
-                });
-            } catch (e) {
-                console.error(`[CronScheduler] Upsert timer error (ID: ${job_id}):`, e.message);
-            }
-        }
-    }
+  _bindWorker(worker) {
+    worker.on('message', async (msg) => {
+      if (msg.action === 'UNIT_COMPLETED') {
+        const { executionId, data } = msg.payload;
+        const record = this.resultCollector.get(executionId);
 
-    // ==========================================
-    // 公共接口：供 Express 路由层调用
-    // ==========================================
+        if (record) {
+          try {
+            // 【单进程写入】只有 Master 负责操作数据库，规避并发写导致的损坏
+            this.db.prepare(`INSERT INTO task_results (execution_id, data, create_at) VALUES (?, ?, ?)`)
+              .run(executionId, JSON.stringify(data), Date.now());
 
-    /**
-     * 创建或更新任务
-     */
-    createJob(payload) {
-        const { job_id, name, frequency, api_token, project_id, runners } = payload;
-        const casesJson = JSON.stringify(Array.isArray(runners) ? runners : []);
-        const freqJson = JSON.stringify(frequency);
+            // 计数检查
+            if (typeof record.received_count !== 'number') record.received_count = 0;
+            record.received_count++;
 
-        const stmt = this.db.prepare(`
-            INSERT INTO jobs (job_id, name, frequency, api_token, project_id, cases,  create_dtime)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(job_id) DO UPDATE SET
-                name=excluded.name,
-                frequency=excluded.frequency,
-                cases=excluded.cases,
-                api_token=excluded.api_token,
-                is_cancel=0
-        `);
-        stmt.run(job_id, name, freqJson, api_token, project_id, casesJson, Date.now());
+            console.log(`[Progress] ${executionId}: ${record.received_count}/${record.total}`);
 
-        // 使用增量更新，不再 loadJobs()
-        this.upsertTimer(job_id, name, frequency, { is_cancel: 0 });
-        return true;
-    }
-
-    cancelJob(job_id) {
-        this.db.prepare(`UPDATE jobs SET is_cancel = 1 WHERE job_id = ?`).run(job_id);
-        if (schedule.scheduledJobs[job_id]) {
-            schedule.scheduledJobs[job_id].cancel();
+            if (record.received_count >= record.total) {
+              await this._reportFromDB(executionId, record);
+            }
+          } catch (e) {
+            console.error(`[Master DB Write Error]`, e.message);
+          }
         }
-        return true;
+      }
+    });
+  }
+
+  async _reportFromDB(executionId, record) {
+    try {
+      console.log(`[CronScheduler] Aggregating results for: ${executionId}`);
+      const rows = this.db.prepare(`SELECT data FROM task_results WHERE execution_id = ?`).all(executionId);
+
+      let stats = {
+        http_total: 0, http_success: 0,
+        assert_total: 0, assert_success: 0,
+        total_resp_time: 0
+      };
+
+      const results = rows.map(row => {
+        const item = JSON.parse(row.data);
+        stats.http_total += (item.http?.total || 0);
+        stats.http_success += (item.http?.success || 0);
+        stats.assert_total += (item.assert?.total || 0);
+        stats.assert_success += (item.assert?.success || 0);
+        stats.total_resp_time += (item.total_response_time || 0);
+
+        return _.assign(item, {
+          source: 'scheduled',
+          start_at: this.formatTimeToISO(item?.start_at),
+          end_at: this.formatTimeToISO(item?.end_at)
+        });
+      });
+
+      const httpRate = stats.http_total > 0 ? ((stats.http_success / stats.http_total) * 100).toFixed(2) : "0.00";
+      const assertRate = stats.assert_total > 0 ? ((stats.assert_success / stats.assert_total) * 100).toFixed(2) : "0.00";
+      const avgResp = results.length > 0 ? (stats.total_resp_time / results.length).toFixed(0) : 0;
+
+      const finalPayload = {
+        info: {
+          job_id: record.job_info.job_id,
+          report_name: record.job_info.name,
+          project_id: record.job_info.project_id,
+          execution_id: executionId,
+          start_at: this.formatTimeToISO(record.job_info.start_time),
+          end_at: this.formatTimeToISO(Date.now()),
+          http_pass_rate: `${httpRate}%`,
+          assert_pass_rate: `${assertRate}%`,
+          avg_response_time: `${avgResp}ms`,
+          total_http: stats.http_total,
+          success_http: stats.http_success,
+          total_assert: stats.assert_total,
+          success_assert: stats.assert_success,
+          total_units: record.total,
+          actual_units: results.length
+        },
+        results: results
+      };
+
+      const response = await axios.post(`${this.apiUrl}/open/hnzycfc/scheduled_task/report/add`, finalPayload, {
+        headers: { 'Content-Type': 'application/json', 'api-token': record.api_token },
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+        timeout: 60000 // 聚合报告可能很大，增加超时时间
+      });
+
+      if (response?.data?.code == 0) {
+        console.log(`[CronScheduler] Execution ${executionId} Success.`);
+        // 上报成功后清理中间数据
+        this.db.prepare(`DELETE FROM task_results WHERE execution_id = ?`).run(executionId);
+      } else {
+        console.error(`[Report Error] ${executionId}: ${response?.data?.msg}`);
+      }
+    } catch (err) {
+      console.error(`[Aggregation Error]`, err.stack);
+    } finally {
+      this.resultCollector.delete(executionId);
     }
-
-    restartJob(job_id) {
-        this.db.prepare(`UPDATE jobs SET is_cancel = 0 WHERE job_id = ?`).run(job_id);
-        const job = this.db.prepare(`SELECT * FROM jobs WHERE job_id = ?`).get(job_id);
-        if (job) {
-            this.upsertTimer(job.job_id, job.name, job.frequency, job);
+  }
+
+  _dispatch(job) {
+    try {
+      const runners = JSON5.parse(job.cases || '[]');
+      if (runners.length === 0) return;
+
+      const executionId = `${job.job_id}_${Date.now()}`;
+      this.resultCollector.set(executionId, {
+        total: runners.length,
+        received_count: 0,
+        api_token: job.api_token,
+        job_info: {
+          job_id: job.job_id,
+          name: job.name,
+          project_id: job.project_id,
+          start_time: Date.now()
         }
-        return true;
-    }
-
-    deleteJob(job_id) {
-        this.db.prepare(`DELETE FROM jobs WHERE job_id = ?`).run(job_id);
-        if (schedule.scheduledJobs[job_id]) {
-            schedule.scheduledJobs[job_id].cancel();
+      });
+
+      const activeWorkers = Object.values(cluster.workers).filter(w => w.isConnected());
+      runners.forEach((runner, index) => {
+        const worker = _.sample(activeWorkers);
+        if (worker) {
+          worker.send({
+            action: 'EXECUTE_UNIT',
+            payload: { executionId, api_token: job.api_token, test_events: runner.test_events, option: runner.option, unit_index: index }
+          });
         }
-        return true;
-    }
-
-    getAllJobs(project_id) {
-        const jobs = this.db.prepare(`SELECT * FROM jobs WHERE project_id = ?`).all(project_id);
-        // 返回列表时剔除巨大的 cases 字段，优化内存
-        return _.map(jobs, job => {
-            const freq = JSON5.parse(job.frequency || '{}');
-            const cases = JSON5.parse(job.cases || '[]');
-            const cronRule = this.convertToCron(freq);
-
-            // 获取下次执行时间
-            // 如果任务已取消，则不显示下次执行时间
-            let nextRunTime = '-';
-            if (job.is_cancel < 1) {
-                nextRunTime = this.getNextExecutionTime(cronRule);
+      });
+    } catch (e) { console.error(`[Dispatch Error]:`, e.message); }
+  }
+
+  // ==========================================
+  // Worker 进程逻辑：仅负责计算，不碰数据库
+  // ==========================================
+
+  _startWorker() {
+    console.log(`[Worker ${process.pid}] Ready.`);
+    const { run: runner } = require('runner-runtime');
+    const net = require('net');
+
+    process.on('message', async (msg) => {
+      if (msg.action === 'EXECUTE_UNIT') {
+        const { executionId, api_token, test_events, option } = msg.payload;
+        const socketPath = path.join(os.tmpdir(), `ea_${uuidv4().slice(0, 8)}.sock`);
+
+        const server = net.createServer((socket) => {
+          socket.on('data', async (stream) => {
+            try {
+              const info = JSON.parse(stream.toString());
+              await this._handleUnitScript(socket, info.action, info.data);
+            } catch (e) {
+              if (!socket.destroyed) socket.write(JSON.stringify({ status: 'error', message: e.message }) + "\n\n");
             }
-
-            return {
-                ..._.omit(job, ['cases']), // 排除大数据字段
-                status: job.is_cancel === 0 ? 0 : 1, // 0:运行中, 1:已暂停
-                next_run_time: nextRunTime,
-                frequency_display: cronRule, // 返回原始 Cron 规则供前端参考
-                runners: _.map(cases, (v) => v?.option?.testing_id)
-            };
+          });
         });
-    }
 
-    loadJobs() {
-        console.log('[CronScheduler] Initializing timers from database...');
-        // 启动时全量清理一次
-        Object.values(schedule.scheduledJobs).forEach(j => j.cancel());
+        server.on('error', (err) => console.error(`[Socket Server Error] PID ${process.pid}: ${err.message}`));
 
-        const jobs = this.db.prepare(`SELECT * FROM jobs WHERE is_cancel < 1`).all();
-        jobs.forEach(job => {
-            this.upsertTimer(job.job_id, job.name, job.frequency, job);
-        });
-    }
+        server.listen(socketPath, () => {
+          const finalOptions = _.cloneDeep(option || {});
+          const base64Pipe = Buffer.from(socketPath).toString('base64');
+          _.set(finalOptions, 'env.ELECTRON_PIPE', base64Pipe);
 
-    /**
-     * 从数据库提取数据并聚合报告
-     */
-    async _reportFromDB(executionId, record) {
-        try {
-            console.log(`[CronScheduler] Batch job finished. Aggregating results from DB for: ${executionId}`);
-
-            // 1. 从 DB 读取该执行批次的所有结果
-            const rows = this.db.prepare(`SELECT data FROM task_results WHERE execution_id = ?`).all(executionId);
-
-            let stats = {
-                http_total: 0, http_success: 0,
-                assert_total: 0, assert_success: 0,
-                total_resp_time: 0
-            };
-
-            // 2. 转换数据并计算统计信息
-            const results = rows.map(row => {
-                const item = JSON.parse(row.data);
-
-                // 累加统计
-                stats.http_total += (item.http?.total || 0);
-                stats.http_success += (item.http?.success || 0);
-                stats.assert_total += (item.assert?.total || 0);
-                stats.assert_success += (item.assert?.success || 0);
-                stats.total_resp_time += (item.total_response_time || 0);
-
-                return _.assign(item, {
-                    source: 'scheduled',
-                    start_at: this.formatTimeToISO(item?.start_at),
-                    end_at: this.formatTimeToISO(item?.end_at)
-                });
-            });
-
-            // 3. 计算通过率等指标
-            const httpRate = stats.http_total > 0 ? ((stats.http_success / stats.http_total) * 100).toFixed(2) : "0.00";
-            const assertRate = stats.assert_total > 0 ? ((stats.assert_success / stats.assert_total) * 100).toFixed(2) : "0.00";
-            const avgResp = results.length > 0 ? (stats.total_resp_time / results.length).toFixed(0) : 0;
-
-            // 4. 封装 Payload
-            const finalPayload = {
-                info: {
-                    job_id: record.job_info.job_id,
-                    report_name: record.job_info.name,
-                    project_id: record.job_info.project_id,
-                    execution_id: executionId,
-                    start_at: this.formatTimeToISO(record.job_info.start_time),
-                    end_at: this.formatTimeToISO(Date.now()),
-                    http_pass_rate: `${httpRate}%`,
-                    assert_pass_rate: `${assertRate}%`,
-                    avg_response_time: `${avgResp}ms`,
-                    total_http: stats.http_total,
-                    success_http: stats.http_success,
-                    total_assert: stats.assert_total,
-                    success_assert: stats.assert_success,
-                    total_units: record.total,
-                    actual_units: results.length
-                },
-                results: results
-            };
-            fs.writeFileSync('finalPayload.json', JSON.stringify(finalPayload))
-            // 5. 上报 API
-            const response = await axios.post(`${this.apiUrl}/open/hnzycfc/scheduled_task/report/add`, finalPayload, {
-                headers: { 'Content-Type': 'application/json', 'api-token': record.api_token },
-                maxContentLength: Infinity,
-                maxBodyLength: Infinity
-            });
-            // console.log(response?.data, 'response?.data');
-
-            if (response?.data?.code == 0) {
-                console.log(`[CronScheduler] Execution ${executionId} reported success.`);
-                // 成功后删除数据库里的临时结果
-                this.db.prepare(`DELETE FROM task_results WHERE execution_id = ?`).run(executionId);
-            } else {
-                console.error(`[Report Error] ${executionId}: ${response?.data?.msg}`);
+          runner(test_events, finalOptions, (res) => {
+            if (res?.action === 'complete') {
+              if (process.connected) {
+                process.send({ action: 'UNIT_COMPLETED', payload: { executionId, data: res.data, api_token } });
+              }
+              server.close();
+              try { if (fs.existsSync(socketPath)) fs.unlinkSync(socketPath); } catch (e) { }
             }
-
-        } catch (err) {
-            console.error(`[Aggregation Critical Error]`, err.stack);
-        } finally {
-            this.resultCollector.delete(executionId);
+          });
+        });
+      }
+    });
+
+    process.on('uncaughtException', (err) => {
+      console.error('[Worker Fatal] Exception:', err.message);
+    });
+  }
+
+  // ==========================================
+  // 业务与辅助方法
+  // ==========================================
+
+  async _handleUnitScript(socket, action, data) {
+    try {
+      switch (action) {
+        case 'queryDatabase': {
+          const { DatabaseQuery } = require('database-query');
+          const result = await DatabaseQuery(data.dbconfig, data.query);
+          socket.write(JSON.stringify(result) + "\n\n");
+          break;
         }
-    }
-    /**
-     * 分发逻辑：将一个批次内的所有 Runner 均衡分配给 Workers
-     */
-    _dispatch(job) {
-        try {
-            const runners = JSON5.parse(job.cases || '[]');
-            if (runners.length === 0) return;
-
-            const executionId = `${job.job_id}_${Date.now()}`;
-            this.resultCollector.set(executionId, {
-                total: runners.length,
-                received_count: 0, // 仅计数
-                api_token: job.api_token,
-                job_info: {
-                    job_id: job.job_id,
-                    name: job.name,
-                    project_id: job.project_id,
-                    start_time: Date.now()
-                    // 如果数据库有创建人字段，也可以存入：creator: job.creator
-                }
-            });
-
-            runners.forEach((runner, index) => {
-                // 负载均衡：选取当前存活的 worker 
-                const workers = Object.values(cluster.workers).filter(w => w.isConnected());
-                console.log(`[Dispatch] Active workers count: ${workers.length}`);
-                const worker = _.sample(workers);
-                if (worker) {
-                    console.log(`[Dispatch] Sending Unit ${index} to Worker ${worker.process.pid}`);
-                    worker.send({
-                        action: 'EXECUTE_UNIT',
-                        payload: {
-                            executionId,
-                            api_token: job.api_token,
-                            test_events: runner.test_events,
-                            option: runner.option,
-                            unit_index: index
-                        }
-                    });
-                } else {
-                    console.error(`[Dispatch Error] No active workers available to handle job ${job.job_id}`);
-                }
-            });
-        } catch (e) {
-            console.error(`[CronScheduler] Dispatch error:`, e.message);
+        case 'execute': {
+          const commandMap = { 'jar': 'java -jar', 'php': 'php -f', 'js': 'node', 'py': 'python3', 'py3': 'python3', 'go': 'go run', 'sh': 'sh' };
+          const ext = path.extname(data.file).slice(1).toLowerCase();
+          const command = `${commandMap[ext] || ''} ${data.file} ${(data.args || []).join(' ')}`;
+          const output = execSync(command, _.assign({ encoding: process.platform === 'win32' ? 'cp936' : 'utf8' }, data.option || {}));
+          socket.write(JSON.stringify({ status: 'success', result: String(output) }) + "\n\n");
+          break;
         }
+      }
+    } catch (err) {
+      socket.write(JSON.stringify({ status: 'error', message: err.message }) + "\n\n");
     }
-
-    // ==========================================
-    // Worker 进程逻辑：负责具体的任务执行
-    // ==========================================
-
-    _startWorker() {
-        try {
-            console.log(`[Worker ${process.pid}] Starting initialization...`);
-            const { run: runner } = require('runner-runtime');
-            const net = require('net');
-
-            process.on('message', async (msg) => {
-                if (msg.action === 'EXECUTE_UNIT') {
-                    const { executionId, api_token, test_events, option } = msg.payload;
-                    const socketPath = path.join(process?.env?.TEMP_DIR || os.tmpdir(), `echoapi_${uuidv4()}.sock`);
-
-                    const server = net.createServer((socket) => {
-                        socket.on('data', async (stream) => {
-                            try {
-                                const info = JSON.parse(stream.toString());
-                                const { action, data } = info;
-                                await this._handleUnitScript(socket, action, data);
-                            } catch (e) {
-                                socket.write(JSON.stringify({ status: 'error', message: e.message }) + "\n\n");
-                            }
-                        });
-                    });
-
-                    // --- 这里是关键！注册错误监听 ---
-                    server.on('error', (err) => {
-                        // 在服务器上看到这个日志，就能定位是权限问题还是路径问题
-                        console.error(`[Worker Socket Server Error] PID: ${process.pid}`);
-                        console.error(`[Error Details] Code: ${err.code} | Message: ${err.message}`);
-                        console.error(`[Attempted Path] ${socketPath}`);
-                    });
-
-                    server.listen(socketPath, () => {
-                        const finalOptions = _.cloneDeep(option || {});
-                        const base64Pipe = Buffer.from(socketPath).toString('base64');
-                        _.set(finalOptions, 'env.ELECTRON_PIPE', base64Pipe);
-
-                        runner(test_events, finalOptions, (res) => {
-                            if (res?.action === 'complete') {
-                                process.send({
-                                    action: 'UNIT_COMPLETED',
-                                    payload: { executionId, data: res.data, api_token }
-                                });
-                                server.close();
-                                if (fs.existsSync(socketPath)) {
-                                    try { fs.unlinkSync(socketPath); } catch (e) { }
-                                }
-                            }
-                        });
-                    });
-                }
-            });
-            process.on('uncaughtException', (err) => {
-                console.error('[Worker Fatal Error] 捕获到沙箱崩溃:', err.message);
-                // 即使崩溃也不要让子进程立即退出，或者让 Master 自动重启它
-            });
-        } catch (error) {
-            console.error(`[Worker ${process.pid}] Critical Boot Error:`, err.stack);
-            process.exit(1);
-        }
+  }
+
+  loadJobs() {
+    console.log('[CronScheduler] Loading timers from DB...');
+    Object.values(schedule.scheduledJobs).forEach(j => j.cancel());
+    try {
+      const jobs = this.db.prepare(`SELECT * FROM jobs WHERE is_cancel < 1`).all();
+      jobs.forEach(job => this.upsertTimer(job.job_id, job.name, job.frequency, job));
+    } catch (e) {
+      console.error('[Load Jobs Error]', e.message);
     }
-
-    async _handleUnitScript(socket, action, data) {
-        try {
-            switch (action) {
-                case 'queryDatabase': {
-                    const { dbconfig, query } = data;
-                    const { DatabaseQuery } = require('database-query');
-                    const result = await DatabaseQuery(dbconfig, query);
-                    socket.write(JSON.stringify(result) + "\n\n");
-                    break;
-                }
-                case 'execute': {
-                    const { file, args = [], option: execOption = {} } = data;
-                    const ext = path.extname(file).slice(1).toLowerCase();
-                    let command = "";
-
-                    switch (ext) {
-                        case 'jar': command = `java -jar ${file} ${args.join(' ')}`; break;
-                        case 'php': command = `php -f ${file} ${args.join(' ')}`; break;
-                        case 'js': command = `node ${file} ${args.join(' ')}`; break;
-                        case 'py':
-                        case 'py3': command = `python3 ${file} ${args.join(' ')}`; break;
-                        case 'go': command = `go run ${file} ${args.join(' ')}`; break;
-                        case 'sh': command = `sh ${file} ${args.join(' ')}`; break;
-                        default: command = `${file} ${args.join(' ')}`;
-                    }
-
-                    const isWindows = process.platform === 'win32';
-                    const config = _.assign(isWindows ? { encoding: 'cp936' } : { encoding: 'utf8' }, execOption);
-                    const output = String(execSync(command, config));
-
-                    socket.write(JSON.stringify({ status: 'success', result: output }) + "\n\n");
-                    break;
-                }
-            }
-        } catch (err) {
-            socket.write(JSON.stringify({ status: 'error', message: err.message }) + "\n\n");
-        }
+  }
+
+  upsertTimer(job_id, name, frequency, jobData) {
+    if (schedule.scheduledJobs[job_id]) schedule.scheduledJobs[job_id].cancel();
+    if (jobData?.is_cancel < 1) {
+      const cronRule = this.convertToCron(frequency);
+      schedule.scheduleJob(job_id, cronRule, () => {
+        const currentJob = this.db.prepare(`SELECT * FROM jobs WHERE job_id = ?`).get(job_id);
+        if (currentJob && currentJob.is_cancel < 1) this._dispatch(currentJob);
+      });
     }
+  }
 
-    // ==========================================
-    // 辅助工具
-    // ==========================================
-
-    /**
-     * 修正后的 Cron 转换逻辑：确保每一项都从第 0 秒开始执行
+  createJob(payload) {
+    const { job_id, name, frequency, api_token, project_id, runners } = payload;
+    const stmt = this.db.prepare(`
+            INSERT INTO jobs (job_id, name, frequency, api_token, project_id, cases, create_dtime)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(job_id) DO UPDATE SET name=excluded.name, frequency=excluded.frequency, cases=excluded.cases, api_token=excluded.api_token, is_cancel=0
+        `);
+    stmt.run(job_id, name, JSON.stringify(frequency), api_token, project_id, JSON.stringify(runners || []), Date.now());
+    this.upsertTimer(job_id, name, frequency, { is_cancel: 0 });
+    return true;
+  }
+
+  cancelJob(job_id) {
+    this.db.prepare(`UPDATE jobs SET is_cancel = 1 WHERE job_id = ?`).run(job_id);
+    if (schedule.scheduledJobs[job_id]) schedule.scheduledJobs[job_id].cancel();
+    return true;
+  }
+
+  /**
+     * 重启已暂停的任务
      */
-    convertToCron(freq) {
-        if (!freq) return '0 0 0 * * *';
-        const data = typeof freq === 'string' ? JSON5.parse(freq) : freq;
-
-        // 情况 A：用户直接传 Cron 表达式
-        if (data.type === 'cron') {
-            const exp = data.cron?.expression || '0 0 * * *';
-            const parts = exp.trim().split(/\s+/);
-            // 如果是 5 位，补齐第 0 位为 0 秒，确保不重复触发
-            return parts.length === 5 ? `0 ${exp}` : exp;
-        }
-
-        // 情况 B：预设周期配置
-        if (data.type === 'preset') {
-            const { cycle, config } = data.preset;
-
-            switch (cycle) {
-                case 'minute':
-                    // 修正：强制 0 秒开始，每 interval 分钟执行
-                    return `0 */${config.interval} * * * *`;
-
-                case 'hour':
-                    // 修正：强制 0 秒 0 分开始，每 interval 小时执行
-                    return `0 0 */${config.interval} * * *`;
-
-                case 'day': {
-                    // 兼容 '10:30' 这种格式
-                    const [hour, minute] = (config.time || "0:0").split(':');
-                    return `0 ${parseInt(minute)} ${parseInt(hour)} * * *`;
-                }
-
-                case 'week': {
-                    const [hour, minute] = (config.time || "0:0").split(':');
-                    // config.weekdays 应该是 [1, 3, 5] 这种数组
-                    const days = Array.isArray(config.weekdays) ? config.weekdays.join(',') : '*';
-                    return `0 ${parseInt(minute)} ${parseInt(hour)} * * ${days}`;
-                }
-
-                default:
-                    return '0 0 0 * * *';
-            }
-        }
-
-        return '0 0 0 * * *';
+  restartJob(job_id) {
+    try {
+      // 1. 更新数据库状态
+      this.db.prepare(`UPDATE jobs SET is_cancel = 0 WHERE job_id = ?`).run(job_id);
+
+      // 2. 获取最新数据并重新注册定时器
+      const job = this.db.prepare(`SELECT * FROM jobs WHERE job_id = ?`).get(job_id);
+      if (job) {
+        this.upsertTimer(job.job_id, job.name, job.frequency, job);
+        console.log(`[CronScheduler] Job ${job_id} restarted.`);
+        return true;
+      }
+      return false;
+    } catch (e) {
+      console.error(`[Restart Job Error] ${job_id}:`, e.message);
+      return false;
     }
-
-    getNextExecutionTime(cron) {
-
-        try {
-            const { CronExpressionParser } = require('cron-parser');
-            const interval = CronExpressionParser.parse(cron, { tz: 'Asia/Shanghai', utc: false });
-            return new Date(interval.next().toISOString()).getTime()
-        } catch (e) {
-            return '-';
-        }
+  }
+
+  deleteJob(job_id) {
+    this.db.prepare(`DELETE FROM jobs WHERE job_id = ?`).run(job_id);
+    if (schedule.scheduledJobs[job_id]) schedule.scheduledJobs[job_id].cancel();
+    return true;
+  }
+
+  getAllJobs(project_id) {
+    const jobs = this.db.prepare(`SELECT * FROM jobs WHERE project_id = ?`).all(project_id);
+    return jobs.map(job => ({
+      ..._.omit(job, ['cases']),
+      status: job.is_cancel === 0 ? 0 : 1,
+      next_run_time: this.getNextExecutionTime(this.convertToCron(job.frequency)),
+      runners: JSON5.parse(job.cases || '[]').map(v => v?.option?.testing_id)
+    }));
+  }
+
+  convertToCron(freq) {
+    const data = typeof freq === 'string' ? JSON5.parse(freq) : freq;
+    if (data.type === 'cron') {
+      const exp = data.cron?.expression || '0 0 * * *';
+      const parts = exp.trim().split(/\s+/);
+      return parts.length === 5 ? `0 ${exp}` : exp;
+    }
+    if (data.type === 'preset') {
+      const { cycle, config } = data.preset;
+      const [h, m] = (config.time || "0:0").split(':');
+      if (cycle === 'minute') return `0 */${config.interval} * * * *`;
+      if (cycle === 'hour') return `0 0 */${config.interval} * * *`;
+      if (cycle === 'day') return `0 ${parseInt(m)} ${parseInt(h)} * * *`;
+      if (cycle === 'week') return `0 ${parseInt(m)} ${parseInt(h)} * * ${Array.isArray(config.weekdays) ? config.weekdays.join(',') : '*'}`;
     }
+    return '0 0 0 * * *';
+  }
+
+  getNextExecutionTime(cron) {
+    try {
+      const { CronExpressionParser } = require('cron-parser');
+      return CronExpressionParser.parse(cron, { tz: 'Asia/Shanghai' }).next().getTime();
+    } catch (e) { return '-'; }
+  }
 }
 
 module.exports = CronScheduler;