bitcore-node/build/src/services/worker.js

A blockchain indexing node with extended capabilities using bitcore

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Worker = exports.WorkerService = void 0;
const cluster_1 = __importDefault(require("cluster"));
const events_1 = require("events");
const config_1 = __importDefault(require("../config"));
const Loggify_1 = require("../decorators/Loggify");
const logger_1 = __importDefault(require("../logger"));
const parseArgv_1 = __importDefault(require("../utils/parseArgv"));
let args = (0, parseArgv_1.default)([], [{ arg: 'DEBUG', type: 'bool' }]);
let WorkerService = class WorkerService extends events_1.EventEmitter {
    constructor() {
        super(...arguments);
        this.workers = new Array();
    }
    async start() {
        if (cluster_1.default.isPrimary) {
            logger_1.default.verbose(`Master ${process.pid} is running`);
            if (!args.DEBUG) {
                for (let worker = 0; worker < config_1.default.numWorkers; worker++) {
                    let newWorker = cluster_1.default.fork();
                    logger_1.default.verbose(`Starting worker number ${worker}`);
                    newWorker.on('message', (msg) => {
                        this.emit(msg.id, msg);
                    });
                    newWorker.on('exit', (code, _signal) => {
                        logger_1.default[code == 0 ? 'info' : 'warn'](`Worker ${newWorker.process.pid} stopped with code ${code}`);
                    });
                    let started = new Promise(resolve => {
                        newWorker.on('listening', () => {
                            resolve();
                        });
                    });
                    this.workers.push({ worker: newWorker, active: false, started });
                }
            }
            const startedPromises = this.workers.map(worker => worker.started);
            return Promise.all(startedPromises);
        }
        else {
            logger_1.default.verbose(`Worker ${process.pid} started`);
            return;
        }
    }
    async stop() { }
    sendTask(task, argument, done) {
        var worker = this.workers.shift();
        if (worker) {
            this.workers.push(worker);
            var id = (Date.now() * Math.random()).toString();
            this.once(id, function (result) {
                done(result.error);
            });
            worker.worker.send({ task, argument, id });
        }
    }
    workerCount() {
        return this.workers.length;
    }
};
exports.WorkerService = WorkerService;
exports.WorkerService = WorkerService = __decorate([
    Loggify_1.LoggifyClass
], WorkerService);
exports.Worker = new WorkerService();
//# sourceMappingURL=worker.js.map