@midwayjs/bootstrap 3.9.0 → 3.10.0

package/dist/interface.d.ts

@@ -38,9 +38,9 @@ export interface IForkManager<T> {
     isWorkerDead(worker: T): boolean;
     isPrimary(): boolean;
 }
-export declare type ClusterOptions = ForkOptions & ClusterSettings & {
+export type ClusterOptions = ForkOptions & ClusterSettings & {
     sticky?: boolean;
     stickyLoadBalancingMethod?: 'random' | 'round-robin' | 'least-connection';
 };
-export declare type ThreadOptions = ForkOptions & WorkerOptions;
+export type ThreadOptions = ForkOptions & WorkerOptions;
 //# sourceMappingURL=interface.d.ts.map

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/dist/sticky.js

@@ -60,10 +60,11 @@ function setupStickyMaster(httpServer, opts = {}) {
                 socket.destroy();
             }
         };
-        socket.on('data', buffer => {
-            const data = buffer.toString();
+        socket.on('data', (buffer) => {
+            let encoding = 'utf-8';
+            let data = buffer.toString(encoding);
             if (workerId && connectionId) {
-                cluster.workers[workerId].send({ type: 'sticky:http-chunk', data, connectionId }, sendCallback);
+                cluster.workers[workerId].send({ type: 'sticky:http-chunk', data, encoding, connectionId }, sendCallback);
                 return;
             }
             workerId = computeWorkerId(data);
@@ -71,11 +72,16 @@ function setupStickyMaster(httpServer, opts = {}) {
                 data
                     .substring(0, data.indexOf('\r\n\r\n'))
                     .includes('pgrade: websocket'));
+            // avoid binary data toString error
+            if (data.startsWith('POST') && data.includes('multipart/form-data')) {
+                encoding = 'base64';
+                data = buffer.toString('base64');
+            }
             socket.pause();
             if (mayHaveMultipleChunks) {
                 connectionId = randomId();
             }
-            cluster.workers[workerId].send({ type: 'sticky:connection', data, connectionId }, socket, {
+            cluster.workers[workerId].send({ type: 'sticky:connection', data, encoding, connectionId }, socket, {
                 keepOpen: mayHaveMultipleChunks,
             }, sendCallback);
         });
@@ -105,7 +111,7 @@ exports.setupStickyMaster = setupStickyMaster;
 function setupWorker(io) {
     // store connections that may receive multiple chunks
     const sockets = new Map();
-    process.on('message', ({ type, data, connectionId }, socket) => {
+    process.on('message', ({ type, data, encoding, connectionId }, socket) => {
         switch (type) {
             case 'sticky:connection':
                 if (!socket) {
@@ -114,7 +120,7 @@ function setupWorker(io) {
                     return;
                 }
                 io.httpServer.emit('connection', socket); // inject connection
-                socket.emit('data', Buffer.from(data)); // republish first chunk
+                socket.emit('data', Buffer.from(data, encoding)); // republish first chunk
                 socket.resume();
                 if (connectionId) {
                     sockets.set(connectionId, socket);
@@ -126,7 +132,7 @@ function setupWorker(io) {
             case 'sticky:http-chunk': {
                 const socket = sockets.get(connectionId);
                 if (socket) {
-                    socket.emit('data', Buffer.from(data));
+                    socket.emit('data', Buffer.from(data, encoding));
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/bootstrap",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "description": "midwayjs bootstrap",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -21,14 +21,14 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@midwayjs/async-hooks-context-manager": "^3.9.0",
+    "@midwayjs/async-hooks-context-manager": "^3.10.0",
     "@midwayjs/event-bus": "^1.0.1"
   },
   "devDependencies": {
-    "@midwayjs/core": "^3.9.0",
+    "@midwayjs/core": "^3.10.0",
     "@midwayjs/logger": "^2.15.0",
     "request": "2.88.2",
-    "socket.io-client": "4.5.3"
+    "socket.io-client": "4.5.4"
   },
   "author": "Harry Chen <czy88840616@gmail.com>",
   "repository": {
@@ -38,5 +38,5 @@
   "engines": {
     "node": ">=12.11.0"
   },
-  "gitHead": "5f6603d2c9606fc6fc7ece71f956e89e394efeee"
+  "gitHead": "33d28f1a020963404488e866432916fd15c0952c"
 }