@midwayjs/bootstrap 3.8.0 → 3.9.0

package/dist/bootstrap.d.ts

@@ -1,12 +1,13 @@
 import { IMidwayBootstrapOptions, IMidwayContainer } from '@midwayjs/core';
-export declare function isTypeScriptEnvironment(): boolean;
+import { IMidwayLogger } from '@midwayjs/logger';
 export declare class BootstrapStarter {
     protected appDir: string;
     protected baseDir: string;
     protected globalOptions: Partial<IMidwayBootstrapOptions>;
     protected globalConfig: any;
     private applicationContext;
-    configure(options: IMidwayBootstrapOptions): this;
+    private eventBus;
+    configure(options?: IMidwayBootstrapOptions): this;
     init(): Promise<IMidwayContainer>;
     run(): Promise<void>;
     stop(): Promise<void>;
@@ -14,16 +15,16 @@ export declare class BootstrapStarter {
     protected getBaseDir(): string;
 }
 export declare class Bootstrap {
-    private static starter;
-    private static logger;
-    private static configured;
+    protected static starter: BootstrapStarter;
+    protected static logger: IMidwayLogger;
+    protected static configured: boolean;
     /**
      * set global configuration for midway
      * @param configuration
      */
     static configure(configuration?: IMidwayBootstrapOptions): typeof Bootstrap;
-    private static getStarter;
-    static run(): Promise<void>;
+    static getStarter(): BootstrapStarter;
+    static run(): Promise<IMidwayContainer>;
     static stop(): Promise<void>;
     static reset(): void;
     /**

package/dist/bootstrap.js

@@ -1,45 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Bootstrap = exports.BootstrapStarter = exports.isTypeScriptEnvironment = void 0;
+exports.Bootstrap = exports.BootstrapStarter = void 0;
 const core_1 = require("@midwayjs/core");
 const path_1 = require("path");
 const logger_1 = require("@midwayjs/logger");
 const async_hooks_context_manager_1 = require("@midwayjs/async-hooks-context-manager");
-function isTypeScriptEnvironment() {
-    const TS_MODE_PROCESS_FLAG = process.env.MIDWAY_TS_MODE;
-    if ('false' === TS_MODE_PROCESS_FLAG) {
-        return false;
-    }
-    // eslint-disable-next-line node/no-deprecated-api
-    return TS_MODE_PROCESS_FLAG === 'true' || !!require.extensions['.ts'];
-}
-exports.isTypeScriptEnvironment = isTypeScriptEnvironment;
+const util_1 = require("./util");
+const event_bus_1 = require("@midwayjs/event-bus");
+const sticky_1 = require("./sticky");
 class BootstrapStarter {
     constructor() {
         this.globalOptions = {};
     }
-    configure(options) {
+    configure(options = {}) {
         this.globalOptions = options;
         return this;
     }
     async init() {
-        this.appDir = this.globalOptions.appDir || process.cwd();
-        this.baseDir = this.getBaseDir();
+        this.appDir = this.globalOptions.appDir =
+            this.globalOptions.appDir || process.cwd();
+        this.baseDir = this.globalOptions.baseDir = this.getBaseDir();
+        if (process.env['MIDWAY_FORK_MODE']) {
+            if (process.env['MIDWAY_FORK_MODE'] === 'cluster') {
+                this.eventBus = new event_bus_1.ChildProcessEventBus({
+                    isWorker: true,
+                });
+            }
+            else if (process.env['MIDWAY_FORK_MODE'] === 'thread') {
+                this.eventBus = new event_bus_1.ThreadEventBus({
+                    isWorker: true,
+                });
+            }
+        }
         this.applicationContext = await (0, core_1.initializeGlobalApplicationContext)({
-            ...this.globalOptions,
-            appDir: this.appDir,
-            baseDir: this.baseDir,
             asyncContextManager: (0, async_hooks_context_manager_1.createContextManager)(),
+            ...this.globalOptions,
         });
         return this.applicationContext;
     }
     async run() {
         this.applicationContext = await this.init();
+        if (this.eventBus) {
+            await this.eventBus.start();
+            if (process.env['MIDWAY_STICKY_MODE'] === 'true') {
+                const applicationManager = this.applicationContext.get(core_1.MidwayApplicationManager);
+                const io = applicationManager.getApplication('socketIO');
+                (0, sticky_1.setupWorker)(io);
+            }
+        }
     }
     async stop() {
         if (this.applicationContext) {
             await (0, core_1.destroyGlobalApplicationContext)(this.applicationContext);
         }
+        if (this.eventBus) {
+            await this.eventBus.stop();
+        }
     }
     getApplicationContext() {
         return this.applicationContext;
@@ -48,7 +64,7 @@ class BootstrapStarter {
         if (this.globalOptions.baseDir) {
             return this.globalOptions.baseDir;
         }
-        if (isTypeScriptEnvironment()) {
+        if ((0, util_1.isTypeScriptEnvironment)()) {
             return (0, path_1.join)(this.appDir, 'src');
         }
         else {
@@ -113,6 +129,7 @@ class Bootstrap {
             .then(() => {
             this.logger.info('[midway:bootstrap] current app started');
             global['MIDWAY_BOOTSTRAP_APP_READY'] = true;
+            return this.getApplicationContext();
         })
             .catch(err => {
             this.logger.error(err);

package/dist/index.d.ts

@@ -1,2 +1,7 @@
-export { isTypeScriptEnvironment, Bootstrap, BootstrapStarter, } from './bootstrap';
+export * from './interface';
+export { isTypeScriptEnvironment } from './util';
+export { Bootstrap, BootstrapStarter } from './bootstrap';
+export { ClusterManager } from './manager/cp';
+export { AbstractForkManager } from './manager/base';
+export { setupStickyMaster } from './sticky';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,8 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BootstrapStarter = exports.Bootstrap = exports.isTypeScriptEnvironment = void 0;
+exports.setupStickyMaster = exports.AbstractForkManager = exports.ClusterManager = exports.BootstrapStarter = exports.Bootstrap = exports.isTypeScriptEnvironment = void 0;
+__exportStar(require("./interface"), exports);
+var util_1 = require("./util");
+Object.defineProperty(exports, "isTypeScriptEnvironment", { enumerable: true, get: function () { return util_1.isTypeScriptEnvironment; } });
 var bootstrap_1 = require("./bootstrap");
-Object.defineProperty(exports, "isTypeScriptEnvironment", { enumerable: true, get: function () { return bootstrap_1.isTypeScriptEnvironment; } });
 Object.defineProperty(exports, "Bootstrap", { enumerable: true, get: function () { return bootstrap_1.Bootstrap; } });
 Object.defineProperty(exports, "BootstrapStarter", { enumerable: true, get: function () { return bootstrap_1.BootstrapStarter; } });
+var cp_1 = require("./manager/cp");
+Object.defineProperty(exports, "ClusterManager", { enumerable: true, get: function () { return cp_1.ClusterManager; } });
+var base_1 = require("./manager/base");
+Object.defineProperty(exports, "AbstractForkManager", { enumerable: true, get: function () { return base_1.AbstractForkManager; } });
+var sticky_1 = require("./sticky");
+Object.defineProperty(exports, "setupStickyMaster", { enumerable: true, get: function () { return sticky_1.setupStickyMaster; } });
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IMidwayLogger } from '@midwayjs/logger';
+import { ClusterSettings } from 'cluster';
+import { WorkerOptions } from 'worker_threads';
+export interface ForkOptions {
+    exec?: string;
+    /**
+     * worker num, default is `os.cpus().length`
+     */
+    count?: number;
+    /**
+     * refork when disconect and unexpected exit, default is `true`
+     */
+    refork?: boolean;
+    /**
+     * restart limit, default is `60`
+     */
+    limit?: number;
+    duration?: number;
+    logger?: IMidwayLogger | Console;
+    /**
+     * Some environments set to worker
+     */
+    env?: Record<string, string>;
+    /**
+     *  Worker init Timeout, default is 30s,
+     */
+    workerInitTimeout?: number;
+}
+export interface IForkManager<T> {
+    start(): any;
+    close(): any;
+    hasWorker(workerId: string): boolean;
+    getWorker(workerId: string): T;
+    getWorkerIds(): string[];
+    isWorkerDead(worker: T): boolean;
+    isPrimary(): boolean;
+}
+export declare type ClusterOptions = ForkOptions & ClusterSettings & {
+    sticky?: boolean;
+    stickyLoadBalancingMethod?: 'random' | 'round-robin' | 'least-connection';
+};
+export declare type ThreadOptions = ForkOptions & WorkerOptions;
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/dist/manager/base.d.ts

@@ -0,0 +1,46 @@
+import { ForkOptions } from '../interface';
+import type { IEventBus, EventBusOptions } from '@midwayjs/event-bus';
+export declare abstract class AbstractForkManager<T, ClusterOptions extends ForkOptions> {
+    readonly options: ClusterOptions;
+    private reforks;
+    private disconnectCount;
+    private unexpectedCount;
+    private disconnects;
+    private hub;
+    protected workers: Map<string, T>;
+    protected eventBus: IEventBus<T>;
+    private isClosing;
+    protected constructor(options: ClusterOptions);
+    start(): Promise<void>;
+    protected tryToRefork(oldWorker: T): void;
+    /**
+     * allow refork
+     */
+    protected allowRefork(): boolean;
+    /**
+     * uncaughtException default handler
+     */
+    protected onerror(err: any): void;
+    /**
+     * unexpectedExit default handler
+     */
+    protected onUnexpected(worker: T, code: any, signal: any): void;
+    /**
+     * reachReforkLimit default handler
+     */
+    protected onReachReforkLimit(): void;
+    protected killWorker(worker: any, timeout: any): Promise<void>;
+    close(timeout?: number): Promise<void>;
+    hasWorker(workerId: string): boolean;
+    getWorker(workerId: string): T;
+    getWorkerIds(): string[];
+    abstract createWorker(oldWorker?: T): T;
+    abstract bindWorkerDisconnect(listener: (worker: T) => void): void;
+    abstract bindWorkerExit(listener: (worker: T, code: any, signal: any) => void): void;
+    abstract getWorkerId(worker: T): string;
+    abstract isWorkerDead(worker: T): boolean;
+    abstract closeWorker(worker: T): any;
+    abstract createEventBus(eventBusOptions: EventBusOptions): IEventBus<T>;
+    abstract isPrimary(): boolean;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/manager/base.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractForkManager = void 0;
+const os = require("os");
+const util = require("util");
+const util_1 = require("../util");
+const events_1 = require("events");
+const util_2 = require("util");
+const debug = (0, util_2.debuglog)('midway:bootstrap');
+class AbstractForkManager {
+    constructor(options) {
+        this.options = options;
+        this.reforks = [];
+        this.disconnectCount = 0;
+        this.unexpectedCount = 0;
+        this.disconnects = {};
+        this.hub = new events_1.EventEmitter();
+        this.workers = new Map();
+        this.isClosing = false;
+        options.count = options.count || os.cpus().length - 1;
+        options.refork = options.refork !== false;
+        options.limit = options.limit || 60;
+        options.duration = options.duration || 60000; // 1 min
+        options.logger = options.logger || console;
+        options.workerInitTimeout = options.workerInitTimeout || 30000;
+        this.eventBus = this.createEventBus({
+            initTimeout: options.workerInitTimeout,
+        });
+    }
+    async start() {
+        debug('Start manager with options: %j', this.options);
+        this.bindWorkerDisconnect(worker => {
+            debug(' - worker(%s): trigger event = disconnect', this.getWorkerId(worker));
+            const log = this.options.logger[worker['disableRefork'] ? 'info' : 'error'];
+            this.disconnectCount++;
+            const isDead = this.isWorkerDead(worker);
+            if (isDead) {
+                debug(' - worker(%s): worker is dead', this.getWorkerId(worker));
+                // worker has terminated before disconnect
+                this.options.logger.info("[%s] [bootstrap:master:%s] don't fork, because worker:%s exit event emit before disconnect", (0, util_1.logDate)(), process.pid, this.getWorkerId(worker));
+                return;
+            }
+            if (worker['disableRefork']) {
+                debug(' - worker(%s): worker is disableRefork(maybe terminated by master)', this.getWorkerId(worker));
+                // worker has terminated by master
+                log("[%s] [bootstrap:master:%s] don't fork, because worker:%s will be kill soon", (0, util_1.logDate)(), process.pid, this.getWorkerId(worker));
+                return;
+            }
+            this.disconnects[this.getWorkerId(worker)] = (0, util_1.logDate)();
+            this.tryToRefork(worker);
+        });
+        this.bindWorkerExit((worker, code, signal) => {
+            debug(' - worker(%s): trigger event = exit', this.getWorkerId(worker));
+            // remove worker
+            this.workers.delete(this.getWorkerId(worker));
+            if (worker['disableRefork']) {
+                return;
+            }
+            const isExpected = !!this.disconnects[this.getWorkerId(worker)];
+            debug(' - worker(%s): isExpected=%s', this.getWorkerId(worker), isExpected);
+            if (isExpected) {
+                delete this.disconnects[this.getWorkerId(worker)];
+                // worker disconnect first, exit expected
+                return;
+            }
+            debug(' - worker(%s): isWorkerDead=%s', this.getWorkerId(worker), this.isWorkerDead(worker));
+            if (this.isWorkerDead(worker)) {
+                return;
+            }
+            debug(' - worker(%s): unexpectedCount will add');
+            this.unexpectedCount++;
+            this.tryToRefork(worker);
+            this.onUnexpected(worker, code, signal);
+        });
+        this.hub.on('reachReforkLimit', this.onReachReforkLimit.bind(this));
+        // defer to set the listeners
+        // so you can listen this by your own
+        setImmediate(() => {
+            if (process.listeners('uncaughtException').length === 0) {
+                process.on('uncaughtException', this.onerror.bind(this));
+            }
+        });
+        for (let i = 0; i < this.options.count; i++) {
+            const w = this.createWorker();
+            debug(' - worker(%s) created', this.getWorkerId(w));
+            this.eventBus.addWorker(w);
+            this.workers.set(this.getWorkerId(w), w);
+        }
+        await this.eventBus.start();
+    }
+    tryToRefork(oldWorker) {
+        if (this.allowRefork()) {
+            debug(' - worker(%s): allow refork and will fork new', this.getWorkerId(oldWorker));
+            const newWorker = this.createWorker(oldWorker);
+            this.workers.set(this.getWorkerId(newWorker), newWorker);
+            this.options.logger.info('[%s] [bootstrap:master:%s] new worker:%s fork (state: %s)', (0, util_1.logDate)(), process.pid, this.getWorkerId(newWorker), newWorker['state']);
+            this.eventBus.addWorker(newWorker);
+        }
+        else {
+            debug(' - worker(%s): forbidden refork and will stop', this.getWorkerId(oldWorker));
+            this.options.logger.info("[%s] [bootstrap:master:%s] don't fork new work (refork: %s)", (0, util_1.logDate)(), process.pid, this.options.refork);
+        }
+    }
+    /**
+     * allow refork
+     */
+    allowRefork() {
+        if (!this.options.refork || this.isClosing) {
+            return false;
+        }
+        const times = this.reforks.push(Date.now());
+        if (times > this.options.limit) {
+            this.reforks.shift();
+        }
+        const span = this.reforks[this.reforks.length - 1] - this.reforks[0];
+        const canFork = this.reforks.length < this.options.limit || span > this.options.duration;
+        if (!canFork) {
+            this.hub.emit('reachReforkLimit');
+        }
+        return canFork;
+    }
+    /**
+     * uncaughtException default handler
+     */
+    onerror(err) {
+        if (!err) {
+            return;
+        }
+        this.options.logger.error('[%s] [bootstrap:master:%s] master uncaughtException: %s', (0, util_1.logDate)(), process.pid, err.stack);
+        this.options.logger.error(err);
+        this.options.logger.error('(total %d disconnect, %d unexpected exit)', this.disconnectCount, this.unexpectedCount);
+    }
+    /**
+     * unexpectedExit default handler
+     */
+    onUnexpected(worker, code, signal) {
+        // eslint-disable-next-line no-prototype-builtins
+        const propertyName = worker.hasOwnProperty('exitedAfterDisconnect')
+            ? 'exitedAfterDisconnect'
+            : 'suicide';
+        const err = new Error(util.format('worker:%s died unexpected (code: %s, signal: %s, %s: %s, state: %s)', this.getWorkerId(worker), code, signal, propertyName, worker[propertyName], worker['state']));
+        err.name = 'WorkerDiedUnexpectedError';
+        this.options.logger.error('[%s] [bootstrap:master:%s] (total %d disconnect, %d unexpected exit) %s', (0, util_1.logDate)(), process.pid, this.disconnectCount, this.unexpectedCount, err.stack);
+    }
+    /**
+     * reachReforkLimit default handler
+     */
+    onReachReforkLimit() {
+        this.options.logger.error('[%s] [bootstrap:master:%s] worker died too fast (total %d disconnect, %d unexpected exit)', (0, util_1.logDate)(), process.pid, this.disconnectCount, this.unexpectedCount);
+    }
+    async killWorker(worker, timeout) {
+        // kill process, if SIGTERM not work, try SIGKILL
+        await this.closeWorker(worker);
+        await Promise.race([(0, events_1.once)(worker, 'exit'), (0, util_1.sleep)(timeout)]);
+        if (worker.killed)
+            return;
+        // SIGKILL: http://man7.org/linux/man-pages/man7/signal.7.html
+        // worker: https://github.com/nodejs/node/blob/master/lib/internal/cluster/worker.js#L22
+        // subProcess.kill is wrapped to subProcess.destroy, it will wait to disconnected.
+        (worker.process || worker).kill('SIGKILL');
+    }
+    async close(timeout = 2000) {
+        debug('run close');
+        this.isClosing = true;
+        await this.eventBus.stop();
+        for (const worker of this.workers.values()) {
+            worker['disableRefork'] = true;
+            await this.killWorker(worker, timeout);
+        }
+    }
+    hasWorker(workerId) {
+        return this.workers.has(workerId);
+    }
+    getWorker(workerId) {
+        return this.workers.get(workerId);
+    }
+    getWorkerIds() {
+        return Array.from(this.workers.keys());
+    }
+}
+exports.AbstractForkManager = AbstractForkManager;
+//# sourceMappingURL=base.js.map

package/dist/manager/cp.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { Worker } from 'cluster';
+import { ClusterOptions } from '../interface';
+import { AbstractForkManager } from './base';
+export declare class ClusterManager extends AbstractForkManager<Worker, ClusterOptions> {
+    readonly options: ClusterOptions;
+    constructor(options?: ClusterOptions);
+    createWorker(): any;
+    bindWorkerDisconnect(listener: (worker: Worker) => void): void;
+    bindWorkerExit(listener: (worker: Worker, code: any, signal: any) => void): void;
+    getWorkerId(worker: Worker): string;
+    isWorkerDead(worker: Worker): boolean;
+    closeWorker(worker: Worker): void;
+    createEventBus(options: any): any;
+    isPrimary(): boolean;
+}
+//# sourceMappingURL=cp.d.ts.map

package/dist/manager/cp.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterManager = void 0;
+const event_bus_1 = require("@midwayjs/event-bus");
+const base_1 = require("./base");
+const cluster = require('cluster');
+const util_1 = require("util");
+const util_2 = require("../util");
+const debug = (0, util_1.debuglog)('midway:bootstrap');
+class ClusterManager extends base_1.AbstractForkManager {
+    constructor(options = {}) {
+        super(options);
+        this.options = options;
+        options.args = options.args || [];
+        options.execArgv = options.execArgv || [];
+        if ((0, util_2.isTypeScriptEnvironment)()) {
+            options.execArgv.push(...['--require', 'ts-node/register']);
+        }
+    }
+    createWorker() {
+        if (cluster['setupPrimary']) {
+            cluster['setupPrimary'](this.options);
+        }
+        else if (cluster['setupMaster']) {
+            cluster['setupMaster'](this.options);
+        }
+        return cluster.fork({
+            MIDWAY_FORK_MODE: 'cluster',
+            MIDWAY_STICKY_MODE: this.options.sticky ? 'true' : 'false',
+            ...this.options.env,
+        });
+    }
+    bindWorkerDisconnect(listener) {
+        debug('Bind cluster.disconnect event');
+        cluster.on('disconnect', listener);
+    }
+    bindWorkerExit(listener) {
+        debug('Bind cluster.exit event');
+        cluster.on('exit', listener);
+    }
+    getWorkerId(worker) {
+        return String(worker.process.pid);
+    }
+    isWorkerDead(worker) {
+        return worker.isDead();
+    }
+    closeWorker(worker) {
+        worker.kill('SIGTERM');
+    }
+    createEventBus(options) {
+        return new event_bus_1.ChildProcessEventBus(options);
+    }
+    isPrimary() {
+        return !cluster.isWorker;
+    }
+}
+exports.ClusterManager = ClusterManager;
+//# sourceMappingURL=cp.js.map

package/dist/manager/thread.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { ThreadOptions } from '../interface';
+import { AbstractForkManager } from './base';
+import { Worker } from 'worker_threads';
+export declare class ThreadManager extends AbstractForkManager<Worker, ThreadOptions> {
+    readonly options: ThreadOptions;
+    private exitListener;
+    constructor(options?: ThreadOptions);
+    createWorker(): Worker;
+    bindWorkerDisconnect(listener: (worker: Worker) => void): void;
+    bindWorkerExit(listener: (worker: Worker, code: any, signal: any) => void): void;
+    getWorkerId(worker: Worker): any;
+    isWorkerDead(worker: Worker): boolean;
+    closeWorker(worker: Worker): Promise<void>;
+    createEventBus(options: any): any;
+    isPrimary(): boolean;
+}
+//# sourceMappingURL=thread.d.ts.map

package/dist/manager/thread.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadManager = void 0;
+const base_1 = require("./base");
+const worker_threads_1 = require("worker_threads");
+const event_bus_1 = require("@midwayjs/event-bus");
+const util_1 = require("../util");
+class ThreadManager extends base_1.AbstractForkManager {
+    constructor(options = {}) {
+        super(options);
+        this.options = options;
+        options.argv = options.argv || [];
+        options.execArgv = options.execArgv || [];
+        process.env.MIDWAY_FORK_MODE = 'thread';
+    }
+    createWorker() {
+        let w;
+        let content = `
+    require(${JSON.stringify(this.options.exec)});
+  `;
+        // 当前是 ts 环境
+        if ((0, util_1.isTypeScriptEnvironment)()) {
+            content = `
+    require("ts-node/register/transpile-only");
+    ${content}
+    `;
+            w = new worker_threads_1.Worker(content, { eval: true, env: worker_threads_1.SHARE_ENV });
+            w['_originThreadId'] = String(w.threadId);
+            this.options.logger.info('new worker thread with ts-node, threadId = %s.', this.getWorkerId(w));
+        }
+        else {
+            w = new worker_threads_1.Worker(content, { eval: true, env: worker_threads_1.SHARE_ENV });
+            this.options.logger.info('new worker thread, threadId = %s.', this.getWorkerId(w));
+        }
+        w.on('exit', code => {
+            this.exitListener(w, code);
+        });
+        return w;
+    }
+    bindWorkerDisconnect(listener) {
+        // this.disconnectListener = listener;
+    }
+    bindWorkerExit(listener) {
+        this.exitListener = listener;
+    }
+    getWorkerId(worker) {
+        return worker['_originThreadId'] || String(worker.threadId);
+    }
+    isWorkerDead(worker) {
+        return false;
+    }
+    async closeWorker(worker) {
+        await worker.terminate();
+    }
+    createEventBus(options) {
+        return new event_bus_1.ThreadEventBus(options);
+    }
+    isPrimary() {
+        return worker_threads_1.isMainThread;
+    }
+}
+exports.ThreadManager = ThreadManager;
+//# sourceMappingURL=thread.js.map

package/dist/sticky.d.ts

@@ -0,0 +1,3 @@
+export declare function setupStickyMaster(httpServer: any, opts?: {}): void;
+export declare function setupWorker(io: any): void;
+//# sourceMappingURL=sticky.d.ts.map

package/dist/sticky.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupWorker = exports.setupStickyMaster = void 0;
+const cluster = require('cluster');
+const crypto_1 = require("crypto");
+const randomId = () => (0, crypto_1.randomBytes)(8).toString('hex');
+function setupStickyMaster(httpServer, opts = {}) {
+    const options = {
+        loadBalancingMethod: 'least-connection',
+        ...opts,
+    };
+    const sessionIdToWorker = new Map();
+    const sidRegex = /sid=([\w-]{20})/;
+    let currentIndex = 0; // for round-robin load balancing
+    const computeWorkerId = data => {
+        const match = sidRegex.exec(data);
+        if (match) {
+            const sid = match[1];
+            const workerId = sessionIdToWorker.get(sid);
+            if (workerId && cluster.workers[workerId]) {
+                return workerId;
+            }
+        }
+        switch (options.loadBalancingMethod) {
+            case 'random': {
+                const workerIds = Object.keys(cluster.workers);
+                return workerIds[Math.floor(Math.random() * workerIds.length)];
+            }
+            case 'round-robin': {
+                const workerIds = Object.keys(cluster.workers);
+                currentIndex++;
+                if (currentIndex >= workerIds.length) {
+                    currentIndex = 0;
+                }
+                return workerIds[currentIndex];
+            }
+            case 'least-connection':
+                // eslint-disable-next-line no-case-declarations
+                let leastActiveWorker;
+                for (const id in cluster.workers) {
+                    const worker = cluster.workers[id];
+                    if (leastActiveWorker === undefined) {
+                        leastActiveWorker = worker;
+                    }
+                    else {
+                        const c1 = worker['clientsCount'] || 0;
+                        const c2 = leastActiveWorker['clientsCount'] || 0;
+                        if (c1 < c2) {
+                            leastActiveWorker = worker;
+                        }
+                    }
+                }
+                return leastActiveWorker.id;
+        }
+    };
+    httpServer.on('connection', socket => {
+        let workerId, connectionId;
+        const sendCallback = err => {
+            if (err) {
+                socket.destroy();
+            }
+        };
+        socket.on('data', buffer => {
+            const data = buffer.toString();
+            if (workerId && connectionId) {
+                cluster.workers[workerId].send({ type: 'sticky:http-chunk', data, connectionId }, sendCallback);
+                return;
+            }
+            workerId = computeWorkerId(data);
+            const mayHaveMultipleChunks = !(data.startsWith('GET') ||
+                data
+                    .substring(0, data.indexOf('\r\n\r\n'))
+                    .includes('pgrade: websocket'));
+            socket.pause();
+            if (mayHaveMultipleChunks) {
+                connectionId = randomId();
+            }
+            cluster.workers[workerId].send({ type: 'sticky:connection', data, connectionId }, socket, {
+                keepOpen: mayHaveMultipleChunks,
+            }, sendCallback);
+        });
+    });
+    // this is needed to properly detect the end of the HTTP request body
+    httpServer.on('request', req => {
+        req.on('data', () => { });
+    });
+    cluster.on('message', (worker, { type, data }) => {
+        switch (type) {
+            case 'sticky:connection':
+                sessionIdToWorker.set(data, worker.id);
+                if (options.loadBalancingMethod === 'least-connection') {
+                    worker['clientsCount'] = (worker['clientsCount'] || 0) + 1;
+                }
+                break;
+            case 'sticky:disconnection':
+                sessionIdToWorker.delete(data);
+                if (options.loadBalancingMethod === 'least-connection') {
+                    worker['clientsCount']--;
+                }
+                break;
+        }
+    });
+}
+exports.setupStickyMaster = setupStickyMaster;
+function setupWorker(io) {
+    // store connections that may receive multiple chunks
+    const sockets = new Map();
+    process.on('message', ({ type, data, connectionId }, socket) => {
+        switch (type) {
+            case 'sticky:connection':
+                if (!socket) {
+                    // might happen if the socket is closed during the transfer to the worker
+                    // see https://nodejs.org/api/child_process.html#child_process_example_sending_a_socket_object
+                    return;
+                }
+                io.httpServer.emit('connection', socket); // inject connection
+                socket.emit('data', Buffer.from(data)); // republish first chunk
+                socket.resume();
+                if (connectionId) {
+                    sockets.set(connectionId, socket);
+                    socket.on('close', () => {
+                        sockets.delete(connectionId);
+                    });
+                }
+                break;
+            case 'sticky:http-chunk': {
+                const socket = sockets.get(connectionId);
+                if (socket) {
+                    socket.emit('data', Buffer.from(data));
+                }
+            }
+        }
+    });
+    const ignoreError = () => { }; // the next request will fail anyway
+    io.engine.on('connection', socket => {
+        process.send({ type: 'sticky:connection', data: socket.id }, ignoreError);
+        socket.once('close', () => {
+            process.send({ type: 'sticky:disconnection', data: socket.id }, ignoreError);
+        });
+    });
+}
+exports.setupWorker = setupWorker;
+//# sourceMappingURL=sticky.js.map

package/dist/util.d.ts

@@ -0,0 +1,4 @@
+export declare function logDate(): string;
+export declare function sleep(timeout: any): Promise<unknown>;
+export declare function isTypeScriptEnvironment(): boolean;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTypeScriptEnvironment = exports.sleep = exports.logDate = void 0;
+function logDate() {
+    const d = new Date();
+    let date = d.getDate();
+    if (date < 10) {
+        date = '0' + date;
+    }
+    let month = d.getMonth() + 1;
+    if (month < 10) {
+        month = '0' + month;
+    }
+    let hours = d.getHours();
+    if (hours < 10) {
+        hours = '0' + hours;
+    }
+    let mintues = d.getMinutes();
+    if (mintues < 10) {
+        mintues = '0' + mintues;
+    }
+    let seconds = d.getSeconds();
+    if (seconds < 10) {
+        seconds = '0' + seconds;
+    }
+    let milliseconds = d.getMilliseconds();
+    if (milliseconds < 10) {
+        milliseconds = '00' + milliseconds;
+    }
+    else if (milliseconds < 100) {
+        milliseconds = '0' + milliseconds;
+    }
+    return (d.getFullYear() +
+        '-' +
+        month +
+        '-' +
+        date +
+        ' ' +
+        hours +
+        ':' +
+        mintues +
+        ':' +
+        seconds +
+        '.' +
+        milliseconds);
+}
+exports.logDate = logDate;
+async function sleep(timeout) {
+    return new Promise(resolve => {
+        setTimeout(resolve, timeout);
+    });
+}
+exports.sleep = sleep;
+function isTypeScriptEnvironment() {
+    const TS_MODE_PROCESS_FLAG = process.env.MIDWAY_TS_MODE;
+    if ('false' === TS_MODE_PROCESS_FLAG) {
+        return false;
+    }
+    // eslint-disable-next-line node/no-deprecated-api
+    return TS_MODE_PROCESS_FLAG === 'true' || !!require.extensions['.ts'];
+}
+exports.isTypeScriptEnvironment = isTypeScriptEnvironment;
+//# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/bootstrap",
-  "version": "3.8.0",
+  "version": "3.9.0",
   "description": "midwayjs bootstrap",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -21,13 +21,12 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@midwayjs/async-hooks-context-manager": "^3.8.0"
+    "@midwayjs/async-hooks-context-manager": "^3.9.0",
+    "@midwayjs/event-bus": "^1.0.1"
   },
   "devDependencies": {
-    "@midwayjs/core": "^3.8.0",
+    "@midwayjs/core": "^3.9.0",
     "@midwayjs/logger": "^2.15.0",
-    "@midwayjs/socketio": "^3.8.0",
-    "@midwayjs/web": "^3.8.0",
     "request": "2.88.2",
     "socket.io-client": "4.5.3"
   },
@@ -37,7 +36,7 @@
     "url": "https://github.com/midwayjs/midway.git"
   },
   "engines": {
-    "node": ">=12"
+    "node": ">=12.11.0"
   },
-  "gitHead": "5c640c7182923587139f9f9c0aecf50585798e1e"
+  "gitHead": "5f6603d2c9606fc6fc7ece71f956e89e394efeee"
 }