Question

我在$ http.get调用中有一个很长的promise链，需要花费几分钟的时间才能完成。花费较长时间的部分是for循环，该循环遍历160个一些数组元素并运行一系列的套接字连接测试。但是，在for循环中的第84次迭代前后，整个promise链（或者可能是get调用）重新开始。而另一个仍在运行。然后，第一个完成后，res.send将永远不会进行，而新链会运行，这将无限重复广告。

router.get('/', function(req, res) {
 fs.readdir('C:\\Temp\\hostPorts', function(err, files) {
  console.log('files', files);
  chooseFile(files).then(response => {readTheFile(response).then(async (result) => {
    splitText(result).then( async (final) => {
      console.log('final version', final);
      res.send({file: final});
    })
    // res.send({file: result});
  }).catch(error => {
    console.log(error);
    }) //end catch
  }); //end promise
 }); //end read
}); //end get

这是我的get调用，splitText函数被卡住了。我将在下面发布splitText函数的源代码，但是我可以肯定它以某种方式创建了两个实例，因为每次在第84次迭代时，我的终端控制台都会重新打印初始console.log（'files'，files），然后遍历另一个链中的承诺。

它最终将完成第一个，因为console.log（'final version'，final）确实打印了。但是重新发送从未发生，第二个承诺链继续运行。然后是第三个，等等，等等。

这是长循环中的代码

async function splitText(file){
  let tableData = "<table  border=1 cellspacing=0><tr>";

  let splited = file.trim().split(/\s+/);
        //vars for checking connectivity

        for (let i = 0; i < splited.length; i++) {
            console.log(splited[i] + " " + i);
            if(i < 4 ) {
                tableData += "<th>" + splited[i] + "</th>";
                //if its less than 4 print out table headers
            }
            else if (i == 4){
                tableData += "</tr><tr><td>" + splited[i] + "</td>";
                //if its 4 create a new row for data
            }
            else if (i % 3 == 0){
                //if modulo 3 is 0 then its on a port, checks connectivity and adds it to the row as data after port
                //then starts a new row
                let host = splited[(i - 1)]; //1 index ago was host
                let port = parseInt(splited[(i)]); //current array index is port
                console.log('host: ' + host );
                console.log('port: ' + port );
                await testPort(port, host).then(async (reachable) => {
                  console.log(reachable);
                  if (reachable) {
                    tableData += "<td>" + splited[i] + "</td><td>" + "<font color=\"GREEN\">UP</font>" + "</tr><tr>";
                   }
                  else {
              tableData += "<td>" + splited[i] + "</td><td>" + "<font color=\"RED\">DOWN</font>" + "</tr><tr>";
                    }
                });
              } //end else if
           else {
                tableData += "<td>" + splited[i] + "</td>";
                //otherwise adds tabledata
             }
        } //end for
     return tableData;
} //end function

这是异步功能，用于检查主机/端口是否已启动。

async function testPort(port, host){
 return new Promise(resolve => {
    const socket = new net.Socket();

      const onError = () => {
        socket.destroy();
        resolve(false);
      };

      socket.setTimeout(10000);
      socket.on('error', onError);
      socket.on('timeout', onError);

      socket.connect(port, host, () => {
        socket.end();
     resolve(true);
   }); //end promise
 });

我不确定这是否是HTTP的问题。在花费太长时间后重新启动，但是我将超时设置为5分钟。或者，如果这是没有响应后重新启动的Promise链。但是我真的很想这么做，因为我从来没有将数据返回给客户端，而且据我所知，我从未回想过函数或创建无限循环。

Answer 1

您不能通过在异步语法上混合三种不同的样式来帮助自己。真正的第一步应该是将代码简化为单一样式，从而经常发现问题所在。

我一眼就怀疑您的问题是您如何兑现承诺。您的某些then语句正在执行新的Promise，但没有返回Promise，这意味着您创建了多个Promise链。您也将丢失错误，因为它们没有catch子句。我会重构为

router.get('/', function(req, res) {
  fs.readdir('C:\\Temp\\hostPorts', function(err, files) {
    sendFile()
      .then(result => res.send(result));
      .catch(err => {
        console.error(err);
        res.sendError("Boom");
      }
  }
} 

async function sendFile() {
  const file= await chooseFile(files);
  const contents = await readTheFile(file);
  const splitContents = await splitText(contents);
  return {file: splitContents};
}

这使用了异步等待，比标准的promise链更易于阅读。您始终必须记住使用经典的Promise链从then子句返回Promises，否则您可能会遇到麻烦。

Answer 2

我不确定您使用的是哪个框架，以及它是否具有内部超时来处理重试请求。上面代码的问题之一是测试网络连接是串行发生的。当您要检查许多主机时，它必然会失败/超时。您可以并行测试多个主机。为此，应分开拆分，测试和构建输出的代码。这是基本版本。

function _splitText(file = '') {
  let ret = {
    header: [],
    hosts: {}
  };
  if (!file.length) {
    return ret;
  }
  //split the content
  let splitted = file.trim().split(/\s+/);
  if (splitted.length % 3 !== 1 && splitted.length < 4) {
    console.log('Invalid data!');
    return ret;
  }

  //get header
  ret.header = splitted.splice(0, 4);
  while (splitted.length) {
    const [name, host, port, ...rest] = splitted;
    ret.hosts[name] = {
      host,
      port,
      isReachable: false
    };
    splitted = rest;
  }
  return ret;
}
async function testPort(name, port, host) {
  return new Promise(resolve => {
    const socket = new net.Socket();

    const onError = () => {
      socket.destroy();
      resolve({
        name,
        isReachable: false
      });
    };

    socket.setTimeout(10000);
    socket.on('error', onError);
    socket.on('timeout', onError);

    socket.connect(port, host, () => {
      socket.end();
      resolve({
        name,
        isReachable: true
      });
    }); //end promise
  });
}
async function testPortsParallel(o, nParallel = 5, timeout = 10000) {
  const hostnames = Object.keys(o.hosts);
  let temp;
  while ((temp = hostnames.splice(0, nParallel))) {
    //create async promise for all hosts and wait for them at one go.
    await Promise.all(temp.map(v => testPort(v, o.hosts[v].host, o.hosts[v].port))).then(values => values.forEach(v => o.hosts[v.name].isReachable = v.isReachable));
  }
}

function buildOutput(o) {
  let ret = '<table  border=1 cellspacing=0>';
  //add header
  ret += '<tr><th>' + o.header.join('</th><th>') + '</th></tr>';
  //add hosts
  ret += o.hosts.keys().map(v => '<tr><td>' + [v, o.hosts[v].host, o.hosts[v].port].join('</td><td>') + '</td></tr>').join('');

  ret += '</table>'
}

async function splitText(s) {
  let data = _splitText(s);
  await testPortsParallel(data);
  return buildOutput(data);
}

splitText('name host port IsReachable 1 a b 2 c d');
//console.log(JSON.stringify(output));

希望这可能会有所帮助。您可以根据需要调整要并行测试的服务器数量。

注意：您的testPort fn也有一点香槟。

通话时间过长后，promise链就会重复自身

2 个答案: