@dazejs/framework/dist/cluster/worker.js

Daze.js - A powerful web framework for Node.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Worker = void 0;
const cluster_1 = __importDefault(require("cluster"));
const debug_1 = __importDefault(require("debug"));
const defered_1 = require("../utils/defered");
const const_1 = require("./const");
const debug = (0, debug_1.default)('daze-framework:cluster');
const defaultOptions = {
    port: 0,
    sticky: false,
    createServer: () => {
    },
};
class Worker {
    constructor(opts) {
        this.options = Object.assign({}, defaultOptions, opts);
    }
    disconnect(refork = true) {
        const { worker } = cluster_1.default;
        if (!worker)
            return;
        if (Reflect.getMetadata(const_1.WORKER_DYING, worker))
            return;
        Reflect.defineMetadata(const_1.WORKER_DYING, true, worker);
        debug('worker disconnect');
        if (refork) {
            worker.send(const_1.WORKER_DISCONNECT);
            worker.once('message', (message) => {
                if (message === const_1.WORKER_DID_FORKED) {
                    this.close();
                }
            });
        }
        else {
            this.close();
        }
    }
    close() {
        let timer;
        const killTimeout = 10 * 1000;
        if (killTimeout > 0) {
            timer = setTimeout(() => {
                debug(`process exit by killed(timeout: ${killTimeout}ms), pid: ${process.pid}`);
                process.exit(1);
            }, killTimeout);
        }
        const { worker } = cluster_1.default;
        if (!worker)
            return;
        debug((`start close server, pid: ${process.pid}`));
        this.server.close(() => {
            debug(`server closed, pid: ${process.pid}`);
            try {
                worker.disconnect();
                clearTimeout(timer);
            }
            catch (e) {
                debug(`already disconnect, pid:${process.pid}`);
            }
        });
    }
    catcheReloadSignal() {
        process.on('message', (message) => {
            if (message !== const_1.RELOAD_SIGNAL)
                return;
            this.disconnect(true);
        });
    }
    run() {
        const deferred = new defered_1.Deferred();
        this.catcheReloadSignal();
        if (!this.options.sticky) {
            this.server = this.options.createServer(this.options.port, () => {
                debug(`server resolved on: ${this.options.port}`);
                deferred.resolve(this.server);
            });
            this.server.on('connection', () => {
                debug(`Request handled by worker: ${process.pid}`);
            });
        }
        else {
            process.on('message', (message, connection) => {
                if (message !== const_1.STIKCY_CONNECTION)
                    return;
                debug('WORKER #%d  got conn from %s', process.pid, connection.remoteAddress);
                this.server.emit('connection', connection);
                connection.resume();
            });
            this.server = this.options.createServer(0, 'localhost', () => {
                debug(`server resolved on: ${0}`);
                deferred.resolve(this.server);
            });
        }
        return deferred.promise;
    }
}
exports.Worker = Worker;
//# sourceMappingURL=worker.js.map