नोड में http.request () पर टाइमआउट कैसे सेट करें?

Question 1

मैं एक HTTP क्लाइंट पर एक समयबाह्य सेट करने का प्रयास कर रहा हूं जो http.request का उपयोग करता है जिसमें कोई भाग्य नहीं है। अब तक मैंने जो किया वह यह है:

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

कोई संकेत?

Question 2

बस ऊपर दिए गए उत्तर को स्पष्ट करने के लिए :

अब timeoutविकल्प और संबंधित अनुरोध घटना का उपयोग करना संभव है :

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

Question 3

2019 अपडेट

अब इसे अधिक सुरुचिपूर्ण ढंग से संभालने के लिए विभिन्न तरीके हैं। कृपया इस धागे पर कुछ अन्य उत्तर देखें। टेक तेजी से चलता है, इसलिए उत्तर अक्सर बहुत जल्दी से पुराना हो सकता है। मेरा जवाब अभी भी काम करेगा लेकिन यह विकल्प के रूप में अच्छी तरह से देखने लायक है।

2012 उत्तर

अपने कोड का उपयोग करते हुए, समस्या यह है कि आपने सॉकेट ऑब्जेक्ट पर सामान सेट करने का प्रयास करने से पहले सॉकेट के लिए अनुरोध को सौंपा है। यह सब कुछ ऐसा है:

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

अनुरोध सॉकेट ऑब्जेक्ट असाइन किए जाने पर 'सॉकेट' ईवेंट को निकाल दिया जाता है।

Question 4

इस समय अनुरोध वस्तु पर सीधे ऐसा करने की एक विधि है:

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

यह एक शॉर्टकट विधि है जो सॉकेट ईवेंट को बांधता है और फिर टाइमआउट बनाता है।

संदर्भ: Node.js v0.8.8 मैनुअल और प्रलेखन

Question 5

रोब इवांस anwser मेरे लिए सही ढंग से काम करता है लेकिन जब मैं request.abort () का उपयोग करता हूं, तो यह एक सॉकेट हैंग एरर को फेंकने के लिए होता है जो अनहेल्दी रहता है।

मुझे अनुरोध ऑब्जेक्ट के लिए एक त्रुटि हैंडलर जोड़ना था:

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

Question 6

सरल विधि है।

सेटटाइमआउट का उपयोग करने या सीधे सॉकेट के साथ काम करने के बजाय,
हम ग्राहक उपयोग में 'विकल्प' में 'टाइमआउट' का उपयोग कर सकते हैं

नीचे सर्वर और क्लाइंट दोनों का कोड है, 3 भागों में।

मॉड्यूल और विकल्प भाग:

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

सर्वर भाग:

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

ग्राहक हिस्सा:

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

यदि आप उपरोक्त सभी 3 भागों को एक फ़ाइल में रखते हैं, "a.js", और फिर चलाएँ:

node a.js

फिर, उत्पादन होगा:

startServer
Server listening on http://127.0.0.1:3000

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

उम्मीद है की वो मदद करदे।

Question 7

मेरे लिए - यहाँ करने का कम भ्रमित तरीका है 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 ↑
        });
    });

Question 8

यहाँ @douwe के उत्तर पर विस्तृत जानकारी वह है जहाँ आप http अनुरोध पर एक टाइमआउट डालेंगे।

// 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 () भी ठीक है।

Question 9

आपको नीचे दिए गए अनुरोध के संदर्भ को पास करना चाहिए

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

स्निपेट का विस्तार करें

अनुरोध त्रुटि ईवेंट ट्रिगर हो जाएगा

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

स्निपेट का विस्तार करें

Question 10

जिज्ञासु, अगर आप net.socketsइसके बजाय सीधे उपयोग करते हैं तो क्या होगा ? यहाँ कुछ नमूना कोड है जिन्हें मैंने परीक्षण के उद्देश्य के लिए रखा है:

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