@abtnode/util 1.16.49-beta-20250815-032308-7bcf0b85 → 1.16.49-beta-20250819-084933-3bcbd851

package/lib/get-pm2-process-info.js

@@ -1,6 +1,6 @@
 const { CustomError } = require('@blocklet/error');
 
-const pm2 = require('./async-pm2');
+const pm2 = require('./pm2/async-pm2');
 
 const noop = () => {};
 

package/lib/{async-pm2.js → pm2/async-pm2.js}

@@ -29,6 +29,9 @@ pm2.start = (opts, cb) => {
   } else {
     opts.node_args = nodeArgs.join(' ');
   }
+  if (opts.env && opts.name) {
+    opts.env.RELOAD_PM2_APP_NAME = opts.name;
+  }
 
   return originStart(opts, cb);
 };

package/lib/pm2/fetch-pm2.js

@@ -0,0 +1,26 @@
+const RpcClient = require('@arcblock/event-hub/lib/rpc');
+const pm2 = require('./async-pm2');
+const md5 = require('../md5');
+
+let rpcClient = null;
+
+async function fetchPm2(pm2Config, ABT_NODE_SK, { timeoutMs = 120000 } = {}) {
+  if (!rpcClient) {
+    rpcClient = new RpcClient(Number(process.env.ABT_NODE_EVENT_PORT) || 40407, '127.0.0.1');
+  }
+
+  if (process.env.NODE_ENV === 'test') {
+    await pm2.startAsync(pm2Config);
+    return 'ok';
+  }
+
+  const pwd = md5(`${ABT_NODE_SK}-fetch-pm2`);
+  const data = await rpcClient.rpc(
+    'pm2/start',
+    { pm2Config, pwd },
+    { timeoutMs, errorPrefix: 'blocklet start failed' }
+  );
+  return data;
+}
+
+module.exports = fetchPm2;

package/lib/pm2/get-instance-number.js

@@ -0,0 +1,21 @@
+const os = require('os');
+
+const getDaemonInstanceCount = () => {
+  return 1;
+};
+
+const getServiceInstanceCount = () => {
+  // unit: GB
+  const memorySize = Math.floor(os.totalmem() / 1024 / 1024 / 1024) || 1;
+
+  const cpuLength = os.cpus().length || 1;
+
+  const customConfig = +process.env.ABT_NODE_MAX_CLUSTER_SIZE || Number.MAX_SAFE_INTEGER;
+
+  return Math.max(Math.min(memorySize, cpuLength, customConfig), 1);
+};
+
+module.exports = {
+  getDaemonInstanceCount,
+  getServiceInstanceCount,
+};

package/lib/pm2/pm2-start-or-reload.js

