@maiyunnet/kebab 9.17.1 → 9.17.3

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() {