web-dev-qa-db-fra.com

nodejs - Comment promisify http.request? rejeter s'est appelé deux fois

J'essaie d'envelopper http.request Dans 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 je reçois une erreur statusCode du serveur distant, il appellera premier refus et après un peu de temps deuxième rejet. Comment faire correctement pour qu'il n'appelle qu'un seul rejet (je pense que Premier rejet est le bon dans ce cas)? Je pense que j'ai besoin de fermer res moi-même, mais il n'y a pas de méthode close() sur l'objet ClientResponse.

PD: Le second rejet déclenche très rarement - pourquoi?

node.jspromisehttprequest
36
happy_marmoset

Votre code est presque correct. Pour reformuler un peu, vous voulez une fonction qui enveloppe http.request avec ce formulaire:

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()
    });
}

Notez l'ajout de params et postData afin que cela puisse être utilisé comme demande générale. et remarquez la dernière lignereq.end() - qui doit toujours être appelé - manquait dans le code OP.

Appliquer ces quelques modifications au code 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();
    });
}

Ceci n’a pas été testé, mais il devrait bien fonctionner ...

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);
});

Et ces promesses peuvent aussi être chaînées ...

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

Je sais que cette question est ancienne mais la réponse m'a en fait inspiré pour écrire une version moderne d'un client HTTP léger promisifié. Voici une nouvelle version qui:

  • Utiliser la syntaxe JavaScript à jour
  • Valider la saisie
  • Soutenir plusieurs méthodes
  • Est facile à étendre pour le support HTTPS
  • Permettra au client de décider comment traiter les codes de réponse
  • Laissera également le client décider de la façon de traiter les corps non JSON

Code ci-dessous:

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();
    });
}
2
Nicolas Bouvrette