tree-gateway/dist/gateway.js

'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 __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
const _ = require("lodash");
const http = require("http");
const compression = require("compression");
const express = require("express");
const admin_api_1 = require("./admin/api/admin-api");
const users_1 = require("./admin/api/users");
const typescript_rest_1 = require("typescript-rest");
const logger_1 = require("./logger");
const express_logger_1 = require("./express-logger");
const config_1 = require("./service/config");
const configuration_1 = require("./configuration");
const fs = require("fs-extra-promise");
const typescript_ioc_1 = require("typescript-ioc");
const events_1 = require("./config/events");
const path = require("path");
const time_intervals_1 = require("./utils/time-intervals");
const service_discovery_1 = require("./pipeline/servicediscovery/service-discovery");
const events_2 = require("events");
const request_1 = require("./pipeline/stats/request");
const api_1 = require("./pipeline/api");
let Gateway = class Gateway extends events_2.EventEmitter {
    constructor() {
        super();
        this.serverRunning = false;
        this.setMaxListeners(150);
    }
    get server() {
        return this.app;
    }
    get apis() {
        return this.apiPipeline.apis;
    }
    get running() {
        return this.serverRunning;
    }
    getApiConfig(apiId) {
        return this.apiPipeline.getApiConfig(apiId);
    }
    start() {
        return new Promise((resolve, reject) => {
            this.initialize()
                .then(() => {
                this.apiServer = new Map();
                let started = 0;
                let expected = 0;
                if (this.config.gateway.protocol.http) {
                    expected++;
                    const httpServer = http.createServer(this.app);
                    this.apiServer.set('http', httpServer.listen(_.toSafeInteger(this.config.gateway.protocol.http.listenPort), () => {
                        this.logger.info(`Gateway listenning HTTP on port ${this.config.gateway.protocol.http.listenPort}`);
                        started++;
                        if (started === expected) {
                            this.serverRunning = true;
                            this.emit('start', this);
                            resolve();
                        }
                    }));
                }
                if (this.config.gateway.protocol.https) {
                    expected++;
                    const httpsServer = this.createHttpsServer(this.app);
                    this.apiServer.set('https', httpsServer.listen(_.toSafeInteger(this.config.gateway.protocol.https.listenPort), () => {
                        this.logger.info(`Gateway listenning HTTPS on port ${this.config.gateway.protocol.https.listenPort}`);
                        started++;
                        if (started === expected) {
                            this.serverRunning = true;
                            this.emit('start', this);
                            resolve();
                        }
                    }));
                }
            })
                .catch((err) => {
                reject(err);
            });
        });
    }
    startAdmin() {
        return new Promise((resolve, reject) => {
            if (!this.config.gateway.admin) {
                return resolve();
            }
            if (this.adminApp) {
                this.adminServer = new Map();
                let started = 0;
                let expected = 0;
                if (this.config.gateway.admin.protocol.http) {
                    expected++;
                    const httpServer = http.createServer(this.adminApp);
                    httpServer.timeout = time_intervals_1.getMilisecondsInterval(this.config.gateway.timeout, 60000);
                    this.adminServer.set('http', httpServer.listen(_.toSafeInteger(this.config.gateway.admin.protocol.http.listenPort), () => {
                        this.logger.info(`Gateway Admin Server listenning HTTP on port ${this.config.gateway.admin.protocol.http.listenPort}`);
                        started++;
                        if (started === expected) {
                            this.emit('admin-start', this);
                            resolve();
                        }
                    }));
                }
                if (this.config.gateway.admin.protocol.https) {
                    expected++;
                    const httpsServer = this.createHttpsServer(this.adminApp);
                    httpsServer.timeout = time_intervals_1.getMilisecondsInterval(this.config.gateway.timeout, 60000);
                    this.adminServer.set('https', httpsServer.listen(_.toSafeInteger(this.config.gateway.admin.protocol.https.listenPort), () => {
                        this.logger.info(`Gateway Admin Server listenning HTTPS on port ${this.config.gateway.admin.protocol.https.listenPort}`);
                        started++;
                        if (started === expected) {
                            this.emit('admin-start', this);
                            resolve();
                        }
                    }));
                }
            }
            else {
                reject('You must start the Tree-Gateway before.');
            }
        });
    }
    stop() {
        return new Promise((resolve, reject) => {
            if (this.apiServer) {
                let toClose = this.apiServer.size;
                if (toClose === 0) {
                    this.serverRunning = false;
                    this.apiPipeline.clearRoutes();
                    this.emit('stop', this);
                    return resolve();
                }
                this.apiServer.forEach(server => {
                    server.close(() => {
                        toClose--;
                        if (toClose === 0) {
                            this.logger.info('Gateway server stopped');
                            this.serverRunning = false;
                            this.apiPipeline.clearRoutes();
                            this.emit('stop', this);
                            resolve();
                        }
                    });
                });
                this.apiServer = null;
            }
            else {
                this.serverRunning = false;
                this.apiPipeline.clearRoutes();
                this.emit('stop', this);
                resolve();
            }
        });
    }
    stopAdmin() {
        return new Promise((resolve, reject) => {
            if (this.adminServer) {
                let toClose = this.adminServer.size;
                if (toClose === 0) {
                    this.emit('admin-stop', this);
                    return resolve();
                }
                this.adminServer.forEach(server => {
                    server.close(() => {
                        toClose--;
                        if (toClose === 0) {
                            this.logger.info('Gateway Admin server stopped');
                            this.emit('admin-stop', this);
                            resolve();
                        }
                    });
                });
                this.adminServer = null;
            }
            else {
                resolve();
            }
        });
    }
    async restart() {
        this.logger.info(`Gateway is restarting...`);
        await this.stopAdmin();
        await this.stop();
        await this.start();
        await this.startAdmin();
    }
    createHttpsServer(app) {
        const privateKey = fs.readFileSync(this.config.gateway.protocol.https.privateKey, 'utf8');
        const certificate = fs.readFileSync(this.config.gateway.protocol.https.certificate, 'utf8');
        const credentials = { key: privateKey, cert: certificate };
        const https = require('https');
        return https.createServer(credentials, app);
    }
    async loadApis() {
        const configs = await this.configService.getAllApiConfig();
        await this.apiPipeline.loadApis(configs, this.server);
    }
    async reloadApis() {
        this.emit('api-reload', this);
        await this.loadApis();
    }
    updateConfig(packageId, needsReload) {
        if (needsReload) {
            this.config.reload()
                .then(() => {
                this.logger.info(`Configuration reloaded. Restarting server...`);
                return this.restart();
            })
                .then(() => {
                this.logger.info(`Server restarted.`);
                this.logger.info(`Configuration package ${packageId} applied successfuly.`);
            })
                .catch((error) => {
                this.logger.error(`Error updating gateway config.`);
                this.logger.inspectObject(error);
            });
        }
        else {
            this.configService.installAllMiddlewares()
                .then(() => this.reloadApis())
                .then(() => {
                this.logger.info(`Configuration package ${packageId} applied successfuly.`);
            })
                .catch(err => {
                this.logger.error(`Error applying configuration package ${packageId}.`);
                this.logger.inspectObject(err);
            });
        }
    }
    async initialize() {
        try {
            this.app = express();
            await this.configureServer();
            await this.configService.removeAllListeners()
                .on(events_1.ConfigEvents.CONFIG_UPDATED, (packageId, needsReload) => this.updateConfig(packageId, needsReload))
                .on(events_1.ConfigEvents.CIRCUIT_CHANGED, (id, state) => this.apiPipeline.circuitChanged(id, state))
                .subscribeEvents();
            await this.configureAdminServer();
            if (this.requestLogger.isGatewayRequestLogEnabled()) {
                this.requestLogger.initialize();
            }
        }
        catch (err) {
            this.logger.error(`Error configuring gateway server. Config File:\n${JSON.stringify(this.config.gateway)}`);
            this.logger.inspectObject(err);
            throw err;
        }
    }
    async configureServer() {
        this.app.disable('x-powered-by');
        if (!this.config.gateway.disableCompression) {
            this.app.use(compression());
        }
        if (this.config.gateway.underProxy) {
            this.app.enable('trust proxy');
        }
        if (this.config.gateway.accessLogger) {
            express_logger_1.AccessLogger.configureAccessLoger(this.config.gateway.accessLogger, this.config.rootPath, this.app, './logs');
        }
        this.configureHealthcheck();
        await this.configService.installAllMiddlewares();
        await this.serviceDiscovery.loadServiceDiscoveryProviders(this.config.gateway);
        this.apiPipeline.buildGatewayFilters(this.app, this.config.gateway.filter);
        await this.loadApis();
    }
    configureHealthcheck() {
        if (this.config.gateway.healthcheck) {
            this.app.get(this.config.gateway.healthcheck, (req, res) => {
                res.write('OK');
                res.end();
            });
        }
    }
    configureAdminServer() {
        if (this.config.gateway.admin) {
            this.adminApp = express();
            this.adminApp.disable('x-powered-by');
            if (!this.config.gateway.disableCompression) {
                this.adminApp.use(compression());
            }
            if (this.config.gateway.admin.accessLogger) {
                express_logger_1.AccessLogger.configureAccessLoger(this.config.gateway.admin.accessLogger, this.config.rootPath, this.adminApp, './logs/admin');
            }
            this.apiPipeline.buildGatewayFilters(this.adminApp, this.config.gateway.admin.filter);
            this.configureAdminCors();
            this.configureApiDocs();
            users_1.UsersRest.configureAuthMiddleware(this.adminApp);
            typescript_rest_1.Server.buildServices(this.adminApp, ...admin_api_1.default);
            this.adminApp.use((err, req, res, next) => {
                if (err instanceof typescript_rest_1.HttpError) {
                    if (res.headersSent) {
                        return next(err);
                    }
                    res.status(err.statusCode);
                    res.json({ error: err.message, code: err.statusCode });
                }
                else {
                    next(err);
                }
            });
        }
    }
    configureAdminCors() {
        if (this.config.gateway.admin.cors) {
            this.adminApp.use(this.apiPipeline.configureCors(this.config.gateway.admin.cors));
        }
    }
    configureApiDocs() {
        if (this.config.gateway.admin.apiDocs) {
            const isTest = process.env.NODE_ENV === 'test';
            const schemes = (this.config.gateway.admin.protocol.https ? ['https'] : ['http']);
            const swaggerFile = isTest ?
                './dist/admin/api/swagger.json' :
                path.join(__dirname, './admin/api/swagger.json');
            const apiPath = this.config.gateway.admin.apiDocs.path;
            const apiHost = this.config.gateway.admin.apiDocs.host;
            typescript_rest_1.Server.swagger(this.adminApp, swaggerFile, apiPath, apiHost, schemes);
        }
    }
};
__decorate([
    typescript_ioc_1.Inject,
    __metadata("design:type", configuration_1.Configuration)
], Gateway.prototype, "config", void 0);
__decorate([
    typescript_ioc_1.Inject,
    __metadata("design:type", logger_1.Logger)
], Gateway.prototype, "logger", void 0);
__decorate([
    typescript_ioc_1.Inject,
    __metadata("design:type", request_1.RequestLogger)
], Gateway.prototype, "requestLogger", void 0);
__decorate([
    typescript_ioc_1.Inject,
    __metadata("design:type", config_1.ConfigService)
], Gateway.prototype, "configService", void 0);
__decorate([
    typescript_ioc_1.Inject,
    __metadata("design:type", service_discovery_1.ServiceDiscovery)
], Gateway.prototype, "serviceDiscovery", void 0);
__decorate([
    typescript_ioc_1.Inject,
    __metadata("design:type", api_1.ApiPileline)
], Gateway.prototype, "apiPipeline", void 0);
Gateway = __decorate([
    typescript_ioc_1.Singleton,
    typescript_ioc_1.AutoWired,
    __metadata("design:paramtypes", [])
], Gateway);
exports.Gateway = Gateway;
//# sourceMappingURL=gateway.js.map