@maiyunnet/kebab 9.17.0 → 9.17.2

package/index.d.ts

@@ -5,7 +5,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export declare const VER = "9.17.0";
+export declare const VER = "9.17.2";
 /** --- 框架根目录，以 / 结尾  --- */
 export declare const ROOT_PATH: string;
 /** --- 框架的 LIB，以 / 结尾 --- */

package/index.js

@@ -6,7 +6,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export const VER = '9.17.0';
+export const VER = '9.17.2';
 // --- 服务端用的路径 ---
 const imu = decodeURIComponent(import.meta.url).replace('file://', '').replace(/^\/(\w:)/, '$1');
 /** --- /xxx/xxx --- */

package/lib/core.d.ts

@@ -206,6 +206,15 @@ export declare function sendRestart(hosts?: string[] | 'config'): Promise<Record
     'result': boolean;
     'return': string;
 }>>;
+/**
+ * --- 向主进程（或局域网同代码机子）发送 stop 操作，停止接收新连接并在现有连接全部结束后退出 ---
+ * @param hosts 局域网主机列表，config 表示使用全局配置；不传时通知当前 master
+ * @returns 各主机发送结果
+ */
+export declare function sendStop(hosts?: string[] | 'config'): Promise<Record<string, {
+    'result': boolean;
+    'return': string;
+}>>;
 /** --- PM2 操作类型 --- */
 export type TPm2Action = 'start' | 'stop' | 'restart';
 /**
@@ -213,6 +222,7 @@ export type TPm2Action = 'start' | 'stop' | 'restart';
  * @param name PM2 进程名称
  * @param action PM2 操作类型
  * @param hosts 局域网列表
+ * @returns 各主机是否已接收并排队，不代表 PM2 操作最终执行成功
  */
 export declare function sendPm2(name: string, action?: TPm2Action, hosts?: string[] | 'config'): Promise<Record<string, {
     'result': boolean;

package/lib/core.js

@@ -713,11 +713,62 @@ export async function sendRestart(hosts) {
     }
     return rtn;
 }
