@midwayjs/bootstrap 3.8.1-beta.1 → 3.9.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 - Now midwayjs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/{bootstrap/bootstrap.d.ts → bootstrap.d.ts}

@@ -1,13 +1,13 @@
 import { IMidwayBootstrapOptions, IMidwayContainer } from '@midwayjs/core';
 import { IMidwayLogger } from '@midwayjs/logger';
-export declare function isTypeScriptEnvironment(): boolean;
 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>;
@@ -24,7 +24,7 @@ export declare class Bootstrap {
      */
     static configure(configuration?: IMidwayBootstrapOptions): typeof Bootstrap;
     static getStarter(): BootstrapStarter;
-    static run(): Promise<void>;
+    static run(): Promise<IMidwayContainer>;
     static stop(): Promise<void>;
     static reset(): void;
     /**

package/dist/{bootstrap/bootstrap.js → 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,4 +1,7 @@
 export * from './interface';
-export { isTypeScriptEnvironment, Bootstrap, BootstrapStarter, } from './bootstrap/bootstrap';
-export { ClusterBootstrap, ClusterBootstrapStarter } from './bootstrap/cluster';
+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

@@ -14,13 +14,17 @@ 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.ClusterBootstrapStarter = exports.ClusterBootstrap = 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 bootstrap_1 = require("./bootstrap/bootstrap");
-Object.defineProperty(exports, "isTypeScriptEnvironment", { enumerable: true, get: function () { return bootstrap_1.isTypeScriptEnvironment; } });
+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, "Bootstrap", { enumerable: true, get: function () { return bootstrap_1.Bootstrap; } });
 Object.defineProperty(exports, "BootstrapStarter", { enumerable: true, get: function () { return bootstrap_1.BootstrapStarter; } });
-var cluster_1 = require("./bootstrap/cluster");
-Object.defineProperty(exports, "ClusterBootstrap", { enumerable: true, get: function () { return cluster_1.ClusterBootstrap; } });
-Object.defineProperty(exports, "ClusterBootstrapStarter", { enumerable: true, get: function () { return cluster_1.ClusterBootstrapStarter; } });
+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

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import type { IMidwayBootstrapOptions } from '@midwayjs/core';
 import type { IMidwayLogger } from '@midwayjs/logger';
 import { ClusterSettings } from 'cluster';
 import { WorkerOptions } from 'worker_threads';
@@ -21,8 +20,27 @@ export interface ForkOptions {
     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;
+export declare type ClusterOptions = ForkOptions & ClusterSettings & {
+    sticky?: boolean;
+    stickyLoadBalancingMethod?: 'random' | 'round-robin' | 'least-connection';
+};
 export declare type ThreadOptions = ForkOptions & WorkerOptions;
-export declare type ClusterBootstrapOptions = IMidwayBootstrapOptions & ClusterOptions;
 //# sourceMappingURL=interface.d.ts.map

package/dist/{fork → manager}/base.d.ts

@@ -1,5 +1,5 @@
 import { ForkOptions } from '../interface';
-import type { IEventBus } from '@midwayjs/event-bus';
+import type { IEventBus, EventBusOptions } from '@midwayjs/event-bus';
 export declare abstract class AbstractForkManager<T, ClusterOptions extends ForkOptions> {
     readonly options: ClusterOptions;
     private reforks;
@@ -7,9 +7,10 @@ export declare abstract class AbstractForkManager<T, ClusterOptions extends Fork
     private unexpectedCount;
     private disconnects;
     private hub;
-    protected workers: Set<T>;
+    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,13 +31,29 @@ 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;
     abstract getWorkerId(worker: T): string;
     abstract isWorkerDead(worker: T): boolean;
     abstract closeWorker(worker: T): any;
-    abstract createEventBus(): IEventBus<T>;
+    abstract createEventBus(eventBusOptions: EventBusOptions): IEventBus<T>;
+    abstract isPrimary(): boolean;
 }
 //# sourceMappingURL=base.d.ts.map

package/dist/{fork → manager}/base.js

@@ -15,16 +15,20 @@ class AbstractForkManager {
         this.unexpectedCount = 0;
         this.disconnects = {};
         this.hub = new events_1.EventEmitter();
-        this.workers = new Set();
+        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;
-        this.eventBus = this.createEventBus();
+        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'];
@@ -48,7 +52,7 @@ class AbstractForkManager {
         this.bindWorkerExit((worker, code, signal) => {
             debug(' - worker(%s): trigger event = exit', this.getWorkerId(worker));
             // remove worker
-            // this.workers.delete(worker);
+            this.workers.delete(this.getWorkerId(worker));
             if (worker['disableRefork']) {
                 return;
             }
@@ -68,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
@@ -79,7 +84,8 @@ class AbstractForkManager {
         for (let i = 0; i < this.options.count; i++) {
             const w = this.createWorker();
             debug(' - worker(%s) created', this.getWorkerId(w));
-            this.workers.add(w);
+            this.eventBus.addWorker(w);
+            this.workers.set(this.getWorkerId(w), w);
         }
         await this.eventBus.start();
     }
@@ -87,8 +93,7 @@ class AbstractForkManager {
         if (this.allowRefork()) {
             debug(' - worker(%s): allow refork and will fork new', this.getWorkerId(oldWorker));
             const newWorker = this.createWorker(oldWorker);
-            this.workers.add(newWorker);
-            debug('----after create', newWorker.process.pid);
+            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);
         }
@@ -155,14 +160,63 @@ 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();
-        for (const worker of this.workers) {
+        for (const worker of this.workers.values()) {
             worker['disableRefork'] = true;
             await this.killWorker(worker, timeout);
         }
+        if (this.exitListener) {
+            await this.exitListener();
+        }
+    }
+    hasWorker(workerId) {
+        return this.workers.has(workerId);
+    }
+    getWorker(workerId) {
+        return this.workers.get(workerId);
+    }
+    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;

package/dist/{fork → manager}/cp.d.ts

@@ -11,6 +11,7 @@ export declare class ClusterManager extends AbstractForkManager<Worker, ClusterO
     getWorkerId(worker: Worker): string;
     isWorkerDead(worker: Worker): boolean;
     closeWorker(worker: Worker): void;
-    createEventBus(): any;
+    createEventBus(options: any): any;
+    isPrimary(): boolean;
 }
 //# sourceMappingURL=cp.d.ts.map

package/dist/{fork → manager}/cp.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClusterManager = void 0;
-const cp_1 = require("@midwayjs/event-bus/dist/cp");
+const event_bus_1 = require("@midwayjs/event-bus");
 const base_1 = require("./base");
-const path_1 = require("path");
 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 = {}) {
@@ -13,10 +13,9 @@ class ClusterManager extends base_1.AbstractForkManager {
         this.options = options;
         options.args = options.args || [];
         options.execArgv = options.execArgv || [];
-        if ((0, path_1.extname)(this.options.exec) === '.ts') {
+        if ((0, util_2.isTypeScriptEnvironment)()) {
             options.execArgv.push(...['--require', 'ts-node/register']);
         }
-        debug('Init cluster manager with options: %j', options);
     }
     createWorker() {
         if (cluster['setupPrimary']) {
@@ -25,8 +24,11 @@ class ClusterManager extends base_1.AbstractForkManager {
         else if (cluster['setupMaster']) {
             cluster['setupMaster'](this.options);
         }
-        console.log('----cluster=', process.pid);
-        return cluster.fork();
+        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');
@@ -45,8 +47,11 @@ class ClusterManager extends base_1.AbstractForkManager {
     closeWorker(worker) {
         worker.kill('SIGTERM');
     }
-    createEventBus() {
-        return new cp_1.ChildProcessEventBus();
+    createEventBus(options) {
+        return new event_bus_1.ChildProcessEventBus(options);
+    }
+    isPrimary() {
+        return !cluster.isWorker;
     }
 }
 exports.ClusterManager = ClusterManager;

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 workerExitListener;
+    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/{fork → manager}/thread.js

@@ -1,28 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThreadManager = void 0;
-const path_1 = require("path");
 const base_1 = require("./base");
-let threads = null;
-let shareEnv = null;
-let Worker = null;
-let ThreadEventBus = null;
-try {
-    // eslint-disable-next-line node/no-unsupported-features/node-builtins
-    threads = require('worker_threads');
-    shareEnv = threads.SHARE_ENV;
-    Worker = threads.Worker;
-    ThreadEventBus = require('@midwayjs/event-bus').ThreadEventBus;
-}
-catch (e) {
-    // ignore not support worker_threads
-}
+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;
@@ -30,21 +19,21 @@ class ThreadManager extends base_1.AbstractForkManager {
     require(${JSON.stringify(this.options.exec)});
   `;
         // 当前是 ts 环境
-        if ((0, path_1.extname)(this.options.exec) === '.ts') {
+        if ((0, util_1.isTypeScriptEnvironment)()) {
             content = `
     require("ts-node/register/transpile-only");
     ${content}
     `;
-            w = new Worker(content, { eval: true, env: shareEnv });
+            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(content, { eval: true, env: shareEnv });
+            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);
+            this.workerExitListener(w, code);
         });
         return w;
     }
@@ -52,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);
@@ -63,8 +52,11 @@ class ThreadManager extends base_1.AbstractForkManager {
     async closeWorker(worker) {
         await worker.terminate();
     }
-    createEventBus() {
-        return new ThreadEventBus();
+    createEventBus(options) {
+        return new event_bus_1.ThreadEventBus(options);
+    }
+    isPrimary() {
+        return worker_threads_1.isMainThread;
     }
 }
 exports.ThreadManager = ThreadManager;

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

@@ -1,3 +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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleep = exports.logDate = void 0;
+exports.isTypeScriptEnvironment = exports.sleep = exports.logDate = void 0;
 function logDate() {
     const d = new Date();
     let date = d.getDate();
@@ -30,8 +30,19 @@ function logDate() {
     else if (milliseconds < 100) {
         milliseconds = '0' + milliseconds;
     }
-    return d.getFullYear() + '-' + month + '-' + date + ' ' +
-        hours + ':' + mintues + ':' + seconds + ('.') + milliseconds;
+    return (d.getFullYear() +
+        '-' +
+        month +
+        '-' +
+        date +
+        ' ' +
+        hours +
+        ':' +
+        mintues +
+        ':' +
+        seconds +
+        '.' +
+        milliseconds);
 }
 exports.logDate = logDate;
 async function sleep(timeout) {
@@ -40,4 +51,13 @@ async function sleep(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.1-beta.1",
+  "version": "3.9.1",
   "description": "midwayjs bootstrap",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -21,14 +21,12 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@midwayjs/async-hooks-context-manager": "^3.8.0",
-    "@midwayjs/event-bus": "0.0.1"
+    "@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"
   },
@@ -38,7 +36,7 @@
     "url": "https://github.com/midwayjs/midway.git"
   },
   "engines": {
-    "node": ">=12"
+    "node": ">=12.11.0"
   },
-  "gitHead": "a603d2348d6141f8f723901498f03a162a037708"
+  "gitHead": "83204ee2b6c0a1e9a1f50b504869b1d48fc18895"
 }

package/dist/bootstrap/cluster.d.ts

@@ -1,18 +0,0 @@
-import { Bootstrap, BootstrapStarter } from './bootstrap';
-import { ClusterBootstrapOptions } from '../interface';
-export declare class ClusterBootstrapStarter extends BootstrapStarter {
-    protected globalOptions: ClusterBootstrapOptions;
-    private clusterManager;
-    init(): Promise<any>;
-    run(): Promise<void>;
-    stop(): Promise<void>;
-}
-export declare class ClusterBootstrap extends Bootstrap {
-    /**
-     * set global configuration for midway
-     * @param configuration
-     */
-    static configure(configuration?: ClusterBootstrapOptions): typeof Bootstrap;
-    static getStarter(): BootstrapStarter;
-}
-//# sourceMappingURL=cluster.d.ts.map

