Ich versuche, ein Timeout auf einem HTTP-Client festzulegen, der http.request ohne Glück verwendet. Bisher habe ich Folgendes getan:

var options = { ... }
var req = http.request(options, function(res) {
  // Usual stuff: on(data), on(end), chunks, etc...
}

/* This does not work TOO MUCH... sometimes the socket is not ready (undefined) expecially on rapid sequences of requests */
req.socket.setTimeout(myTimeout);  
req.socket.on('timeout', function() {
  req.abort();
});

req.write('something');
req.end();

Irgendwelche Hinweise?

Nur um die Antwort oben zu verdeutlichen :

Jetzt ist es möglich, die timeoutOption und das entsprechende Anforderungsereignis zu verwenden:

// set the desired timeout in options
const options = {
    //...
    timeout: 3000,
};

// create a request
const request = http.request(options, response => {
    // your callback here
});

// use its "timeout" event to abort the request
request.on('timeout', () => {
    request.abort();
});

Update 2019

Es gibt verschiedene Möglichkeiten, dies jetzt eleganter zu handhaben. Bitte sehen Sie einige andere Antworten auf diesen Thread. Tech bewegt sich schnell, so dass Antworten oft ziemlich schnell veraltet sind. Meine Antwort wird immer noch funktionieren, aber es lohnt sich auch, nach Alternativen zu suchen.

2012 Antwort

Bei Verwendung Ihres Codes besteht das Problem darin, dass Sie nicht darauf gewartet haben, dass der Anforderung ein Socket zugewiesen wird, bevor Sie versuchen, Inhalte für das Socket-Objekt festzulegen. Es ist alles asynchron, also:

var options = { ... }
var req = http.request(options, function(res) {
  // Usual stuff: on(data), on(end), chunks, etc...
});

req.on('socket', function (socket) {
    socket.setTimeout(myTimeout);  
    socket.on('timeout', function() {
        req.abort();
    });
});

req.on('error', function(err) {
    if (err.code === "ECONNRESET") {
        console.log("Timeout occurs");
        //specific error treatment
    }
    //other error treatment
});

req.write('something');
req.end();

Das 'Socket'-Ereignis wird ausgelöst, wenn der Anforderung ein Socket-Objekt zugewiesen wird.

In diesem Moment gibt es eine Methode, um dies direkt für das Anforderungsobjekt zu tun:

request.setTimeout(timeout, function() {
    request.abort();
});

Dies ist eine Verknüpfungsmethode, die an das Socket-Ereignis bindet und dann das Zeitlimit erstellt.

Referenz: Node.js v0.8.8 Handbuch und Dokumentation

Die Rob Evans-Antwort funktioniert für mich korrekt, aber wenn ich request.abort () verwende, tritt ein Socket-Aufhängefehler auf, der unbehandelt bleibt.

Ich musste einen Fehlerhandler für das Anforderungsobjekt hinzufügen:

var options = { ... }
var req = http.request(options, function(res) {
  // Usual stuff: on(data), on(end), chunks, etc...
}

req.on('socket', function (socket) {
    socket.setTimeout(myTimeout);  
    socket.on('timeout', function() {
        req.abort();
    });
}

req.on('error', function(err) {
    if (err.code === "ECONNRESET") {
        console.log("Timeout occurs");
        //specific error treatment
    }
    //other error treatment
});

req.write('something');
req.end();

Es gibt eine einfachere Methode.

Anstatt setTimeout zu verwenden oder direkt mit Socket zu arbeiten, können
wir 'Timeout' in den 'Optionen' in Client-Anwendungen verwenden

Unten finden Sie den Code von Server und Client in drei Teilen.

Modul- und Optionsteil:

'use strict';

// Source: https://github.com/nodejs/node/blob/master/test/parallel/test-http-client-timeout-option.js

const assert = require('assert');
const http = require('http');

const options = {
    host: '127.0.0.1', // server uses this
    port: 3000, // server uses this

    method: 'GET', // client uses this
    path: '/', // client uses this
    timeout: 2000 // client uses this, timesout in 2 seconds if server does not respond in time
};

Serverteil:

function startServer() {
    console.log('startServer');

    const server = http.createServer();
    server
            .listen(options.port, options.host, function () {
                console.log('Server listening on http://' + options.host + ':' + options.port);
                console.log('');

                // server is listening now
                // so, let's start the client

                startClient();
            });
}

Client-Teil:

function startClient() {
    console.log('startClient');

    const req = http.request(options);

    req.on('close', function () {
        console.log("got closed!");
    });

    req.on('timeout', function () {
        console.log("timeout! " + (options.timeout / 1000) + " seconds expired");

        // Source: https://github.com/nodejs/node/blob/master/test/parallel/test-http-client-timeout-option.js#L27
        req.destroy();
    });

    req.on('error', function (e) {
        // Source: https://github.com/nodejs/node/blob/master/lib/_http_outgoing.js#L248
        if (req.connection.destroyed) {
            console.log("got error, req.destroy() was called!");
            return;
        }

        console.log("got error! ", e);
    });

    // Finish sending the request
    req.end();
}


startServer();

Wenn Sie alle oben genannten 3 Teile in eine Datei einfügen, "a.js", und dann ausführen:

node a.js

dann wird die Ausgabe sein:

startServer
Server listening on http://127.0.0.1:3000

startClient
timeout! 2 seconds expired
got closed!
got error, req.destroy() was called!

Hoffentlich hilft das.

Für mich - hier ist eine weniger verwirrende Art, das zu tun socket.setTimeout

var request=require('https').get(
    url
   ,function(response){
        var r='';
        response.on('data',function(chunk){
            r+=chunk;
            });
        response.on('end',function(){
            console.dir(r);            //end up here if everything is good!
            });
        }).on('error',function(e){
            console.dir(e.message);    //end up here if the result returns an error
            });
request.on('error',function(e){
    console.dir(e);                    //end up here if a timeout
    });
request.on('socket',function(socket){
    socket.setTimeout(1000,function(){
        request.abort();                //causes error event ↑
        });
    });

Wenn Sie hier auf die Antwort @douwe eingehen, können Sie eine http-Anfrage zeitlich festlegen.

// TYPICAL REQUEST
var req = https.get(http_options, function (res) {                                                                                                             
    var data = '';                                                                                                                                             

    res.on('data', function (chunk) { data += chunk; });                                                                                                                                                                
    res.on('end', function () {
        if (res.statusCode === 200) { /* do stuff with your data */}
        else { /* Do other codes */}
    });
});       
req.on('error', function (err) { /* More serious connection problems. */ }); 

// TIMEOUT PART
req.setTimeout(1000, function() {                                                                                                                              
    console.log("Server connection timeout (after 1 second)");                                                                                                                  
    req.abort();                                                                                                                                               
});

this.abort () ist auch in Ordnung.

Sie sollten die Referenz wie unten angegeben anfordern

var options = { ... }
var req = http.request(options, function(res) {
  // Usual stuff: on(data), on(end), chunks, etc...
});

req.setTimeout(60000, function(){
    this.abort();
}).bind(req);
req.write('something');
req.end();

Das Anforderungsfehlerereignis wird ausgelöst

req.on("error", function(e){
       console.log("Request Error : "+JSON.stringify(e));
  });

Neugierig, was passiert, wenn Sie net.socketsstattdessen gerade verwenden? Hier ist ein Beispielcode, den ich zu Testzwecken zusammengestellt habe:

var net = require('net');

function HttpRequest(host, port, path, method) {
  return {
    headers: [],
    port: 80,
    path: "/",
    method: "GET",
    socket: null,
    _setDefaultHeaders: function() {

      this.headers.push(this.method + " " + this.path + " HTTP/1.1");
      this.headers.push("Host: " + this.host);
    },
    SetHeaders: function(headers) {
      for (var i = 0; i < headers.length; i++) {
        this.headers.push(headers[i]);
      }
    },
    WriteHeaders: function() {
      if(this.socket) {
        this.socket.write(this.headers.join("\r\n"));
        this.socket.write("\r\n\r\n"); // to signal headers are complete
      }
    },
    MakeRequest: function(data) {
      if(data) {
        this.socket.write(data);
      }

      this.socket.end();
    },
    SetupRequest: function() {
      this.host = host;

      if(path) {
        this.path = path;
      }
      if(port) {
        this.port = port;
      }
      if(method) {
        this.method = method;
      }

      this._setDefaultHeaders();

      this.socket = net.createConnection(this.port, this.host);
    }
  }
};

var request = HttpRequest("www.somesite.com");
request.SetupRequest();

request.socket.setTimeout(30000, function(){
  console.error("Connection timed out.");
});

request.socket.on("data", function(data) {
  console.log(data.toString('utf8'));
});

request.WriteHeaders();
request.MakeRequest();