multi-tasks 3.5.1 → 4.0.0-rc.1

package/bench-storage.svg

@@ -1,17 +1,21 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="720" height="252" viewBox="0 0 720 252" font-family="Segoe UI, Helvetica, Arial, sans-serif">
-  <rect x="1" y="1" width="718" height="250" rx="8" fill="#ffffff" stroke="#dadce0"/>
-  <text x="24" y="38" font-size="17" font-weight="600" fill="#202124">task_storage benchmark — 30,000 tasks × 28 workers</text>
-  <text x="24" y="60" font-size="12" fill="#5f6368">wall-clock time of a full run, average of 3 runs · lower is better</text>
+<svg xmlns="http://www.w3.org/2000/svg" width="720" height="310" viewBox="0 0 720 310" font-family="Segoe UI, Helvetica, Arial, sans-serif">
+  <rect x="1" y="1" width="718" height="308" rx="8" fill="#ffffff" stroke="#dadce0"/>
+  <text x="24" y="38" font-size="17" font-weight="600" fill="#202124">task_storage benchmark — 100,000 tasks × 28 workers</text>
+  <text x="24" y="60" font-size="12" fill="#5f6368">wall-clock time of a full run, average of 2 runs · lower is better</text>
 
   <text x="112" y="114" font-size="14" fill="#202124" text-anchor="end">file</text>
   <rect x="120" y="94" width="420" height="34" rx="3" fill="#9aa0a6"/>
-  <text x="548" y="116" font-size="14" fill="#202124">195.1s · 154 tasks/s</text>
+  <text x="548" y="116" font-size="14" fill="#202124">439.0s · 228 tasks/s</text>
 
-  <text x="112" y="172" font-size="14" fill="#202124" text-anchor="end">memory</text>
-  <rect x="120" y="152" width="24" height="34" rx="3" fill="#188038"/>
-  <text x="152" y="174" font-size="14" fill="#202124">11.2s · 2,676 tasks/s</text>
-  <text x="360" y="174" font-size="15" font-weight="700" fill="#188038">17.4× faster</text>
+  <text x="112" y="172" font-size="14" fill="#202124" text-anchor="end">aof</text>
+  <rect x="120" y="152" width="9" height="34" rx="3" fill="#188038"/>
+  <text x="137" y="174" font-size="14" fill="#202124">8.7s · 11,468 tasks/s</text>
+  <text x="420" y="174" font-size="15" font-weight="700" fill="#188038">50× faster than file</text>
 
-  <line x1="120" y1="208" x2="540" y2="208" stroke="#e8eaed"/>
-  <text x="24" y="232" font-size="11" fill="#5f6368">per-round walls — file: 202.7 / 193.6 / 188.9s · memory: 11.3 / 11.1 / 11.3s · Windows 11, SSD · script: test-manual/bench-storage.js</text>
+  <text x="112" y="230" font-size="14" fill="#202124" text-anchor="end">memory</text>
+  <rect x="120" y="210" width="7" height="34" rx="3" fill="#1a73e8"/>
+  <text x="135" y="232" font-size="14" fill="#202124">7.3s · 13,706 tasks/s</text>
+
+  <line x1="120" y1="266" x2="540" y2="266" stroke="#e8eaed"/>
+  <text x="24" y="290" font-size="11" fill="#5f6368">per-round walls — file: 441.0 / 437.1s · aof: 8.7 / 8.8s · memory: 7.3 / 7.3s · Windows 11, SSD · script: test-manual/bench-storage.js</text>
 </svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multi-tasks",
