hapi-bouncer/dist/utils/normalizeConnections.js

hapi bouncer proxy

'use strict';

exports.__esModule = true;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

exports.default = normalizeConnections;

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _ParsedUrl = require('./ParsedUrl');

var _ParsedUrl2 = _interopRequireDefault(_ParsedUrl);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var HTTPS_MAGIC = 'https?';

function readCert(certDir, key) {
    if (!key) {
        return null;
    }
    var file = _path2.default.resolve(certDir, key);
    if (_fs2.default.existsSync(file)) {
        return _fs2.default.readFileSync(file).toString();
    }

    return null;
}

// export interface RawConnection {
//     from: string;
//     to: string;
// }

// export interface RawConfig {
//     host?: string;
//     tls: TlsRec;
//     connections: RawConnection[];
// }
//
// export interface NormalizedConnection {
//     port?: string;
//     tls?: TlsRec;
// }
// export interface NormalizedConfig {
//     host?: string;
//     connections: NormalizedConnection[];
//     links: Link[];
// }

function normalizeConnections(certDir, rc) {
    var rcTls = rc.tls || {};
    var tls = _extends({
        requestCert: true,
        rejectUnauthorized: false
    }, rcTls, {
        key: readCert(certDir, rcTls.key || 'server.key'),
        cert: readCert(certDir, rcTls.cert || 'server.crt'),
        ca: readCert(certDir, rcTls.ca || 'ca.crt')
    });
    if (!rc.connections) {
        throw new Error('Need connection mappings in config');
    }
    var connMap = {};
    for (var i = 0; i < rc.connections.length; i++) {
        var conn = rc.connections[i];
        var fromUrls = [];
        if (conn.from.indexOf(HTTPS_MAGIC) === 0) {
            var fromUrlPart = conn.from.substring(HTTPS_MAGIC.length);
            fromUrls.push('http' + fromUrlPart);
            fromUrls.push('https' + fromUrlPart);
        } else {
            fromUrls.push(conn.from);
        }

        for (var j = 0; j < fromUrls.length; j++) {
            var fromUrl = fromUrls[j];

            var from = new _ParsedUrl2.default(fromUrl);
            var to = new _ParsedUrl2.default(conn.to);
            var _port = from.port ? from.port : from.protocol === 'https' ? 443 : 80;
            var key = String(_port);
            if (!connMap[key]) {
                connMap[key] = {
                    server: {
                        tls: from.protocol === 'https' ? tls : false,
                        port: _port
                    },
                    links: []
                };
            }
            connMap[key].links.push({ from: from, to: to });
        }
    }

    var connections = Object.keys(connMap).map(function (port) {
        return connMap[port];
    });

    return {
        host: rc.host || '0.0.0.0',
        routes: rc.routes || {},
        connections: connections
    };
}
//# sourceMappingURL=normalizeConnections.js.map