+/**
+ * --- 向主进程（或局域网同代码机子）发送 stop 操作，停止接收新连接并在现有连接全部结束后退出 ---
+ * @param hosts 局域网主机列表，config 表示使用全局配置；不传时通知当前 master
+ * @returns 各主机发送结果
+ */
+export async function sendStop(hosts) {
+    if (!hosts) {
+        // --- 本地模式 ---
+        // eslint-disable-next-line no-console
+        console.log('[ Child] Sending stop request...');
+        process.send({
+            'action': 'stop'
+        });
+        return {
+            '127.0.0.1': { 'result': true, 'return': 'Done' }
+        };
+    }
+    if (hosts === 'config') {
+        hosts = globalConfig.hosts;
+    }
+    // --- 未传或 config 展开后为空数组，均回退到本机 ---
+    if (!hosts?.length) {
+        hosts = ['127.0.0.1'];
+    }
+    // --- 局域网模式 ---
+    const time = lTime.stamp();
+    /** --- 返回成功的 host --- */
+    const rtn = {};
+    for (const host of hosts) {
+        const res = await lUndici.get('http://' + host + ':' + globalConfig.rpcPort.toString() + '/' + lCrypto.aesEncrypt(lText.stringifyJson({
+            'action': 'stop',
+            'time': time
+        }), globalConfig.rpcSecret), {
+            'timeout': 5
+        });
+        const content = await res.getContent();
+        if (!content) {
+            rtn[host] = { 'result': false, 'return': 'Timeout' };
+            continue;
+        }
+        const str = content.toString();
+        if (str === 'Done') {
+            rtn[host] = { 'result': true, 'return': 'Done' };
+        }
+        else {
+            rtn[host] = { 'result': false, 'return': str };
+        }
+    }
+    return rtn;
+}
 /**
  * --- 向本机或局域网 RPC 发送 PM2 操作 ---
  * @param name PM2 进程名称
  * @param action PM2 操作类型
  * @param hosts 局域网列表
+ * @returns 各主机是否已接收并排队，不代表 PM2 操作最终执行成功
  */
 export async function sendPm2(name, action = 'restart', hosts) {
     if (hosts === 'config') {

package/lib/db/conn.d.ts

@@ -53,9 +53,12 @@ export declare class Connection {
      */
     isUsing(): boolean;
     /**
-     * --- 判断是否可用（丢失的也算不可用），返回 true 代表获取成功并自动刷新最后时间 ---
+     * --- 判断是否可用（丢失的也算不可用），返回 true 代表获取成功 ---
+     * @param opt 获取选项，连接巡检独占时不刷新最后使用时间
      */
-    using(): boolean;
+    using(opt?: {
+        'refreshLast'?: boolean;
+    }): boolean;
     /**
      * --- 取消占用 ---
      */
@@ -85,7 +88,12 @@ export declare class Connection {
      * --- 关闭连接，一般情况下不使用 ---
      */
     end(): Promise<boolean>;
-    beginTransaction(): Promise<boolean>;
+    /**
+     * --- 开启事务，只能在独占连接中使用 ---
+     * @param logError 失败时是否记录错误，连接池在非最后一次重试时传 false
+     * @returns 是否开启成功
+     */
+    beginTransaction(logError?: boolean): Promise<boolean>;
     commit(): Promise<boolean>;
     rollback(): Promise<boolean>;
 }

package/lib/db/conn.js

@@ -99,14 +99,17 @@ export class Connection {
         return this._using;
     }
     /**
-     * --- 判断是否可用（丢失的也算不可用），返回 true 代表获取成功并自动刷新最后时间 ---
+     * --- 判断是否可用（丢失的也算不可用），返回 true 代表获取成功 ---
+     * @param opt 获取选项，连接巡检独占时不刷新最后使用时间
      */
-    using() {
+    using(opt = {}) {
         if (this._lost || this._using) {
             return false;
         }
         else {
-            this.refreshLast();
+            if (opt.refreshLast !== false) {
+                this.refreshLast();
+            }
             this._using = true;
             return true;
         }
@@ -281,6 +284,8 @@ export class Connection {
      * --- 关闭连接，一般情况下不使用 ---
      */
     async end() {
+        // --- 驱动的 end 事件可能在异步关闭完成后才触发，提前标记避免连接池在关闭期间重新取到本连接 ---
+        this._lost = true;
         try {
             await this._link.end();
             return true;
@@ -289,8 +294,12 @@ export class Connection {
             return false;
         }
     }
-    // --- 事务，只能在独占连接中使用，pool 创建事务返回独占连接，commit 或 rollback 释放连接回连接池 ---
-    async beginTransaction() {
+    /**
+     * --- 开启事务，只能在独占连接中使用 ---
+     * @param logError 失败时是否记录错误，连接池在非最后一次重试时传 false
+     * @returns 是否开启成功
+     */
+    async beginTransaction(logError = true) {
         if (this._using) {
             try {
                 this._transaction = true;
@@ -306,12 +315,16 @@ export class Connection {
                 this._transaction = false;
                 this._using = false;
                 this._lost = true;
-                lCore.log({}, '[DB][Connection][beginTransaction] ' + lText.stringifyError(e), '-error');
+                if (logError) {
+                    lCore.log({}, '[DB][Connection][beginTransaction] ' + lText.stringifyError(e), '-error');
+                }
                 return false;
             }
         }
         else {
-            lCore.log({}, '[DB][Connection][beginTransaction] connection is not in use', '-error');
+            if (logError) {
+                lCore.log({}, '[DB][Connection][beginTransaction] connection is not in use', '-error');
+            }
             return false;
         }
     }

package/lib/db/pool.js

@@ -67,6 +67,10 @@ async function checkConnection() {
             }
             continue;
         }
+        // --- 巡检探活或关闭前先独占连接，避免业务在异步操作期间取到同一连接 ---
+        if (!connection.using({ 'refreshLast': false })) {
+            continue;
+        }
         if (connection.getLast() <= now - 30) {
             // --- 超 30 秒未被使用，则关闭 ---
             await connection.end();
@@ -75,8 +79,9 @@ async function checkConnection() {
             continue;
         }
         // --- 30 秒内使用过，看看连接是否正常 ---
-        if (await connection.isAvailable(false)) {
+        if (await connection.isAvailable(false) && !connection.isLost()) {
             // --- 正常 ---
+            connection.used();
             continue;
         }
         // --- 连接有问题，直接关闭 ---
@@ -120,7 +125,7 @@ export class Pool {
      */
     async query(sql, values) {
         ++this._queries;
-        // --- 获取并自动 using  ---
+        // --- 获取并自动 using ---
         const conn = await this._getConnection();
         if (!conn) {
             return {
@@ -167,7 +172,9 @@ export class Pool {
                 lCore.log(ctr ?? {}, `[DB][Pool][beginTransaction] failed to get connection, service: ${lDb.ESERVICE[this._service]}, database: ${this._etc.name ?? ''}`, '-error');
                 return null;
             }
-            if (!await conn.beginTransaction()) {
+            /** --- 只有最后一次尝试仍失败时才记录原始错误，避免已恢复的重试被误判为业务失败 --- */
+            const logError = i === BEGIN_TRANSACTION_MAX_ATTEMPTS - 1;
+            if (!await conn.beginTransaction(logError)) {
                 continue;
             }
             return new Transaction(ctr, conn);

package/lib/undici/response.d.ts

@@ -31,7 +31,7 @@ export declare class Response {
     /**
      * --- 获取响应读取流对象 ---
      */
-    getStream(): (import("undici/types/readable").default & undici.Dispatcher.BodyMixin) | zlib.Gunzip | zlib.Inflate | zlib.BrotliDecompress | null;
+    getStream(): zlib.BrotliDecompress | zlib.Gunzip | zlib.Inflate | (import("undici/types/readable").default & undici.Dispatcher.BodyMixin) | null;
     /**
      * --- 获取原生响应读取流对象 ---
      */

package/lib/undici.d.ts

@@ -133,6 +133,8 @@ export interface IRequestOptions {
     'retry'?: number;
     /** --- JSON 解析失败后的重试次数，默认 0；仅适用于 ResponseJson 快捷方法，非幂等请求需由调用方保证安全 --- */
     'retryJson'?: number;
+    /** --- JSON 重试验证方法；返回 false 时按 retryJson 的设置重试，仅适用于 ResponseJson 快捷方法 --- */
+    'retryJsonHandler'?: (json: kebab.Json) => boolean;
     /** --- 追踪 location 次数，0 为不追踪，默认为 0 --- */
     'follow'?: number;
     /** --- 自定义 host 映射，如 {'www.maiyun.net': '127.0.0.1'}，或全部映射到一个 host --- */

package/lib/undici.js

@@ -152,7 +152,7 @@ async function requestResponseJson(u, data, opt, action) {
         }
         const rtnStr = rtn.toString();
         const json = lText.parseJson(rtnStr);
-        if (json) {
+        if (json && (opt.retryJsonHandler?.(json) ?? true)) {
             return json;
         }
         if (i < retryJson) {
@@ -162,7 +162,8 @@ async function requestResponseJson(u, data, opt, action) {
         }
         if (opt.log === undefined || opt.log) {
             const requestData = data === undefined ? '' : `, data: ${lText.stringifyJson(data)}`;
-            lCore.log({}, `[UNDICI][${action}] parse json failed, url: ${u}${requestData}, content: ${rtnStr}`, '-neterror');
+            const reason = json ? 'retry json handler returned false' : 'parse json failed';
+            lCore.log({}, `[UNDICI][${action}] ${reason}, url: ${u}${requestData}, content: ${rtnStr}`, '-neterror');
         }
         return false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maiyunnet/kebab",
-  "version": "9.17.0",
+  "version": "9.17.2",
   "description": "Simple, easy-to-use, and fully-featured Node.js framework that is ready-to-use out of the box.",
   "type": "module",
   "keywords": [
@@ -35,7 +35,7 @@
     "@tailwindcss/cli": "^4.3.3",
     "@types/ssh2": "^1.15.5",
     "ajv": "^8.20.0",
-    "ajv-formats": "^3.0.1",
+    "ajv-formats": "^3.0.1", 
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "ejs": "^6.0.1",

package/sys/child.js

@@ -47,6 +47,10 @@ let http2Server;
 const linkCount = {};
 /** --- 是否正在停止，停止时对 HTTP/1.1 响应追加 Connection: close，避免请求完成后连接回到保活池 --- */
 let stopping = false;
+/** --- 当前缓动停止任务，避免重复 IPC 消息触发停止流程 --- */
+let stopPromise = null;
+/** --- 缓动停止是否必须一直等到现有连接全部结束 --- */
+let stopWaitForever = false;
 /** --- 当前活跃的 HTTP/2 会话集合，用于 graceful shutdown 时发送 GOAWAY 帧 --- */
 const http2Sessions = new Set();
 /**
@@ -552,56 +556,66 @@ async function reloadCert() {
     defaultSc = certList.size > 0 ? certList.values().next().value.sc : undefined;
     certHostIndex = {};
 }
+/**
+ * --- 停止接收新连接，并在现有请求、上传、异步任务和 WebSocket 全部结束后退出 worker ---
+ * @param waitForever 是否取消原有的一小时退出兜底，仅完整 stop 命令使用
+ * @returns worker 退出时结束
+ */
+async function gracefulStop(waitForever = false) {
+    if (waitForever) {
+        stopWaitForever = true;
+    }
+    if (stopPromise) {
+        return stopPromise;
+    }
+    stopping = true;
+    stopPromise = (async () => {
+        // --- 向所有 HTTP/2 会话发送 GOAWAY 帧，通知客户端停止在该连接上发送新请求并切换到新连接 ---
+        for (const session of http2Sessions) {
+            try {
+                session.goaway(http2.constants.NGHTTP2_NO_ERROR);
+            }
+            catch { }
+        }
+        httpServer?.close();
+        http2Server?.close();
+        // --- 立即关闭空闲保活连接，活跃连接会继续执行并在响应后关闭 ---
+        httpServer?.closeIdleConnections();
+        clearInterval(hbTimer);
+        sMonitor.stop();
+        // --- 等待活跃请求全部完成；WebSocket 的路由任务会一直保留到连接关闭 ---
+        /** --- 当前已等待时间，restart 最多等待一小时，完整 stop 不限制 --- */
+        let waiting = 0;
+        while (Object.keys(linkCount).length) {
+            const str = [];
+            for (const key in linkCount) {
+                str.push(key + ':' + linkCount[key].toString());
+            }
+            lCore.debug(`[CHILD] Worker ${process.pid} busy: ${str.join(',')}.`);
+            lCore.log({}, `[CHILD] Worker ${process.pid} busy: ${str.join(',')}.`, '-warning');
+            await lCore.sleep(5_000);
+            waiting += 5_000;
+            // --- 再次清理已变为空闲的保活连接 ---
+            httpServer?.closeIdleConnections();
+            if (!stopWaitForever && (waiting > 3_600_000)) {
+                break;
+            }
+        }
+        process.exit();
+    })();
+    return stopPromise;
+}
 // --- 接收主进程回传信号，主要用来 reload，restart ---
 process.on('message', function (msg) {
     (async function () {
         switch (msg.action) {
             case 'reload': {
                 await reload();
-                // eslint-disable-next-line no-console
-                console.log(`[child] Worker ${process.pid} reload execution succeeded.`);
+                lCore.display(`[CHILD] Worker ${process.pid} reload execution succeeded.`);
                 break;
             }
             case 'stop': {
-                // --- 需要停止监听，等待已有连接全部断开，然后关闭线程 ---
-                stopping = true;
-                // --- 向所有 HTTP/2 会话发送 GOAWAY 帧，通知 CDN 客户端停止在该连接上发送新请求并切换到新连接 ---
-                for (const session of http2Sessions) {
-                    try {
-                        session.goaway(http2.constants.NGHTTP2_NO_ERROR);
-                    }
-                    catch { }
-                }
-                httpServer?.close();
-                http2Server?.close();
-                // --- 立即关闭空闲保活连接（无活跃请求的 keep-alive socket），避免进程长时间等待 ---
-                httpServer?.closeIdleConnections();
-                clearInterval(hbTimer);
-                sMonitor.stop();
-                // --- 等待活跃请求全部完成 ---
-                /** --- 当前已等待时间，等待不超过 1 小时 --- */
-                let waiting = 0;
-                while (true) {
-                    if (!Object.keys(linkCount).length) {
-                        break;
-                    }
-                    // --- 有活跃连接，等待中 ---
-                    const str = [];
-                    for (const key in linkCount) {
-                        str.push(key + ':' + linkCount[key].toString());
-                    }
-                    lCore.debug(`[CHILD] Worker ${process.pid} busy: ${str.join(',')}.`);
-                    lCore.log({}, `[CHILD] Worker ${process.pid} busy: ${str.join(',')}.`, '-warning');
-                    await lCore.sleep(5_000);
-                    waiting += 5_000;
-                    // --- 再次清理已变为空闲的保活连接 ---
-                    httpServer?.closeIdleConnections();
-                    if (waiting > 3600_000) {
-                        break;
-                    }
-                }
-                // --- 链接全部断开 ---
-                process.exit();
+                await gracefulStop(msg.waitForever === true);
                 break;
             }
             case 'global': {

package/sys/master.js

@@ -19,6 +19,10 @@ import * as lTime from '#kebab/lib/time.js';
 import * as lZip from '#kebab/lib/zip.js';
 /** --- 当前运行中的子进程列表 --- */
 const workerList = {};
+/** --- master 是否正在缓动停止 --- */
+let stopping = false;
+/** --- 当前缓动停止任务，避免重复 stop 命令触发 --- */
+let stopPromise = null;
 /**
  * --- 判断候选路径是否位于指定根目录内 ---
  * @param rootPath 已解析的真实根目录
@@ -246,6 +250,12 @@ function createRpcListener() {
                     await restartWorkers();
                     break;
                 }
+                case 'stop': {
+                    gracefulStop().catch((e) => {
+                        lCore.display('[master] [gracefulStop]', e);
+                    });
+                    break;
+                }
                 case 'global': {
                     // --- 为所有子进程更新 global 变量 ---
                     for (const pid in workerList) {
@@ -264,7 +274,7 @@ function createRpcListener() {
                     break;
                 }
                 case 'pm2': {
-                    // --- 执行 PM2 操作 ---
+                    // --- 接收 PM2 操作 ---
                     if (!msg.name || typeof msg.name !== 'string') {
                         res.end('Invalid name');
                         return;
@@ -279,12 +289,18 @@ function createRpcListener() {
                         res.end('Invalid pm2Action');
                         return;
                     }
-                    const rtn = await lCore.exec(`pm2 ${msg.pm2Action} ${msg.name}`);
-                    if (rtn === false) {
-                        res.end('Exec failed');
-                        return;
-                    }
-                    break;
+                    // --- 先确认已接收，让调用方完成当前 HTTP 响应，再执行可能终止本进程的 PM2 操作 ---
+                    res.end('Done');
+                    setTimeout(() => {
+                        lCore.exec(`pm2 ${msg.pm2Action} ${msg.name}`).then((rtn) => {
+                            if (rtn === false) {
+                                lCore.display(`[master] PM2 ${msg.pm2Action} ${msg.name} failed.`);
+                            }
+                        }).catch((e) => {
+                            lCore.display(`[master] PM2 ${msg.pm2Action} ${msg.name} failed.`, e);
+                        });
+                    }, 1_000);
+                    return;
                 }
                 case 'npm': {
                     // --- 执行 npm install 操作 ---
@@ -931,10 +947,59 @@ function createRpcListener() {
         });
     }).listen(lCore.globalConfig.rpcPort);
 }
+/**
+ * --- 通知 worker 停止，并等待其现有连接全部结束后退出 ---
+ * @param worker 要停止的 worker
+ * @returns worker 退出后完成
+ */
+function stopWorker(worker) {
+    if (worker.isDead()) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        worker.once('exit', () => { resolve(); });
+        try {
+            if (worker.isConnected()) {
+                worker.send({
+                    'action': 'stop',
+                    'waitForever': true,
+                });
+                return;
+            }
+            worker.process.kill('SIGTERM');
+        }
+        catch (e) {
+            lCore.display(`[master] Failed to notify worker ${worker.process.pid ?? 'undefined'} to stop, using SIGTERM.`, e);
+            worker.process.kill('SIGTERM');
+        }
+    });
+}
+/**
+ * --- 停止命令入口和所有 worker，等待整套 Kebab 进程排空后退出 master ---
+ * @returns 全部 worker 退出后完成
+ */
+async function gracefulStop() {
+    if (stopPromise) {
+        return stopPromise;
+    }
+    stopping = true;
+    stopPromise = (async () => {
+        lCore.display('[master] Graceful stop started.');
+        // --- 包括 restart 时已从 workerList 移除、但仍在排空的旧 worker ---
+        const workers = Object.values(cluster.workers ?? {}).filter((worker) => worker !== undefined);
+        await Promise.all(workers.map(worker => stopWorker(worker)));
+        lCore.display('[master] Graceful stop completed.');
+        process.exit(0);
+    })();
+    return stopPromise;
+}
 /**
  * --- 零宕机重启所有 worker 进程：先创建新进程并等待监听就绪，再停止旧进程 ---
  */
 async function restartWorkers() {
+    if (stopping) {
+        return;
+    }
     // --- 收集旧进程信息（先快照，避免迭代过程中修改 workerList） ---
     const oldEntries = [];
     for (const pid in workerList) {
@@ -946,6 +1011,9 @@ async function restartWorkers() {
     }
     // --- 阶段 1：创建新进程并等待其监听端口就绪 ---
     for (const entry of oldEntries) {
+        if (stopping) {
+            return;
+        }
         const newWorker = await createChildProcess(entry.cpu);
         if (newWorker) {
             await waitForWorkerListening(newWorker);
@@ -953,6 +1021,9 @@ async function restartWorkers() {
     }
     // --- 阶段 2：停止旧进程 ---
     for (const entry of oldEntries) {
+        if (stopping) {
+            return;
+        }
         entry.worker.send({
             'action': 'stop'
         });
@@ -963,6 +1034,9 @@ async function restartWorkers() {
  * --- 检测是否有死掉丢失的子进程，复活之 ---
  */
 async function checkWorkerLost() {
+    if (stopping) {
+        return;
+    }
     const now = Date.now();
     for (const pid in workerList) {
         if (now - workerList[pid].hbtime < 30000) {
@@ -984,6 +1058,9 @@ async function checkWorkerLost() {
  * @param cpu CPU ID
  */
 async function createChildProcess(cpu) {
+    if (stopping) {
+        return null;
+    }
     const worker = cluster.fork();
     if (!worker.process.pid) {
         return null;
@@ -1017,6 +1094,12 @@ async function createChildProcess(cpu) {
                     await restartWorkers();
                     break;
                 }
+                case 'stop': {
+                    gracefulStop().catch((e) => {
+                        lCore.display('[master] [gracefulStop]', e);
+                    });
+                    break;
+                }
                 case 'global': {
                     // --- 为所有子进程更新 global 变量 ---
                     for (const pid in workerList) {

package/www/example/ctr/test.d.ts

@@ -56,6 +56,7 @@ export default class extends sCtr.Ctr {
     coreUpdatecode(): Promise<string>;
     coreReload(): Promise<string>;
     coreRestart(): Promise<string>;
+    coreStop(): Promise<string>;
     corePm2(): Promise<string>;
     coreNpm(): Promise<any>;
     coreGlobal(): Promise<string>;

package/www/example/ctr/test.js

@@ -169,6 +169,7 @@ export default class extends sCtr.Ctr {
             `<br><a href="${this._config.const.urlBase}test/core-ls">View "test/core-ls"</a>`,
             `<br><a href="${this._config.const.urlBase}test/core-reload">View "test/core-reload"</a>`,
             `<br><a href="${this._config.const.urlBase}test/core-restart">View "test/core-restart"</a>`,
+            `<br><a href="${this._config.const.urlBase}test/core-stop">View "test/core-stop"</a>`,
             `<br><a href="${this._config.const.urlBase}test/core-pm2?name=cron&action=restart">View "test/core-pm2"</a>`,
             `<br><a href="${this._config.const.urlBase}test/core-npm">View "test/core-npm"</a>`,
             `<br><a href="${this._config.const.urlBase}test/core-global">View "test/core-global"</a>`,
@@ -1572,6 +1573,10 @@ to: ${to}`
         const list = await lCore.sendRestart();
         return `The restart request has been sent, please review the console.<br>Hosts: ${JSON.stringify(list)}<br><br>` + this._getEnd();
     }
+    async coreStop() {
+        const list = await lCore.sendStop();
+        return `The stop request has been sent, please review the console.<br>Hosts: ${lText.stringifyJson(list)}<br><br>` + this._getEnd();
+    }
     async corePm2() {
         const name = this._get['name'] ?? '';
         const action = (this._get['action'] ?? 'restart');
@@ -2499,10 +2504,29 @@ error: <pre>${JSON.stringify(res.error, null, 4)}</pre>`);
         const echo = [];
         const json = await lUndici.getResponseJson(this._internalUrl + 'test/undici-get-response-json1');
         echo.push(`<pre>const json = await lUndici.getResponseJson('${this._internalUrl}test/undici-get-response-json1');</pre>
-result: <pre>${lText.htmlescape(JSON.stringify(json, null, 4))}</pre>`);
+result: <pre>${lText.htmlescape(JSON.stringify(json, null, 4))}</pre><hr>`);
         const json2 = await lUndici.getResponseJson(this._internalUrl + 'test/undici-get-response-json2');
         echo.push(`<pre>const json2 = await lUndici.getResponseJson('${this._internalUrl}test/undici-get-response-json2');</pre>
-result: <pre>${lText.htmlescape(JSON.stringify(json2, null, 4))}</pre>`);
+result: <pre>${lText.htmlescape(JSON.stringify(json2, null, 4))}</pre><hr>`);
+        /** --- JSON 重试验证方法的执行次数 --- */
+        let retryJsonHandlerCount = 0;
+        const json3 = await lUndici.getResponseJson(this._internalUrl + 'test/undici-get-response-json1', {
+            'retryJson': 1,
+            'retryJsonHandler': (value) => {
+                ++retryJsonHandlerCount;
+                return (retryJsonHandlerCount > 1) && (value.result === 1);
+            },
+        });
+        echo.push(`<pre>let retryJsonHandlerCount = 0;
+const json3 = await lUndici.getResponseJson('${this._internalUrl}test/undici-get-response-json1', {
+    'retryJson': 1,
+    'retryJsonHandler': (value) => {
+        ++retryJsonHandlerCount;
+        return (retryJsonHandlerCount > 1) && (value.result === 1);
+    },
+});</pre>
+handler count: ${retryJsonHandlerCount}
+result: <pre>${lText.htmlescape(JSON.stringify(json3, null, 4))}</pre>`);
         return echo.join('') + '<br>' + this._getEnd();
     }
     undiciGetResponseJson1() {