@neoskop/paperboy/dist/paperboy.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const retry = require("retry");
const shelljs = require("shelljs");
const logger_1 = require("./logger");
const nats_service_1 = require("./service/nats.service");
const rabbitmq_service_1 = require("./service/rabbitmq.service");
class Paperboy {
    constructor(options) {
        this.options = options;
    }
    build(buildCommand) {
        return __awaiter(this, void 0, void 0, function* () {
            const operation = retry.operation({
                forever: true,
                minTimeout: 1000,
                maxTimeout: 60 * 1000
            });
            yield new Promise(done => {
                operation.attempt(() => __awaiter(this, void 0, void 0, function* () {
                    try {
                        yield new Promise((resolve, reject) => {
                            const buildProcess = shelljs.exec(buildCommand || this.options.command, {
                                async: true
                            });
                            buildProcess.on('exit', (code) => {
                                if (code === 0) {
                                    resolve();
                                }
                                else {
                                    reject(code);
                                }
                            });
                        });
                        done();
                    }
                    catch (error) {
                        logger_1.logger.error(`Build process failed with exit code: ${error}`);
                        if (operation.retry(error)) {
                            logger_1.logger.warn('Retrying build...');
                            return;
                        }
                    }
                }));
            });
        });
    }
    start() {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.options.queue === undefined ||
                this.options.queue.uri === undefined) {
                throw new Error('You need to configure the queue when running paperboy start');
            }
            // initial generation
            yield this.build(this.options.initialCommand);
            // Execute readiness hook if set
            if (this.options.readinessHook && 0 !== this.options.readinessHook.length) {
                shelljs.exec(this.options.readinessHook);
            }
            // Start listening to queue
            let queueService;
            if (this.options.queue.uri.startsWith('nats')) {
                queueService = new nats_service_1.NatsService(this.options, this.build.bind(this));
            }
            else if (this.options.queue.uri.startsWith('amqp')) {
                queueService = new rabbitmq_service_1.RabbitMQService(this.options, this.build.bind(this));
            }
            else {
                throw new Error(`Unknown protocol in queue URI ${this.options.queue.uri}`);
            }
            queueService.listen();
        });
    }
}
exports.Paperboy = Paperboy;
//# sourceMappingURL=paperboy.js.map