request-fragment.js

'use strict';

const http = require('http');
const https = require('https');
const url = require('url');
const Agent = require('agentkeepalive');
const HttpsAgent = require('agentkeepalive').HttpsAgent;
const { globalTracer, FORMAT_HTTP_HEADERS } = require('opentracing');
const tracer = globalTracer();

// By default tailor supports gzipped response from fragments
const requiredHeaders = {
    'accept-encoding': 'gzip, deflate'
};

const kaAgent = new Agent();
const kaAgentHttps = new HttpsAgent();

/**
 * Simple Request Promise Function that requests the fragment server with
 *  - filtered headers
 *  - Specified timeout from fragment attributes
 *
 * @param {filterHeaders} - Function that handles the header forwarding
 * @param {processFragmentResponse} - Function that handles response processing
 * @param {string} fragmentUrl - URL of the fragment server
 * @param {Object} fragmentAttributes - Attributes passed via fragment tags
 * @param {Object} request - HTTP request stream
 * @param {Object} span - opentracing span context passed for propagation
 * @returns {Promise} Response from the fragment server
 */
module.exports = (filterHeaders, processFragmentResponse) => (
    fragmentUrl,
    fragmentAttributes,
    request,
    span = null
) =>
    new Promise((resolve, reject) => {
        const parsedUrl = url.parse(fragmentUrl);
        const options = Object.assign(
            {
                headers: Object.assign(
                    filterHeaders(fragmentAttributes, request),
                    requiredHeaders
                ),
                timeout: fragmentAttributes.timeout
            },
            parsedUrl
        );

        if (span) {
            tracer.inject(span.context(), FORMAT_HTTP_HEADERS, options.headers);
        }

        const { protocol: reqProtocol, timeout } = options;
        const hasHttpsProtocol = reqProtocol === 'https:';
        const protocol = hasHttpsProtocol ? https : http;
        options.agent = hasHttpsProtocol ? kaAgentHttps : kaAgent;

        if (hasHttpsProtocol && fragmentAttributes.ignoreInvalidSsl) {
            options.rejectUnauthorized = false;
        }

        const fragmentRequest = protocol.request(options);

        if (timeout) {
            fragmentRequest.setTimeout(timeout, fragmentRequest.abort);
        }

        fragmentRequest.on('response', response => {
            try {
                resolve(
                    processFragmentResponse(response, {
                        request,
                        fragmentUrl,
                        fragmentAttributes
                    })
                );
            } catch (e) {
                reject(e);
            }
        });
        fragmentRequest.on('error', reject);
        fragmentRequest.end();
    });