节点。js请求模块获取ETIMEDOUT和ESOCKETTIMEDOUT

Question

我用请求模块和异步模块的组合并行爬行了很多链接
我注意到很多ETIMEDOUT和ESOCKETTIMEDOUT错误，尽管使用chrome可以访问链接并快速响应。

在请求选项中，我将maxSocket限制为2，将timeout限制为10000。我使用限制为2的async.filterLimited（）来减少每次请求的并行性。所以我有2套接字，2个请求和10秒的超时时间来等待来自服务器的头响应，但我得到了这些错误。

在这里s我使用的请求配置：

{
    ...
    pool: {
        maxSockets: 2
    },
    timeout: 10000
    ,
    time: true
    ...
}

以下是我用来生成链接的代码片段：

var self = this;
async.filterLimit(resources, 2, function(resource, callback) {
    request({
        uri: resource.uri
    }, function (error, response, body) {
        if (!error && response.statusCode === 200) {
            ...
        } else {
            self.emit('error', resource, error);
        }
        callback(...);
    })
}, function(result) {
    callback(null, result);
});

我听了错误事件，我看到每当错误代码为ETIMEDOUT时，connect对象为true/false，因此有时是连接超时，有时不是（根据请求文档）

更新：我决定将maxSockets提升到Infinity，这样就不会因为缺少可用的套接字而导致连接中断：

pool: {
    maxSockets: Infinity
}

为了控制带宽，我实现了一种requestLoop方法，该方法使用maxAttemps和retryDelay参数处理请求，以控制请求：

async.filterLimit(resources, 10, function(resource, callback) {
    self.requestLoop({
        uri: resource.uri
    }, 100, 5000, function (error, response, body) {
            var fetched = false;
            if (!error) {
                ...
            } else {
                ....
            }
            callback(...);
        });
}, function(result) {
    callback(null, result);
});

requestLoop的实现：

requestLoop = function(options, attemptsLeft, retryDelay, callback, lastError) {
    var self = this;
    if (attemptsLeft <= 0) {
        callback((lastError != null ? lastError : new Error('...')));
    } else {
        request(options, function (error, response, body) {
            var recoverableErrors = ['ESOCKETTIMEDOUT', 'ETIMEDOUT', 'ECONNRESET', 'ECONNREFUSED'];
            var e;
            if ((error && _.contains(recoverableErrors, error.code)) || (response && (500 <= response.statusCode && response.statusCode < 600))) {
                e = error ? new Error('...');
                e.code = error ? error.code : response.statusCode;
                setTimeout((function () {
                    self.requestLoop(options, --attemptsLeft, retryDelay, callback, e);
                }), retryDelay);
            } else if (!error && (200 <= response.statusCode && response.statusCode < 300)) {
                callback(null, response, body);
            } else if (error) {
                e = new Error('...');
                e.code = error.code;
                callback(e);
            } else {
                e = new Error('...');
                e.code = response.statusCode;
                callback(e);
            }
        });
    }
};

所以总结一下：-提升maxSockets到Infinity来尝试克服套接字连接的超时错误-实现请求循环方法来控制失败的请求和maxAttemps以及retry Delay>的此类请求-还有最大并发请求数由传递给的数量设置async.filter限制

我想指出，我也玩过这里的一切设置，以便获得错误的自由爬行，但到目前为止，尝试也失败了。

仍在寻求有关解决此问题的帮助。

更新2：我决定放弃异步。过滤器限制，并使我自己的限制机制。我只有3个变量来帮助我实现这一点：
pendingRequests-一个包含所有请求的请求数组（稍后将解释）activeRequests-活动请求数maxConcurrentRequests-允许的最大并发请求数

在pendingRequests数组中，我推送一个复杂对象，其中包含对requestLoop函数的引用，以及包含要传递给loop函数的参数的arguments数组：

self.pendingRequests.push({
    "arguments": [{
        uri: resource.uri.toString()
    }, self.maxAttempts, function (error, response, body) {
        if (!error) {
            if (self.policyChecker.isMimeTypeAllowed((response.headers['content-type'] || '').split(';')[0]) &&
                self.policyChecker.isFileSizeAllowed(body)) {
                self.totalBytesFetched += body.length;
                resource.content = self.decodeBuffer(body, response.headers["content-type"] || '', resource);
                callback(null, resource);
            } else {
                self.fetchedUris.splice(self.fetchedUris.indexOf(resource.uri.toString()), 1);
                callback(new Error('Fetch failed because a mime-type is not allowed or file size is bigger than permited'));
            }
        } else {
            self.fetchedUris.splice(self.fetchedUris.indexOf(resource.uri.toString()), 1);
            callback(error);
        }
        self.activeRequests--;
        self.runRequest();
    }],
    "function": self.requestLoop
});
self.runRequest();

您“”注意到末尾调用了runRequest（）。此功能任务是在最大activeRequests限制maxConcurrentRequests的同时，管理请求并在可能的情况下激发请求：

var self = this;
process.nextTick(function() {
    var next;
    if (!self.pendingRequests.length || self.activeRequests >= self.maxConcurrentRequests) {
        return;
    }
    self.activeRequests++;
    next = self.pendingRequests.shift();
    next["function"].apply(self, next["arguments"]);
    self.runRequest();
});

这应该可以解决任何超时错误，通过我的测试，我仍然注意到在我测试过的特定网站上有一些超时。我不能100%肯定这一点，但我认为这是由于支持http服务器的网站的性质，通过执行ip检查，将用户请求限制在最大值，从而返回一些http 400消息，以防止服务器上可能发生的“攻击”。

Answer 1

我发现如果有太多的异步请求，那么ESOCKETTIMEDOUT异常发生在linux。我找到的变通方法是这样做的：

将此选项设置为request（）：agent:false，pool:{maxSockets:100}请注意，在此之后，超时时间可能会变长，因此可能需要增加超时时间。

Answer 2

编辑：副本https://stackoverflow.com/a/37946324/744276

默认情况下，节点有4个工作进程来解析DNS查询。如果您的DNS查询需要很长时间，请求将在DNS阶段被阻止，症状就是ESOCKETTIMEDOUT或ETIMEDOUT。

尝试增加你的uv线程池大小：

export UV_THREADPOOL_SIZE=128
node ...

或者在索引中。js（或您的入口点在哪里）：

#!/usr/bin/env node
process.env.UV_THREADPOOL_SIZE = 128;

function main() {
   ...
}

编辑1：我也写了一篇关于它的博客文章。

编辑2：如果查询是非唯一的，您可能希望使用缓存，如nscd。