@@ -0,0 +1,137 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable consistent-return */
+/* eslint-disable no-promise-executor-return */
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const pm2 = require('./async-pm2');
+
+function getTempEnvPath(name) {
+  const envPath = path.join(process.env.ABT_NODE_DATA_DIR || os.tmpdir(), 'tmp', `blocklet-${name}.temp-env.json`);
+  const dir = path.dirname(envPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return envPath;
+}
+
+function loadReloadEnv() {
+  if (!process.env.RELOAD_PM2_APP_NAME) {
+    return;
+  }
+  const tempEnvPath = getTempEnvPath(process.env.RELOAD_PM2_APP_NAME);
+  if (!fs.existsSync(tempEnvPath)) {
+    return;
+  }
+  try {
+    const env = JSON.parse(fs.readFileSync(tempEnvPath, 'utf8'));
+    Object.assign(process.env, env);
+  } catch {
+    //
+  }
+
+  try {
+    fs.unlinkSync(tempEnvPath);
+  } catch {
+    //
+  }
+}
+
+// 等单个 pm_id online
+function waitProcOnlineById(id, timeout = 20_000) {
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    (function poll() {
+      pm2.describe(id, (err, list) => {
+        if (err) return reject(err);
+        const info = Array.isArray(list) ? list[0] : list;
+        if (info?.pm2_env?.status === 'online') return resolve();
+        if (Date.now() - start > timeout) return reject(new Error('proc not online in time'));
+        setTimeout(poll, 120);
+      });
+    })();
+  });
+}
+
+/** 等待该 app 的 cluster 全 online */
+function waitSomeInstancesOnline(name, instances, timeoutMs = 20_000) {
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    (function poll() {
+      pm2.list((err, list) => {
+        if (err) return reject(err);
+        const procs = list.filter((p) => p.name === name);
+        const online = procs.filter((p) => p.pm2_env?.status === 'online').length;
+        if (online >= instances) return resolve();
+        if (Date.now() - start > timeoutMs) return reject(new Error('instances not online in time'));
+        setTimeout(poll, 120);
+      });
+    })();
+  });
+}
+
+async function rollingRestartWithEnv(config) {
+  // eslint-disable-next-line camelcase
+  const { name, listen_timeout = 20_000 } = config;
+  const procs = await new Promise((resolve, reject) => {
+    pm2.list((err, list) => (err ? reject(err) : resolve(list)));
+  });
+
+  // 固定顺序
+  const targets = procs.filter((p) => p.name === name).sort((a, b) => a.pm_id - b.pm_id);
+
+  for (const p of targets) {
+    await new Promise((resolve, reject) => {
+      pm2.reload(p.pm_id, {}, (err) => (err ? reject(err) : resolve()));
+    });
+    // 等这个 pm_id 回到 online（而不是 name 级别）
+    await waitProcOnlineById(p.pm_id, listen_timeout);
+    // 给切换一点冗余，避免瞬时影响
+    await new Promise((r) => setTimeout(r, 500));
+  }
+}
+
+async function pm2ReloadWithEnv(config) {
+  const { name, instances } = config;
+  if (instances > 1) {
+    await rollingRestartWithEnv(config);
+  } else {
+    await new Promise((resolve, reject) => {
+      pm2.reload(name, {}, (err) => (err ? reject(err) : resolve()));
+    });
+  }
+}
+
+async function isProcessRunningByPm2(name) {
+  const isHasRunning = await new Promise((resolve) => {
+    pm2.list((err, list) => {
+      if (err) return resolve(false);
+      const proc = list.find((p) => p.name === name);
+      resolve(!!proc);
+    });
+  });
+
+  return isHasRunning;
+}
+
+async function pm2StartOrReload(config = {}) {
+  const { name } = config;
+  const tempEnvPath = getTempEnvPath(name);
+  fs.writeFileSync(tempEnvPath, JSON.stringify(config.env));
+
+  const isHasRunning = await isProcessRunningByPm2(name);
+
+  if (isHasRunning) {
+    await pm2ReloadWithEnv(config);
+  } else {
+    await pm2.startAsync(config);
+  }
+  await waitSomeInstancesOnline(name, config.instances);
+}
+
+module.exports = {
+  loadReloadEnv,
+  isProcessRunningByPm2,
+  waitSomeInstancesOnline,
+  pm2StartOrReload,
+};

package/lib/pm2/setup-graceful-shutdown.js

@@ -0,0 +1,356 @@
+/* eslint-disable no-continue */
+/* eslint-disable no-empty */
+const INSTALLED = Symbol.for('graceful.shutdown.installed');
+
+function setupGracefulShutdown(server, opts = {}) {
+  if (server[INSTALLED]) return;
+  server[INSTALLED] = true;
+
+  const {
+    killTimeout = 10000, // 总体兜底退出时间（ms）
+    socketEndTimeout = 5000, // 等待所有 TCP 连接优雅结束的最大时间（ms）
+    wsServers = [], // 可传入 ws 或 socket.io 实例，用于优雅关闭
+    logger = console, // 日志对象
+    setConnectionCloseOnShutdown = true, // h1 关停时设置 Connection: close / shouldKeepAlive=false
+    tuneKeepAlive = true, // 关停时温和缩短 keepAliveTimeout
+    http503OnShutdown = false, // 关停窗口是否对新请求/新流立即 503（默认 false：保持 200）
+    http503DelayMs = 2000, // 503 生效延迟（ms），给新进程接管留时间
+    quietEndDelay = 250, // 关停后延迟一小段再 end 空闲 socket（降低竞态）
+    // ---- HTTP/2 相关可选项 ----
+    enableHttp2Support = false, // 若服务包含 HTTP/2，建议保持 true
+    http2RefuseNewStreamsOnShutdown = true, // 关停窗口拒绝“新建流”（用 503 响应）
+    // ---- KA 调优参数（温和缩短）----
+    kaGentleMs = 600, // 关停期将 keepAliveTimeout 降到该值（建议 300–800ms）
+    kaPhaseDelayMs = 500, // 进入关停后，延迟一小段时间再缩短 KA
+  } = opts;
+
+  let isShuttingDown = false;
+  let shutdownStartedAt = 0;
+  let readySent = false;
+
+  if (!logger.info) logger.info = logger.log;
+
+  const sendReadyOnce = () => {
+    if (readySent) return;
+    readySent = true;
+    process.send?.('ready');
+  };
+
+  if (typeof server.listening === 'boolean' && server.listening) {
+    setImmediate(sendReadyOnce);
+  } else {
+    server.on('listening', sendReadyOnce);
+  }
+
+  // --------- HTTP/1.1 连接与请求跟踪 ----------
+  const sockets = new Set();
+  const metaMap = new WeakMap(); // socket -> { active: number, _ended?: boolean }
+
+  server.on('connection', (socket) => {
+    sockets.add(socket);
+    metaMap.set(socket, { active: 0 });
+    socket.on('close', () => sockets.delete(socket));
+  });
+
+  server.prependListener('request', (req, res) => {
+    const { socket } = req;
+    const meta = metaMap.get(socket);
+    if (meta) meta.active++;
+
+    const isH2 = req.httpVersionMajor >= 2;
+
+    if (isShuttingDown) {
+      // HTTP/1.x：仅设置 shouldKeepAlive=false（Node 会自动输出 Connection: close）
+      if (!isH2 && setConnectionCloseOnShutdown && !res.headersSent) {
+        try {
+          res.shouldKeepAlive = false;
+          // 下面这句可选；shouldKeepAlive=false 已足够，保留以兼容旧栈
+          res.setHeader?.('Connection', 'close');
+        } catch {
+          //
+        }
+      }
+
+      const should503 = http503OnShutdown && (http503DelayMs <= 0 || Date.now() - shutdownStartedAt >= http503DelayMs);
+
+      if (should503) {
+        res.statusCode = 503;
+        res.end('server reloading');
+        return;
+      }
+    }
+
+    const done = () => {
+      res.removeListener('finish', done);
+      res.removeListener('close', done);
+
+      const m = metaMap.get(socket);
+      if (!m) return;
+      m.active = Math.max(0, m.active - 1);
+
+      // 关停期且该 socket 已无在途请求 → 优雅收尾
+      if (isShuttingDown && m.active === 0 && !m._ended) {
+        m._ended = true;
+        try {
+          socket.end();
+        } catch {
+          //
+        }
+      }
+    };
+
+    res.on('finish', done); // 正常完成
+    res.on('close', done); // 客户端提前断开
+  });
+
+  // --------- WebSocket / Socket.IO 关闭 ----------
+  function closeWebSockets() {
+    for (const s of wsServers) {
+      if (s && s.clients && typeof s.clients.forEach === 'function') {
+        try {
+          s.clients.forEach((client) => {
+            // 1001: going away
+            if (client.readyState === 1 /* OPEN */) client.close(1001, 'Server restart');
+          });
+          setTimeout(
+            () => {
+              s.clients.forEach((client) => {
+                if (client.readyState !== 3 /* CLOSED */) client.terminate?.();
+              });
+            },
+            Math.min(socketEndTimeout, killTimeout - 100)
+          ).unref?.();
+        } catch (e) {
+          logger.error('[shutdown] close ws failed:', e);
+        }
+        continue;
+      }
+
+      if (s && typeof s.close === 'function' && s.sockets && s.sockets.sockets) {
+        try {
+          const socketsMap = s.sockets.sockets;
+          if (typeof socketsMap.forEach === 'function') {
+            socketsMap.forEach((sock) => {
+              try {
+                sock.disconnect(true);
+              } catch {
+                //
+              }
+            });
+          } else if (Symbol.iterator in Object(socketsMap)) {
+            for (const [, sock] of socketsMap) {
+              try {
+                sock.disconnect(true);
+              } catch {
+                //
+              }
+            }
+          }
+          s.close(); // 停止接受新连接并关闭现有
+        } catch (e) {
+          logger.error('[shutdown] close socket.io failed:', e);
+        }
+        continue;
+      }
+
+      try {
+        s?.broadcastClose?.('Server restart');
+        s?.terminateAll?.();
+      } catch {
+        //
+      }
+    }
+  }
+
+  // --------- HTTP/2 会话与流管理 ----------
+  const h2Sessions = new Set();
+  const h2Meta = new WeakMap(); // session -> { active: number, closed?: boolean }
+
+  let NGHTTP2_NO_ERROR;
+  try {
+    if (enableHttp2Support) {
+      // eslint-disable-next-line global-require
+      const http2 = require('http2');
+      NGHTTP2_NO_ERROR = http2.constants.NGHTTP2_NO_ERROR;
+
+      // 仅 http2 服务器会触发
+      server.on?.('session', (session) => {
+        h2Sessions.add(session);
+        h2Meta.set(session, { active: 0 });
+
+        session.on('close', () => h2Sessions.delete(session));
+
+        // 统计活跃流, Http2Stream
+        session.on('stream', (stream) => {
+          const meta = h2Meta.get(session);
+          if (meta) meta.active++;
+
+          // 关停窗口内：可选择拒绝“新建流”
+          if (isShuttingDown && http2RefuseNewStreamsOnShutdown) {
+            const should503 =
+              http503OnShutdown && (http503DelayMs <= 0 || Date.now() - shutdownStartedAt >= http503DelayMs);
+            try {
+              // 用 503 语义清晰，Node 没有直接暴露 REFUSED_STREAM 常量
+              stream.respond({ ':status': should503 ? 503 : 200 });
+              if (should503) stream.end('server reloading');
+              else stream.end(); // 若不打 503，可立即结束，以促使客户端重建到新实例
+              return;
+            } catch {
+              //
+            }
+          }
+
+          const onDone = () => {
+            stream.removeListener('close', onDone);
+            stream.removeListener('aborted', onDone);
+            const m = h2Meta.get(session);
+            if (!m) return;
+            m.active = Math.max(0, m.active - 1);
+            if (isShuttingDown && m.active === 0 && !m.closed) {
+              m.closed = true;
+              try {
+                session.close();
+              } catch {
+                //
+              }
+            }
+          };
+          stream.on('close', onDone);
+          stream.on('aborted', onDone);
+        });
+      });
+    }
+  } catch (e) {
+    // 环境不支持 http2，忽略
+    NGHTTP2_NO_ERROR = undefined;
+  }
+
+  // --------- h1 TCP socket 收尾 ----------
+  function drainTcpSockets() {
+    sockets.forEach((socket) => {
+      const meta = metaMap.get(socket) || { active: 0 };
+      if (meta.active === 0 && !meta._ended) {
+        meta._ended = true;
+        try {
+          socket.end();
+        } catch {
+          //
+        }
+      }
+    });
+
+    // 兜底：到点仍未关闭的强制 destroy（避免泄露）
+    const hardKillAfter = Math.min(socketEndTimeout, Math.max(0, killTimeout - 200));
+    setTimeout(() => {
+      sockets.forEach((socket) => {
+        try {
+          socket.destroy();
+        } catch {
+          //
+        }
+      });
+    }, hardKillAfter).unref?.();
+  }
+
+  function gracefulExit() {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    shutdownStartedAt = Date.now();
+    logger.info('[shutdown] starting graceful shutdown');
+
+    // (A) HTTP/1.x：温和缩短 keep-alive（可选）
+    if (tuneKeepAlive) {
+      setTimeout(
+        () => {
+          try {
+            const ka = Math.max(50, Number(kaGentleMs) || 600); // 安全下限 50ms
+            if ('keepAliveTimeout' in server) server.keepAliveTimeout = ka;
+            if ('headersTimeout' in server) server.headersTimeout = Math.max(server.headersTimeout || 0, ka + 1000);
+            // 不设置 requestTimeout（保持 0 / 无限），避免掐在途
+          } catch {
+            //
+          }
+        },
+        Math.max(0, Number(kaPhaseDelayMs) || 0)
+      ).unref?.();
+    }
+
+    // (B) HTTP/2：向现有会话发 GOAWAY，阻止新流（让已有流跑完）
+    if (enableHttp2Support && NGHTTP2_NO_ERROR != null) {
+      for (const session of h2Sessions) {
+        try {
+          session.goaway(NGHTTP2_NO_ERROR);
+        } catch {
+          //
+        }
+      }
+    }
+
+    // 1) 先优雅关闭 WS/Socket.IO
+    closeWebSockets();
+
+    // 2) 停止接收新的 TCP 连接/HTTP 请求/HTTP2 会话
+    if (typeof server.close === 'function') {
+      server.close(() => {
+        logger.log('[shutdown] http server closed, exiting 0');
+        process.exit(0);
+      });
+    }
+
+    // 3) 稍等一会儿再去收尾（减少与在途请求竞争）
+    setTimeout(() => {
+      drainTcpSockets(); // h1
+
+      // h2：对“已无活跃流”的会话关闭
+      if (enableHttp2Support) {
+        for (const session of h2Sessions) {
+          const meta = h2Meta.get(session) || { active: 0 };
+          if (meta.active === 0 && !meta.closed) {
+            meta.closed = true;
+            try {
+              session.close();
+            } catch {
+              //
+            }
+          }
+        }
+      }
+    }, quietEndDelay).unref?.();
+
+    // 4) h2 兜底：到点仍未关闭的会话直接 destroy，避免泄露
+    const hardKillAfter = Math.min(socketEndTimeout, Math.max(0, killTimeout - 200));
+    setTimeout(() => {
+      if (enableHttp2Support) {
+        for (const session of h2Sessions) {
+          try {
+            session.destroy();
+          } catch {
+            //
+          }
+        }
+      }
+    }, hardKillAfter).unref?.();
+
+    // 5) 最终兜底：进程仍未退出则强退
+    setTimeout(() => {
+      logger.error('[shutdown] timeout reached, forcing exit 1');
+      process.exit(1);
+    }, killTimeout).unref?.();
+  }
+
+  process.on('message', (msg) => {
+    if (msg === 'shutdown') gracefulExit();
+  });
+  process.on('SIGINT', gracefulExit);
+  process.on('SIGTERM', gracefulExit);
+  process.on('uncaughtException', (err) => {
+    logger.error('uncaughtException:', err);
+    gracefulExit();
+  });
+  process.on('unhandledRejection', (reason) => {
+    logger.error('unhandledRejection:', reason);
+    gracefulExit();
+  });
+}
+
+module.exports = { setupGracefulShutdown };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.49-beta-20250815-032308-7bcf0b85",
+  "version": "1.16.49-beta-20250819-084933-3bcbd851",
   "description": "ArcBlock's JavaScript utility",
   "main": "lib/index.js",
   "files": [
@@ -18,18 +18,19 @@
   "author": "polunzh <polunzh@gmail.com> (http://github.com/polunzh)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/constant": "1.16.49-beta-20250815-032308-7bcf0b85",
-    "@abtnode/db-cache": "1.16.49-beta-20250815-032308-7bcf0b85",
-    "@arcblock/did": "1.21.2",
+    "@abtnode/constant": "1.16.49-beta-20250819-084933-3bcbd851",
+    "@abtnode/db-cache": "1.16.49-beta-20250819-084933-3bcbd851",
+    "@arcblock/did": "1.22.2",
+    "@arcblock/event-hub": "1.22.2",
     "@arcblock/pm2": "^6.0.12",
-    "@blocklet/constant": "1.16.49-beta-20250815-032308-7bcf0b85",
+    "@blocklet/constant": "1.16.49-beta-20250819-084933-3bcbd851",
     "@blocklet/error": "^0.2.5",
-    "@blocklet/meta": "1.16.49-beta-20250815-032308-7bcf0b85",
+    "@blocklet/meta": "1.16.49-beta-20250819-084933-3bcbd851",
     "@blocklet/xss": "^0.2.5",
-    "@ocap/client": "1.21.2",
-    "@ocap/mcrypto": "1.21.2",
-    "@ocap/util": "1.21.2",
-    "@ocap/wallet": "1.21.2",
+    "@ocap/client": "1.22.2",
+    "@ocap/mcrypto": "1.22.2",
+    "@ocap/util": "1.22.2",
+    "@ocap/wallet": "1.22.2",
     "archiver": "^7.0.1",
     "axios": "^1.7.9",
     "axios-mock-adapter": "^2.1.0",
@@ -90,5 +91,5 @@
     "fs-extra": "^11.2.0",
     "jest": "^29.7.0"
   },
-  "gitHead": "75dd236eb42d14a5093c1364e51625412aa91790"
+  "gitHead": "b8bbf2279e9a29bd58eac7b66e1db16e851a183c"
 }