@midwayjs/bootstrap 3.9.0 → 3.9.1

package/dist/manager/base.d.ts

@@ -10,6 +10,7 @@ export declare abstract class AbstractForkManager<T, ClusterOptions extends Fork
     protected workers: Map<string, T>;
     protected eventBus: IEventBus<T>;
     private isClosing;
+    private exitListener;
     protected constructor(options: ClusterOptions);
     start(): Promise<void>;
     protected tryToRefork(oldWorker: T): void;
@@ -30,10 +31,22 @@ export declare abstract class AbstractForkManager<T, ClusterOptions extends Fork
      */
     protected onReachReforkLimit(): void;
     protected killWorker(worker: any, timeout: any): Promise<void>;
-    close(timeout?: number): Promise<void>;
+    stop(timeout?: number): Promise<void>;
     hasWorker(workerId: string): boolean;
     getWorker(workerId: string): T;
     getWorkerIds(): string[];
+    onStop(exitListener: any): void;
+    protected bindClose(): void;
+    /**
+     * on bootstrap receive a exit signal
+     * @param signal
+     */
+    private onSignal;
+    /**
+     * on bootstrap process exit
+     * @param code
+     */
+    private onMasterExit;
     abstract createWorker(oldWorker?: T): T;
     abstract bindWorkerDisconnect(listener: (worker: T) => void): void;
     abstract bindWorkerExit(listener: (worker: T, code: any, signal: any) => void): void;

package/dist/manager/base.js

@@ -72,6 +72,7 @@ class AbstractForkManager {
             this.tryToRefork(worker);
             this.onUnexpected(worker, code, signal);
         });
+        this.bindClose();
         this.hub.on('reachReforkLimit', this.onReachReforkLimit.bind(this));
         // defer to set the listeners
         // so you can listen this by your own
@@ -159,7 +160,7 @@ class AbstractForkManager {
         // subProcess.kill is wrapped to subProcess.destroy, it will wait to disconnected.
         (worker.process || worker).kill('SIGKILL');
     }
-    async close(timeout = 2000) {
+    async stop(timeout = 2000) {
         debug('run close');
         this.isClosing = true;
         await this.eventBus.stop();
@@ -167,6 +168,9 @@ class AbstractForkManager {
             worker['disableRefork'] = true;
             await this.killWorker(worker, timeout);
         }
+        if (this.exitListener) {
+            await this.exitListener();
+        }
     }
     hasWorker(workerId) {
         return this.workers.has(workerId);
@@ -177,6 +181,43 @@ class AbstractForkManager {
     getWorkerIds() {
         return Array.from(this.workers.keys());
     }
+    onStop(exitListener) {
+        this.exitListener = exitListener;
+    }
+    bindClose() {
+        // kill(2) Ctrl-C
+        process.once('SIGINT', this.onSignal.bind(this, 'SIGINT'));
+        // kill(3) Ctrl-\
+        process.once('SIGQUIT', this.onSignal.bind(this, 'SIGQUIT'));
+        // kill(15) default
+        process.once('SIGTERM', this.onSignal.bind(this, 'SIGTERM'));
+        process.once('exit', this.onMasterExit.bind(this));
+    }
+    /**
+     * on bootstrap receive a exit signal
+     * @param signal
+     */
+    async onSignal(signal) {
+        if (!this.isClosing) {
+            this.options.logger.info('[bootstrap:master] receive signal %s, closing', signal);
+            try {
+                await this.stop();
+                this.options.logger.info('[bootstrap:master] close done, exiting with code:0');
+                process.exit(0);
+            }
+            catch (err) {
+                this.options.logger.error('[midway:master] close with error: ', err);
+                process.exit(1);
+            }
+        }
+    }
+    /**
+     * on bootstrap process exit
+     * @param code
+     */
+    onMasterExit(code) {
+        this.options.logger.info('[bootstrap:master] exit with code:%s', code);
+    }
 }
 exports.AbstractForkManager = AbstractForkManager;
 //# sourceMappingURL=base.js.map

package/dist/manager/thread.d.ts

@@ -4,7 +4,7 @@ import { AbstractForkManager } from './base';
 import { Worker } from 'worker_threads';
 export declare class ThreadManager extends AbstractForkManager<Worker, ThreadOptions> {
     readonly options: ThreadOptions;
-    private exitListener;
+    private workerExitListener;
     constructor(options?: ThreadOptions);
     createWorker(): Worker;
     bindWorkerDisconnect(listener: (worker: Worker) => void): void;

package/dist/manager/thread.js

@@ -33,7 +33,7 @@ class ThreadManager extends base_1.AbstractForkManager {
             this.options.logger.info('new worker thread, threadId = %s.', this.getWorkerId(w));
         }
         w.on('exit', code => {
-            this.exitListener(w, code);
+            this.workerExitListener(w, code);
         });
         return w;
     }
@@ -41,7 +41,7 @@ class ThreadManager extends base_1.AbstractForkManager {
         // this.disconnectListener = listener;
     }
     bindWorkerExit(listener) {
-        this.exitListener = listener;
+        this.workerExitListener = listener;
     }
     getWorkerId(worker) {
         return worker['_originThreadId'] || String(worker.threadId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/bootstrap",
-  "version": "3.9.0",
+  "version": "3.9.1",
   "description": "midwayjs bootstrap",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -38,5 +38,5 @@
   "engines": {
     "node": ">=12.11.0"
   },
-  "gitHead": "5f6603d2c9606fc6fc7ece71f956e89e394efeee"
+  "gitHead": "83204ee2b6c0a1e9a1f50b504869b1d48fc18895"
 }