node.js - make - nodejs http server

nodejs-¿Cómo promisificar http.request? rechazo fue llamado dos veces

Question

Estoy tratando de envolver http.request en Promise :

 new Promise(function(resolve, reject) {
    var req = http.request({
        host: ''127.0.0.1'',
        port: 4000,
        method: ''GET'',
        path: ''/api/v1/service''
    }, function(res) {
        if (res.statusCode < 200 || res.statusCode >= 300) {
            // First reject
            reject(new Error(''statusCode='' + res.statusCode));
            return;
        }
        var body = [];
        res.on(''data'', function(chunk) {
            body.push(chunk);
        });
        res.on(''end'', function() {
            try {
                body = JSON.parse(Buffer.concat(body).toString());
            } catch(e) {
                reject(e);
                return;
            }
            resolve(body);
        });
    });
    req.on(''error'', function(err) {
        // Second reject
        reject(err);
    });
    req.write(''test'');
}).then(function(data) {
    console.log(data);
}).catch(function(err) {
    console.log(err);
});

Si recibo un statusCode estado statusCode del servidor remoto, llamará Primero rechazar y después de un poco de tiempo Segundo rechazo . ¿Cómo hacer correctamente para que solo llame a un solo rechazo (creo que el primer rechazo es correcto en este caso)? Creo que necesito cerrar los res , pero no hay close() método close() en el objeto ClientResponse .

UPD: El segundo rechazo se dispara muy raramente, ¿por qué?

Answer 1

Es más fácil para usted usar bluebird api, puede promisify módulo de solicitud y usar la función de solicitud async como una promesa en sí misma, o tiene la opción de usar el módulo request-promise , que hace que no trabaje para crear una promesa sino que use y el objeto que ya encapsula el módulo usando la promesa, aquí hay un ejemplo:

var rp = require(''request-promise'');

rp({host: ''127.0.0.1'',
    port: 4000,
    method: ''GET'',
    path: ''/api/v1/service''})
    .then(function (parsedBody) {
        // GET succeeded... 
    })
    .catch(function (err) {
        // GET failed... 
    });

Answer 2

Sé que esta pregunta es antigua, pero la respuesta me inspiró a escribir una versión moderna de un cliente HTTP ligero y prometido. Aquí hay una nueva versión que:

• Utilice la sintaxis de JavaScript actualizada
• Validar entrada
• Soporta múltiples métodos
• Es fácil de ampliar para el soporte HTTPS
• Permitirá que el cliente decida cómo tratar con los códigos de respuesta
• También permitirá que el cliente decida cómo tratar con cuerpos que no son JSON

Código abajo:

function httpRequest(method, url, body = null) {
    if (![''get'', ''post'', ''head''].includes(method)) {
        throw new Error(`Invalid method: ${method}`);
    }

    let urlObject;

    try {
        urlObject = new URL(url);
    } catch (error) {
        throw new Error(`Invalid url ${url}`);
    }

    if (body && method !== ''post'') {
        throw new Error(`Invalid use of the body parameter while using the ${method.toUpperCase()} method.`);
    }

    let options = {
        method: method.toUpperCase(),
        hostname: urlObject.hostname,
        port: urlObject.port,
        path: urlObject.pathname
    };

    if (body) {
        options.headers[''Content-Length''] = Buffer.byteLength(body);
    }

    return new Promise((resolve, reject) => {

        const clientRequest = http.request(options, incomingMessage => {

            // Response object.
            let response = {
                statusCode: incomingMessage.statusCode,
                headers: incomingMessage.headers,
                body: []
            };

            // Collect response body data.
            incomingMessage.on(''data'', chunk => {
                response.body.push(chunk);
            });

            // Resolve on end.
            incomingMessage.on(''end'', () => {
                if (response.body.length) {

                    response.body = response.body.join();

                    try {
                        response.body = JSON.parse(response.body);
                    } catch (error) {
                        // Silently fail if response is not JSON.
                    }
                }

                resolve(response);
            });
        });

        // Reject on request error.
        clientRequest.on(''error'', error => {
            reject(error);
        });

        // Write request body if present.
        if (body) {
            clientRequest.write(body);
        }

        // Close HTTP connection.
        clientRequest.end();
    });
}

Answer 3

Tu código está casi bien. Para reformular un poco, desea una función que envuelva http.request con este formulario:

function httpRequest(params, postData) {
    return new Promise(function(resolve, reject) {
        var req = http.request(params, function(res) {
            // on bad status, reject
            // on response data, cumulate it
            // on end, parse and resolve
        });
        // on request error, reject
        // if there''s post data, write it to the request
        // important: end the request req.end()
    });
}

Observe la adición de params y postData para que se pueda utilizar como una solicitud de propósito general. Y observe que la última línea req.end() , que siempre debe llamarse, faltaba del código OP.

Aplicando esos cambios de pareja al código OP ...

function httpRequest(params, postData) {
    return new Promise(function(resolve, reject) {
        var req = http.request(params, function(res) {
            // reject on bad status
            if (res.statusCode < 200 || res.statusCode >= 300) {
                return reject(new Error(''statusCode='' + res.statusCode));
            }
            // cumulate data
            var body = [];
            res.on(''data'', function(chunk) {
                body.push(chunk);
            });
            // resolve on end
            res.on(''end'', function() {
                try {
                    body = JSON.parse(Buffer.concat(body).toString());
                } catch(e) {
                    reject(e);
                }
                resolve(body);
            });
        });
        // reject on request error
        req.on(''error'', function(err) {
            // This is not a "Second reject", just a different sort of failure
            reject(err);
        });
        if (postData) {
            req.write(postData);
        }
        // IMPORTANT
        req.end();
    });
}

Esto no se ha probado, pero debería funcionar bien ...

var params = {
    host: ''127.0.0.1'',
    port: 4000,
    method: ''GET'',
    path: ''/api/v1/service''
};
// this is a get, so there''s no post data

httpRequest(params).then(function(body) {
    console.log(body);
});

Y estas promesas pueden ser encadenadas, también ...

httpRequest(params).then(function(body) {
    console.log(body);
    return httpRequest(otherParams);
}).then(function(body) {
    console.log(body);
    // and so on
});