package/dist/bootstrap/cluster.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClusterBootstrap = exports.ClusterBootstrapStarter = void 0;
-const bootstrap_1 = require("./bootstrap");
-const cp_1 = require("../fork/cp");
-const path_1 = require("path");
-class ClusterBootstrapStarter extends bootstrap_1.BootstrapStarter {
-    constructor() {
-        super(...arguments);
-        this.globalOptions = {};
-    }
-    async init() {
-        return null;
-    }
-    async run() {
-        this.clusterManager = new cp_1.ClusterManager({
-            exec: (0, path_1.join)(__dirname, 'bootstrap'),
-            ...this.globalOptions,
-        });
-        await this.clusterManager.start();
-    }
-    async stop() {
-        await this.clusterManager.close();
-    }
-}
-exports.ClusterBootstrapStarter = ClusterBootstrapStarter;
-class ClusterBootstrap extends bootstrap_1.Bootstrap {
-    /**
-     * set global configuration for midway
-     * @param configuration
-     */
-    static configure(configuration = {}) {
-        return super.configure(configuration);
-    }
-    static getStarter() {
-        if (!this.starter) {
-            this.starter = new ClusterBootstrapStarter();
-        }
-        return this.starter;
-    }
-}
-exports.ClusterBootstrap = ClusterBootstrap;
-//# sourceMappingURL=cluster.js.map

package/dist/fork/thread.d.ts

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