-  "version": "3.5.1",
+  "version": "4.0.0-rc.1",
   "description": "Multi-process task scheduling based on Node.js cluster, with crash resume and failed-task restart support",
   "main": "index.js",
   "files": [

package/utils/makedir.js

@@ -7,14 +7,15 @@ function sync(directoryPath) {
 }
 function getDirectFiles(dir, callback) {  
     let childrenfiles = [];
-    if(!fs.existsSync(dir)){
-        console.log('FATAL: directory is missing:', dir);
-        return process.exit(1);        
-    }
     let entries;
     try{
         entries = fs.readdirSync(dir, { withFileTypes: true });//一次拿齐 isFile, 省掉逐文件 statSync(大任务量启动/resume 显著)
     }catch(err){
+        //目录缺失检测并入 readdirSync 的 catch(省掉独立 existsSync 预检): ENOENT = 目录丢失, 语义不变
+        if(err && err.code === 'ENOENT'){
+            console.log('FATAL: directory is missing:', dir);
+            return process.exit(1);
+        };
         console.error("Could not list the directory.", err);
         return callback([]);
     }

package/utils/progressCtl.js

@@ -260,6 +260,10 @@ const workerStatus = (id, payload) => {
 };
 
 const finish = () => {//收尾: 换行定格进度条行 + 输出计数器行(master 退出前调用); 未开启为 no-op
+  if (renderTimer) {//收尾后不再渲染: 尾随节流帧/workerExited 触发的晚到帧会回卷光标、把计数器行抹掉
+    clearTimeout(renderTimer);
+    renderTimer = null;
+  };
   if (resizeSettleTimer) {//收尾后不再重锚定重绘: 防抖帧会落在计数器行之后
     clearTimeout(resizeSettleTimer);
     resizeSettleTimer = null;
@@ -270,6 +274,9 @@ const finish = () => {//收尾: 换行定格进度条行 + 输出计数器行(ma
       let stats = getStats();
       view.writeLine(`[Tasks] succeeded=${stats.succeeded}, failed=${stats.failed}, succ-but-save-failed=${stats.succButSaveFailed || 0}`);
     };
+    //渲染路径整体解除: render/resize 防抖/resize 监听均以 view 为开关, 置 null 后晚到事件全部自然失效
+    view = null;
+    progressOn = false;
   };
 };
 

package/utils/runLog.js

@@ -32,8 +32,9 @@ const isEnabled = () => {
   return state.enabled;
 };
 
-//拦截 console: 把 console.log/warn/error 替换为写 run.log 的实现,
+//拦截 console: 把 console.log/info/debug/warn/error 替换为写 run.log 的实现,
 //用户代码(processTask/onFinish 等)里的 console 输出同样进文件。
+//info/debug 是 console 实例上的独立方法(并非 log 的别名), 漏钩会在非 echo 模式直写 TTY 挤偏进度帧且不进 run.log。
 //echo 为真时同时调原实现上屏(progressBar 未开/非 TTY 回退); 为假时只写文件(进度区接管终端)。
 //reset/unhookConsole 恢复原实现(必须在 enabled 变 false 之前恢复, 否则 write 透传 console 会递归)。
 const hookConsole = ({ echo } = {}) => {
@@ -42,8 +43,10 @@ const hookConsole = ({ echo } = {}) => {
   };
   state.hooked = true;
   state.echo = !!echo;
-  originalConsole = { log: console.log, warn: console.warn, error: console.error };
+  originalConsole = { log: console.log, info: console.info, debug: console.debug, warn: console.warn, error: console.error };
   console.log = write;
+  console.info = write;
+  console.debug = write;
   console.warn = warn;
   console.error = error;
 };
@@ -53,6 +56,8 @@ const unhookConsole = () => {
     return;
   };
   console.log = originalConsole.log;
+  console.info = originalConsole.info;
+  console.debug = originalConsole.debug;
   console.warn = originalConsole.warn;
   console.error = originalConsole.error;
   originalConsole = null;

package/utils/startupBanner.js

@@ -19,12 +19,17 @@ const renderTitleBox = (mode) => {
 };
 
 const renderFieldLines = (info) => {
+  //默认值落地的 run 在 task_storage 行追加升级提示(4.0.0 默认值 file -> aof); 显式设置时只显示模式本身
+  const storageValue = info.storageDefaultApplied
+    ? `${info.taskStorage} (default since 4.0.0, was 'file'; set task_storage: 'file' for the classic per-task-file layout)`
+    : info.taskStorage;
   const rows = [
     ['taskId', info.taskId],
     ['taskFolder', info.taskFolder],
     ['workers', `${info.numOfWorkers} (numCPUs=${info.numCPUs})`],
     ['master PID', `${info.pid}`],
     ['new tasks', `${info.newTasks}`],
+    ['task_storage', storageValue],
     ['run.log', info.sysLogFile || '(not available)'],
     ['started at', info.startedAt],
     ['monitor install cmd', 'npm install multi-tasks-monitor'],

package/workers/AofStore.js

@@ -0,0 +1,349 @@
+const fs = require('fs');
+const pathUtil = require('path');
+const { createMemoryStore } = require('./MemoryStore');
+const IpcTaskStore = require('./IpcTaskStore');
+const runLog = require('../utils/runLog');
+
+//AofStore: aof 档 master 侧存储 = MemoryStore(内存权威状态) + append-only aof(崩溃恢复)。
+//核心原则(拍板, 勿回退):
+//  master 是 aof 唯一写者; 每个变更 op 先应用 MemoryStore、后追加 aof 行({op,args} NDJSON);
+//  重放 = 逐行 apply 到 MemoryStore, replay 与在线路径零分叉;
+//  checkpoint = 先写 snapshot(临时文件+rename 原子替换)、后截断 aof, 顺序勿反;
+//  op 应用/aof 追加/checkpoint 全在 Multithread 同一串行 queue, checkpoint 天然对应 aof 某前缀一致态;
+//  saveResult/deleteResult 除内存+aof 行外, 追加结果行到聚合 NDJSON 文件 results/succ.json /
+//  errors.json(流式追加 10 万行仅 ~0.5s, 取代逐任务小文件——那是 aof 与 memory 差 10 倍的唯一来源);
+//  收尾 flushResults() 按内存终态整体重写两个文件(墓碑/历史行清除), 与 checkpoint 一并 await。
+const AOF_FNAME = 'aof.log';
+const SNAPSHOT_FNAME = 'aof.snapshot.json';
+//周期 checkpoint 双模式(拍板):
+//  aof_checkpoint_ops 显式设置 = 旧固定行数模式(<=0 关周期触发), 作新旧对比开关保留;
+//  ops 未设置 = 字节几何模式: aof 自上次 checkpoint 增长 N 字节触发, N = aof_checkpoint_bytes
+//  (默认 32MB, <=0 关), 每次触发后 N ×2 封顶 256MB——结账成本 ∝ 状态大小, 几何间隔让全运行期
+//  总结账量收敛到 ~2 倍最终态(固定间隔随任务量平方级放大, 已实测 10 万任务 +49% 耗时)。
+const DEFAULT_CHECKPOINT_BYTES = 32 * 1024 * 1024;
+const MAX_CHECKPOINT_BYTES = 256 * 1024 * 1024;
+
+//与 IPC 协议同一字面量(单一来源在 IpcTaskStore, 勿复制)
+const UNDEFINED_SENTINEL = IpcTaskStore.__UNDEFINED_SENTINEL;
+
+const encodeArg = (value) => (typeof value === 'undefined' ? { [UNDEFINED_SENTINEL]: true } : value);
+const decodeArg = (value) => (value && value[UNDEFINED_SENTINEL] ? undefined : value);
+
+//变更 op 全集(重放白名单同此): 与 MemoryStore 方法一一对应。
+//注意 aof 行用 MemoryStore 方法名(addMessage/clearMessages), 不是 IPC op 名(saveUserMessage/deleteUserMessage)
+const AOF_OPS = ['add', 'addMany', 'move', 'saveResult', 'deleteResult', 'saveLog', 'incrementRetry', 'resetRetry', 'addMessage', 'clearMessages'];
+
+const createAofStore = (config, innerStore) => {
+  const { masterTaskId, taskFolder } = config || {};
+  if (!masterTaskId || !taskFolder) {
+    throw new Error('createAofStore: config requires {masterTaskId, taskFolder}');
+  };
+  //checkpointOps: 显式 number = 旧固定行数模式; 未设置(null) = 字节几何模式(语义见文件头)
+  const checkpointOps = typeof config.aof_checkpoint_ops === 'number' ? config.aof_checkpoint_ops : null;
+  const byteCap = typeof config.__aof_checkpoint_bytes_cap === 'number' ? config.__aof_checkpoint_bytes_cap : MAX_CHECKPOINT_BYTES;
+  let byteThreshold = checkpointOps === null
+    ? (typeof config.aof_checkpoint_bytes === 'number' ? config.aof_checkpoint_bytes : DEFAULT_CHECKPOINT_BYTES)
+    : 0;
+
+  const store = innerStore || createMemoryStore(config);
+  const aofPath = pathUtil.resolve(taskFolder, '.sys', AOF_FNAME);
+  const snapshotPath = pathUtil.resolve(taskFolder, '.sys', SNAPSHOT_FNAME);
+
+  //结果聚合文件(用户拍板 2026-09 二版): 每任务一行的 NDJSON 聚合文件 results/succ.json /
+  //  errors.json, 取代逐任务小文件(逐任务 writeFile+rename 是 aof 与 memory 差 10 倍的唯一来源,
+  //  而流式追加 10 万行仅 ~0.5s; 整体重写+线程池调大都救不了 Windows 单文件操作延迟, 实测封顶 ~2000 ops/s):
+  //  运行中 saveResult 追加 {subid,data} 行(data undefined 时该键省略), deleteResult 追加
+  //  {subid,deleted:true} 墓碑行(读者按 subid 取最后一行为准); 收尾 flushResults 按内存终态
+  //  tmp+rename 整体重写两个文件(墓碑/翻盘历史行全部清掉); resume 时 __reconcileResultFiles 只修
+  //  撕坏的尾行+清 .tmp 残件(不重写——Windows 不能 rename 占用中的文件, 追加流可能与重写交叉)
+  //内部开关 aof_append_result_files(不对外文档化, 与 aof_checkpoint_* 同属内部调参键): aof 档缺省 true,
+  //  显式 false 关闭结果聚合文件(结果只留内存/onFinish, aof 状态行与可恢复性不受影响)
+  const resultFilesEnabled = config.aof_append_result_files !== false;
+  const resultPath = (hasError) => pathUtil.resolve(taskFolder, 'results', hasError ? 'errors.json' : 'succ.json');
+  const resultStreams = { succ: null, errors: null };
+  let resultBroken = false;
+  let fileOpWarned = false;
+
+  const warnFileOnce = (...args) => {
+    if (!fileOpWarned) {
+      fileOpWarned = true;
+      runLog.warn(...args);
+    };
+  };
+
+  const appendResultLine = (hasError, record) => {
+    if (!resultFilesEnabled || resultBroken) return;
+    const side = hasError ? 'errors' : 'succ';
+    if (!resultStreams[side]) {
+      resultStreams[side] = fs.createWriteStream(resultPath(hasError), { flags: 'a' });
+      resultStreams[side].on('error', (e) => {
+        resultBroken = true;
+        warnFileOnce('[AofStore]: result stream broken, result files degraded for this run', e);
+      });
+    };
+    resultStreams[side].write(JSON.stringify(record) + '\n');
+  };
+
+  //内存终态 → 一侧文件内容(NDJSON, 插入序): 只含当前存在的终态结果, 墓碑/历史行不进
+  const buildSideContent = (hasError) => {
+    const lines = [];
+    store.__serialize().results.forEach(([subid, entry]) => {
+      if (entry.hasError === hasError) {
+        lines.push(JSON.stringify(typeof entry.data === 'undefined' ? { subid } : { subid, data: entry.data }));
+      };
+    });
+    return lines.length ? lines.join('\n') + '\n' : '';
+  };
+
+  //tmp+rename 整体重写一侧(同 checkpoint snapshot 原子模式): kill 中途只留 .tmp 残件, 目标文件不破
+  const rewriteSide = async (hasError) => {
+    const finalPath = resultPath(hasError);
+    await fs.promises.writeFile(`${finalPath}.tmp`, buildSideContent(hasError));
+    await fs.promises.rename(`${finalPath}.tmp`, finalPath);
+  };
+
+  let stream = null;
+  let broken = false;//流出错整轮丢弃(同 run.log best-effort): 本次运行失去可恢复性, 退化为 memory 档语义
+  let linesSinceCheckpoint = 0;
+  let bytesSinceCheckpoint = 0;
+  let checkpointInFlight = null;
+
+  const onStreamError = (e) => {
+    broken = true;
+    runLog.warn('[AofStore]: aof stream broken, recoverability lost for this run', e);
+  };
+
+  const openStream = (flags) => {
+    stream = fs.createWriteStream(aofPath, { flags });
+    stream.on('error', onStreamError);
+  };
+
+  const appendLine = (op, args) => {
+    if (broken) return;
+    if (!stream) openStream('a');
+    const line = JSON.stringify({ op, args: args.map(encodeArg) }) + '\n';
+    stream.write(line);
+    linesSinceCheckpoint++;
+    bytesSinceCheckpoint += Buffer.byteLength(line, 'utf-8');
+  };
+
+  const aofOps = {};
+  AOF_OPS.forEach((op) => {
+    aofOps[op] = (...args) => {
+      const result = store[op](...args);//先应用(add 会先赋 subid 再落行)
+      appendLine(op, args);
+      return result;
+    };
+  });
+
+  //saveResult/deleteResult 在「内存 + aof 行」外追加结果聚合行(运行中即可读; 读者按 subid 取最后一行)
+  const rawSaveResult = aofOps.saveResult;
+  aofOps.saveResult = (subid, hasError, data) => {
+    const result = rawSaveResult(subid, hasError, data);
+    appendResultLine(hasError, typeof data === 'undefined' ? { subid } : { subid, data });
+    return result;
+  };
+  const rawDeleteResult = aofOps.deleteResult;
+  aofOps.deleteResult = (subid) => {
+    const type = store.getSavedResultType(subid);//'succ'/'error'/null: 删前取侧, 墓碑行追加到对应文件
+    const result = rawDeleteResult(subid);
+    if (type) appendResultLine(type === 'error', { subid, deleted: true });
+    return result;
+  };
+
+  //收尾(三条退出路径与 checkpoint 一并 await): 先关追加流(缓冲全冲下、句柄释放, Windows 上
+  //句柄未关 rename 会 EPERM) → 两侧按内存终态 tmp+rename 整体重写(墓碑/翻盘历史行清掉) →
+  //清旧版逐任务结果文件与 .tmp 残件; 失败只告警不 reject(收尾路径直接 await, reject 会挂死 master)
+  const flushResults = async () => {
+    for (const side of ['succ', 'errors']) {
+      const s = resultStreams[side];
+      if (s) {
+        resultStreams[side] = null;
+        //用 end(cb) 而非等 'close': 流中途出错已销毁时 'close' 早已发完不再重发, 等它会永远悬挂
+        //(退出路径 await 本函数, 悬挂 = 挂死 master 收尾); end(cb) 对已销毁流也回调
+        await new Promise((resolve) => { s.end(resolve); });
+      };
+    };
+    for (const hasError of [false, true]) {
+      try {
+        await rewriteSide(hasError);
+      } catch (e) {
+        warnFileOnce('[AofStore]: flush result files failed, later failures suppressed', e);
+      };
+    };
+    for (const side of ['succ', 'errors']) {//旧版(逐任务双写/物化)目录残留, 只清文件不动目录
+      const dir = pathUtil.resolve(taskFolder, 'results', side);
+      let files = [];
+      try {
+        files = fs.readdirSync(dir);
+      } catch (e) {
+        continue;
+      };
+      await Promise.all(files.map(async (fname) => {
+        if (!fname.endsWith('.json') && !fname.endsWith('.json.tmp')) return;
+        try {
+          await fs.promises.unlink(pathUtil.resolve(dir, fname));
+        } catch (e) {};
+      }));
+    };
+  };
+
+  //resume 修复(loadFromDisk 调用, 同步): torn write 只可能撕坏最后一行(单写者单 append 流),
+  //截回干净行边界; 顺带清 rewrite 被 kill 打断留下的 .tmp 残件。不重写文件——追加流还要继续写
+  const repairResultFile = (fpath) => {
+    try {
+      fs.unlinkSync(`${fpath}.tmp`);
+    } catch (e) {};
+    if (!fs.existsSync(fpath)) return;
+    //按字节定位行边界(truncateSync 的长度是字节数; 字符串下标对多字节数据会截进前一行,
+    //与 loadFromDisk 修 aof.log 用 Buffer.byteLength 同源)
+    const buf = fs.readFileSync(fpath);
+    if (buf.length === 0 || buf[buf.length - 1] === 0x0a) return;
+    const cut = buf.lastIndexOf(0x0a);
+    fs.truncateSync(fpath, cut + 1);
+  };
+  const reconcileResultFiles = () => {
+    if (!resultFilesEnabled) return;
+    repairResultFile(resultPath(false));
+    repairResultFile(resultPath(true));
+  };
+
+  //pop 出队即 new->running, 落成 move 行(否则重放时该任务滞留 new 会被重复派发,
+  //且后续 running->finished 的 move 行因 from 不匹配被跳过 → 已完成任务被重跑)
+  const pop = () => {
+    const task = store.pop();
+    if (task) appendLine('move', [task.subid, 'new', 'running']);
+    return task;
+  };
+
+  //checkpoint = 写 snapshot(临时文件+rename 原子替换) + 截断 aof。
+  //顺序硬性约束: 先 snapshot 落盘、后截断——截断失败只留冗余(下次再压), 反过来丢数据。
+  //调用点必须在 Multithread 串行 queue 内(op 应用与 append 无并发), snapshot 才对应 aof 某前缀一致态。
+  const checkpoint = () => {
+    if (checkpointInFlight) return checkpointInFlight;
+    const run = (async () => {
+      const tmpPath = `${snapshotPath}.tmp`;
+      await fs.promises.writeFile(tmpPath, JSON.stringify(store.__serialize()));
+      await fs.promises.rename(tmpPath, snapshotPath);
+      //截断前先把已 append 的行全部冲下盘(stream FIFO), 再 'w' 重开截断
+      if (stream) {
+        await new Promise((resolve) => { stream.end(resolve); });
+      };
+      openStream('w');
+      //'w' 的截断发生在异步 open 完成时, 等它落地再 resolve, 保证 checkpoint 返回时盘上已截断;
+      //open 失败也放行(onStreamError 已置 broken 告警, 本回合退化 memory 语义)
+      await new Promise((resolve) => {
+        stream.once('open', resolve);
+        stream.once('error', resolve);
+      });
+      linesSinceCheckpoint = 0;
+      bytesSinceCheckpoint = 0;
+    })();
+    checkpointInFlight = run.catch((e) => {
+      //snapshot 未落盘则不截断(上面顺序保证), 下个周期重试; 不翻转任务成败、不中断运行
+      runLog.warn('[AofStore]: checkpoint failed, aof kept untruncated', e);
+    }).finally(() => {
+      checkpointInFlight = null;
+    });
+    return checkpointInFlight;
+  };
+
+  const maybeCheckpoint = () => {
+    if (checkpointOps !== null) {
+      if (checkpointOps > 0 && linesSinceCheckpoint >= checkpointOps) return checkpoint();
+      return null;
+    };
+    //字节几何模式: 达阈值先翻倍(同步, 下次生效)再触发; 触发失败计数器不清零, 下轮按新阈值重试
+    if (byteThreshold > 0 && bytesSinceCheckpoint >= byteThreshold) {
+      byteThreshold = Math.min(byteThreshold * 2, byteCap);
+      return checkpoint();
+    };
+    return null;
+  };
+
+  return {
+    ...aofOps,
+    pop,
+    checkpoint,
+    maybeCheckpoint,
+    //aof_append_result_files=false 时不挂 flushResults: Multithread 收尾 typeof 检查自动跳过
+    ...(resultFilesEnabled ? { flushResults } : {}),
+    getSavedResultType: store.getSavedResultType,
+    getState: store.getState,
+    getTasks: store.getTasks,
+    getRemaining: store.getRemaining,
+    stats: store.stats,
+    forEachSuccResult: store.forEachSuccResult,
+    forEachErrorResult: store.forEachErrorResult,
+    forEachResult: store.forEachResult,
+    __reconcileResultFiles: reconcileResultFiles,
+    __innerStore: store,//测试与 loadFromDisk 内部用
+  };
+};
+
+//重放单行进 MemoryStore: op 白名单即 AOF_OPS, 未知 op throw(不静默跳过——
+//跳过等于丢状态变更, 重放结果与在线态分叉)
+const replayOp = (store, rec) => {
+  if (!rec || AOF_OPS.indexOf(rec.op) < 0) {
+    throw new Error(`AofStore: unknown aof op "${rec && rec.op}"`);
+  };
+  const args = (rec.args || []).map(decodeArg);
+  store[rec.op](...args);
+};
+
+//resume 入口: snapshot(若有且可解析) + aof 增量重放。
+//torn write 只可能截断最后一行(单写者单 append 流): 跳过坏尾行并把文件截回干净边界,
+//否则后续追加会接在半行后面永久污染; 中间行损坏 = 真腐败, throw 走 resume FATAL exit(1) 链路。
+const loadFromDisk = (config) => {
+  const { taskFolder } = config || {};
+  if (!taskFolder) {
+    throw new Error('AofStore.loadFromDisk: config requires {taskFolder}');
+  };
+  const aofPath = pathUtil.resolve(taskFolder, '.sys', AOF_FNAME);
+  const snapshotPath = pathUtil.resolve(taskFolder, '.sys', SNAPSHOT_FNAME);
+
+  let snapshot = null;
+  if (fs.existsSync(snapshotPath)) {
+    try {
+      snapshot = JSON.parse(fs.readFileSync(snapshotPath, 'utf-8'));
+    } catch (e) {
+      runLog.warn('[AofStore]: snapshot corrupted, falling back to full aof replay', e);
+      snapshot = null;
+    };
+  };
+  const inner = createMemoryStore(config, snapshot);
+
+  if (fs.existsSync(aofPath)) {
+    const lines = fs.readFileSync(aofPath, 'utf-8').split('\n');
+    let offset = 0;
+    let truncateAt = -1;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line === '') {
+        offset += 1;
+        continue;
+      };
+      let rec = null;
+      try {
+        rec = JSON.parse(line);
+      } catch (e) {
+        const isTail = lines.slice(i + 1).every((l) => l === '');
+        if (!isTail) {
+          throw new Error(`AofStore: corrupted aof line ${i + 1} in ${aofPath}`);
+        };
+        truncateAt = offset;
+        break;
+      };
+      replayOp(inner, rec);
+      offset += Buffer.byteLength(line, 'utf-8') + 1;
+    };
+    if (truncateAt >= 0) {
+      fs.truncateSync(aofPath, truncateAt);
+    };
+  };
+  const store = createAofStore(config, inner);
+  store.__reconcileResultFiles();//修上一轮 kill 撕坏的结果文件尾行/清残件(重放只建内存, 终态重写在收尾)
+  return store;
+};
+
+module.exports = { createAofStore, loadFromDisk, AOF_OPS, AOF_FNAME, SNAPSHOT_FNAME };