Şanssız http.request kullanan bir HTTP istemcisinde bir zaman aşımı ayarlamaya çalışıyorum. Şimdiye kadar yaptığım şey şuydu:

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

Herhangi bir ipucu?

Sadece yukarıdaki cevabı netleştirmek için :

Artık timeoutseçeneği ve ilgili istek olayını kullanmak mümkündür :

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

2019 Güncellemesi

Şimdi bunu daha zarif bir şekilde halletmenin çeşitli yolları var. Lütfen bu ileti dizisindeki diğer yanıtlara bakın. Teknoloji hızlı hareket eder, bu nedenle yanıtlar genellikle oldukça hızlı bir şekilde güncelliğini yitirebilir. Cevabım yine işe yarayacak ama alternatiflere de bakmaya değer.

2012 Cevap

Kodunuzu kullanırken sorun, soket nesnesinde bir şeyler ayarlamaya çalışmadan önce isteğe bir soketin atanmasını beklememiş olmanızdır. Hepsi eşzamansız, yani:

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

İsteğe bir soket nesnesi atandığında 'soket' olayı tetiklenir.

Şu anda bunu doğrudan istek nesnesi üzerinde yapmak için bir yöntem var:

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

Bu, soket olayına bağlanan ve ardından zaman aşımını oluşturan bir kısayol yöntemidir.

Başvuru: Node.js v0.8.8 Kılavuzu ve Belgeler

Rob Evans yanıtlayıcısı benim için doğru çalışıyor ancak request.abort () kullandığımda, işlenmeden kalan bir soket kapatma hatası veriyor.

İstek nesnesi için bir hata işleyici eklemem gerekiyordu:

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

Daha basit bir yöntem var.

SetTimeout kullanmak veya doğrudan soket ile çalışmak yerine,
istemci kullanımlarında 'seçenekler' içinde 'zaman aşımı' kullanabiliriz.

Aşağıda hem sunucunun hem de istemcinin kodu 3 kısımdır.

Modül ve seçenekler bölümü:

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

Sunucu bölümü:

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

Müşteri bölümü:

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

Yukarıdaki 3 parçanın tümünü tek bir dosyaya, "a.js" dosyasına koyarsanız ve ardından şunu çalıştırın:

node a.js

daha sonra çıktı:

startServer
Server listening on http://127.0.0.1:3000

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

Umarım yardımcı olur.

Benim için - işte bunu yapmanın daha az kafa karıştırıcı bir yolu 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 ↑
        });
    });

@Douwe cevabını burada detaylandırmak, bir http talebinde zaman aşımı koyacağınız yerdir.

// 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 () da iyidir.

Referansı aşağıdaki gibi talebe iletmelisiniz

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

Hata isteği olayı tetiklenecek

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

Merak ediyorum, net.socketsbunun yerine düz kullanırsanız ne olur ? Test amacıyla bir araya getirdiğim bazı örnek kodlar:

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