Node.js 节点、Express和MongoDB中的套接字挂起

我正在开发一个平均堆栈应用程序。我请求coincap.io API使用节点和Express中的cronjobs和request library获取硬币数据，在获取数据后，我每隔5分钟将数据推送到我的MLAB MongoDb实例中

我在控制台中遇到以下错误

{ Error: connect ETIMEDOUT 104.17.39.95:80
    at Object._errnoException (util.js:999:13)
    at _exceptionWithHostPort (util.js:1020:20)
    at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1207:14)
  errno: 'ETIMEDOUT',
  code: 'ETIMEDOUT',
  syscall: 'connect',
  address: '104.17.39.95',
  port: 80 }

{ Error: socket hang up
    at createHangUpError (_http_client.js:330:15)
    at Socket.socketOnEnd (_http_client.js:423:23)
    at Socket.emit (events.js:164:20)
    at endReadableNT (_stream_readable.js:1062:12)
    at process._tickCallback (internal/process/next_tick.js:152:19) code: 'ECONNRESET' }

下面是我在server.js文件中的mongoose配置

const options = {
    reconnectTries: 10, // Never stop trying to reconnect
    reconnectInterval: 500, // Reconnect every 500msi.e 0.5 sec
    poolSize: 15, // Maintain up to 15 socket connections
    socketTimeoutMS: 0, // Close sockets after 5 minute of inactivity
    connectTimeoutMS: 0,
    family: 4, // Use IPv4, skip trying IPv6
    keepAlive: true
};

// Connect to database via mongoose
mongoose.connect(config.database, options)
  .then(() => console.log(`MongoDB Connected ${config.database}`))
  .catch(err => console.log(err));

使用以下代码将服务器设置为无超时：

app.listen(port, () => console.log(`Server started on port ${port}`));
app.listen().setTimeout(0); 

下面是获取URL提供的数据的功能

var historyGraphTask = cron.schedule('*/15 * * * *', function () {
    CoinGraph.count(function (err, count) {
        if (err) {
            console.log(err);
        } else {
            CoinGraph.find({}, (err, coinData) => {
                if (err) {
                    console.log(err);
                } else {
                    for (var i = 0; i < coinData.length; i++) {
                        let symbol = coinData[i].symbol;
                        const historyUrl = 'http://coincap.io/history/' + symbol;
                        DataReq(historyUrl).then((data) => {
                            if (data === null || data === undefined) {
                                console.log('Data Error in cron job of graph');
                            } else {
                                const newData = data.Data;
                                HistoryData.findOneAndUpdate({symbol: symbol} , { data : newData  }, { safe: true, upsert: true }  ,(err, historyData) => {
                                    if (err) {
                                        console.log(err);
                                    } else {
                                        CoinGraph.findOneAndUpdate({ symbol: symbol }, { historyData: historyData._id }, { safe: true, upsert: true } , function (err, updatedData) {
                                            if (err) {
                                                console.log(err);
                                            } else {
                                                console.log(updatedData);
                                            }
                                        });
                                    }
                                }); 

                            }
                        }).catch((error) => {
                            console.log(error);
                        });

                    }
                }
            });
        }

    });
});

function DataReq(Url) {
    return new Promise((resolve, reject) => {
        request(Url, {timeout: 0}, function (error, response, body) {
            if (body === undefined || body === null || error) {
                console.log(error);
                return;
            } else {
                const Data = JSON.parse(body);
                if (Data) {
                    resolve({ Data });
                } else {
                    reject();
                }
            }
        });
    });
}

var historyGraphTask=cron.schedule（'*/15****'，函数（）{
CoinGraph.count（函数（err，count）{
如果（错误）{
控制台日志（err）；
}否则{
CoinGraph.find（{}，（err，coinData）=>{
如果（错误）{
控制台日志（err）；
}否则{
对于（var i=0；i{
如果（数据===null | |数据===未定义）{
log（'图形的cron作业中的数据错误'）；
}否则{
const newData=data.data；
findOneAndUpdate（{symbol:symbol}，{data:newData}，{safe:true，upsert:true}，（err，HistoryData）=>{
如果（错误）{
控制台日志（err）；
}否则{
CoinGraph.findOneAndUpdate（{symbol:symbol}，{historyData:historyData.\u id}，{safe:true，upsert:true}，函数（err，updatedata）{
如果（错误）{
控制台日志（err）；
}否则{
console.log（updatedata）；
}
});
}
}); 
}
}).catch（（错误）=>{
console.log（错误）；
});
}
}
});
}
});
});
函数DataReq（Url）{
返回新承诺（（解决、拒绝）=>{
请求（Url，{timeout:0}，函数（错误、响应、正文）{
if（body==未定义| | body===空| |错误）{
console.log（错误）；
返回；
}否则{
const Data=JSON.parse（body）；
如果（数据）{
解析（{Data}）；
}否则{
拒绝（）；
}
}
});
});
}

---

我做错了什么？我已经尝试了所有可能的解决方案，但很长一段时间以来一直坚持这一点。

根据您的代码，它看起来并没有结束。所谓结束，我指的是执行任何回调来结束函数

我的初步发现是，你需要以某种方式进行回调

我建议您在您使用的CRON库或coingraph文档中检查文档，以正确处理请求