Node.js Hyperledger结构Nodejs SDK Eventhub已关闭

我已经在IBM区块链平台上部署了示例fabcar网络，并且正在使用其中的代码与之交互。当我单独调用每个函数时，交互效果非常好

当我开发节点服务器并公开调用链代码的API时，问题就出现了。一旦我这么做了，我就开始出错了

未能成功调用：：错误：eventhub出现问题：：错误：eventhub已关闭

奇怪的是，当我同时向POST呼叫发送3个请求时，我得到了这个错误。但该记录被插入到IBM云上

当我同时发送100个请求时，只有大约20个请求被插入到云中，其余的请求显示这个错误和一个类似这样的额外错误

错误：[Orderer.js]：sendBroadcast-on错误：“错误：14不可用：连接失败\n在createStatusError（/home/trs-laptop-20/Downloads/fabcar network/node_modules/fabric client/node_modules/grpc/src/client.js:64:15）\n在ClientDuplexStream上。\u emitStatusIfDone（/home/trs-laptop-20/Downloads/fabcar network/node_modules/fabric client/node_modules/grpc/src/client.js:270:19）\n在ClientDuplexStream上。\ u readsDone（/home/trs-laptop-20/Downloads/fabcar network/node_modules/fabric client/node_modules/grpc/src/client.js:236:8）\n在readCallback上（/home/trs-laptop-20/Downloads/fabcar network/node_modules/fabric client/node_modules/grpc/src/client.js:296:12）”

在某些情况下

错误：[client utils.js]：sendPeersProposal-承诺被拒绝：错误：14不可用：连接失败 新建createStatusError（/home/trs-laptop-20/Downloads/fabcar network/node_modules/fabric client/node_modules/grpc/src/client.js:64:15） at/home/trs-laptop-20/Downloads/fabcar network/node_modules/fabric client/node_modules/grpc/src/client.js:583:15

我不明白为什么会出现这些错误。我必须开发一个能够处理负载的高性能应用程序，任何帮助和指导都将不胜感激

这是我的app.js代码：

'use strict';

//get libraries
const express = require('express');
const bodyParser = require('body-parser');
const request = require('request');
const path = require('path');

//create express web-app
const app = express();
const router = express.Router();
app.use(bodyParser.json());
const invoke = require('./invokeNetwork.js');

//declare port
var port = process.env.PORT || 8000;
if (process.env.VCAP_APPLICATION) {
  port = process.env.PORT;
}

//run app on port
app.listen(port, function() {
  console.log('app running on port: %d', port);
});

app.post('/api/post', async function(req,res){
    var carID = req.body.carID;
    var make = req.body.make;
    var model = req.body.model;
    var color = req.body.color;
    var owner = req.body.owner;

  await invoke.invokeCreate(carID, make, model, color, owner).then((response) => {
    //return error if error in response
    if (response.status == 500) {
      res.status(500).send({ error: response.message });
    } else {
      //else return success
      res.status(200).send({ message: response.message });
    }
  }).catch(err => {
    console.log(err);
  });

});

这是invokeNetwork.js代码

'use strict';

var Fabric_Client = require('fabric-client');
var path = require('path');
var util = require('util');
var os = require('os');
var fs = require('fs');

var isError = false;
var throwError = "";

//make sure we have the profiles we need
var networkConfig = path.join(__dirname, './config/network-profile.json')
var clientConfig = path.join(__dirname, './config/client-profile.json');

module.exports = {

invokeCreate: async function(carID, make, model, color, owner) {

  isError = false;

//try {

  checkProfilesExist(networkConfig, clientConfig); //terminates early if they are not found

// load the base network profile
var fabric_client = Fabric_Client.loadFromConfig(path.join(__dirname, './config/network-profile.json'));

// overlay the client profile over the network profile
fabric_client.loadFromConfig(path.join(__dirname, './config/client-profile.json'));

// setup the fabric network - get the channel that was loaded from the network profile
var channel = fabric_client.getChannel('defaultchannel');
var tx_id = null;

//load the user who is going to unteract with the network
fabric_client.initCredentialStores().then(() => {
  // get the enrolled user from persistence, this user will sign all requests
  return fabric_client.getUserContext('user1', true);
}).then((user_from_store) => {
  if (user_from_store && user_from_store.isEnrolled()) {
    console.log('Successfully loaded user1 from persistence');

  } else {
    throw new Error('Failed to get user1.... run registerUserNetwork.js');
  }

  // get a transaction id object based on the current user assigned to fabric client
  tx_id = fabric_client.newTransactionID();
  console.log("Assigning transaction_id: ", tx_id._transaction_id);

  // createCar chaincode function - requires 5 args, ex: args: ['CAR11', 'Honda', 'Accord', 'Black', 'Dave'],
  // changeCarOwner chaincode function - requires 2 args , ex: args: ['CAR11', 'MGK'],
    var request = {
        chaincodeId: 'fabcar',
        fcn: 'createCar',
        args: [carID, make, model, color, owner],
        txId: tx_id
  };

  // send the transaction proposal to the endorsing peers
  return channel.sendTransactionProposal(request);
}).then((results) => {
  var proposalResponses = results[0];
  var proposal = results[1];
  let isProposalGood = false;
  if (proposalResponses && proposalResponses[0].response &&
    proposalResponses[0].response.status === 200) {
    isProposalGood = true;
    console.log('Transaction proposal was good');
  } else {
    console.error('Transaction proposal was bad');

  }
  if (isProposalGood) {
    console.log(util.format(
      'Successfully sent Proposal and received ProposalResponse: Status - %s, message - "%s"',
      proposalResponses[0].response.status, proposalResponses[0].response.message));

    // build up the request for the orderer to have the transaction committed
    var request = {
      proposalResponses: proposalResponses,
      proposal: proposal
    };

    // set the transaction listener and set a timeout of 30 sec
    // if the transaction did not get committed within the timeout period,
    // report a TIMEOUT status
    var transaction_id_string = tx_id.getTransactionID(); //Get the transaction ID string to be used by the event processing
    var promises = [];

    var sendPromise = channel.sendTransaction(request);
    promises.push(sendPromise); //we want the send transaction first, so that we know where to check status

    // get an eventhub once the fabric client has a user assigned. The user
    // is required bacause the event registration must be signed
    console.error('Getting event hub');
    let event_hub = fabric_client.getEventHub('org1-peer1');

    // using resolve the promise so that result status may be processed
    // under the then clause rather than having the catch clause process
    // the status
    let txPromise = new Promise((resolve, reject) => {
      let handle = setTimeout(() => {
        event_hub.disconnect();
        resolve({ event_status: 'TIMEOUT' }); //we could use reject(new Error('Trnasaction did not complete within 30 seconds'));
      }, 3000);
      event_hub.connect();
      event_hub.registerTxEvent(transaction_id_string, (tx, code) => {
        // this is the callback for transaction event status
        // first some clean up of event listener
        clearTimeout(handle);
        event_hub.unregisterTxEvent(transaction_id_string);
        event_hub.disconnect();

        // now let the application know what happened
        var return_status = { event_status: code, tx_id: transaction_id_string };
        if (code !== 'VALID') {
          console.error('The transaction was invalid, code = ' + code);
          resolve(return_status); // we could use reject(new Error('Problem with the tranaction, event status ::'+code));
        } else {
          console.log('The transaction has been committed on peer ' + event_hub._ep._endpoint.addr);
          resolve(return_status);
        }
      }, (err) => {
        //this is the callback if something goes wrong with the event registration or processing
        reject(new Error('There was a problem with the eventhub ::' + err));
        throwError += err;
      });
    });
    promises.push(txPromise);

    return Promise.all(promises);
  } else {
    console.error('Failed to send Proposal or receive valid response. Response null or status is not 200. exiting...');
    throw new Error('Failed to send Proposal or receive valid response. Response null or status is not 200. exiting...');
  }
}).then((results) => {
  console.log('Send transaction promise and event listener promise have completed');
  // check the results in the order the promises were added to the promise all list
  if (results && results[0] && results[0].status === 'SUCCESS') {
    console.log('Successfully sent transaction to the orderer.');
  } else {
    console.error('Failed to order the transaction. Error code: ' + response.status);
    throw new exception("Transaction");
  }

  if (results && results[1] && results[1].event_status === 'VALID') {
    console.log('Successfully committed the change to the ledger by the peer');
    return true;
  } else {
    console.log('Transaction failed to be committed to the ledger due to ::' + results[1].event_status);
  }
}).catch((err) => {
  console.error('Failed to invoke successfully :: ' + err);
  isError = true;
  throwError += err;
});

console.log(isError);

return {
  message: (isError) ? throwError : 'Success Transaction'
}

function checkProfilesExist(networkConfig, clientConfig) {
  if (!fs.existsSync(networkConfig)) {
    console.log("Error: config file 'network-profile.json' not found.");
    console.log("Make sure 'network-profile.json' is copied into the './config' folder.");
    process.exit()
  }

  //make sure we have the client profile we need

  if (!fs.existsSync(clientConfig)) {
    console.log("Error: config file 'client-profile.json' not found.");
    console.log("Make sure 'client-profile.json' is copied into the './config' folder.");
    process.exit()
  }
}

}

}
//throw new exception("Exceoption thrown");
//return true;
// }
//   catch(err) {
//     //print and return error
//     console.log(err);
//     var error = {};
//     error.error = err.message;
//     return error;
//     }
//   }
// }

---

所以，我们一直在玩弄fabric，并尝试测试一些性能。我遇到了与您处理的所有相同的问题，因此我们将解释我们的问题，希望它们能帮助您

Eventhub关闭

错误：eventhub出现问题：：错误：eventhub已关闭

问题 注意到当我们发送大量交易时会出现这种情况，当我们使用不可靠的互联网连接时也会出现这种情况。以下是：

这些事件是短暂的，因此，如果在发布事件时注册的侦听器崩溃，则侦听器将错过该事件

我认为问题在于eventhub试图连接到我们的API，但连接中存在问题。这会导致eventhub超时（因为它没有收到响应），然后导致eventhub关闭

解决方案 同样，结构文档建议：

• 在块级别监听，因此即使错过了块，也可以获取旧块（更多信息请参见上面的fabric docs链接）
• 构建自己的队列

请查看此pastebin以获取基本块侦听器->

错误：14不可用 问题 我们注意到，当我们开始发送大量事务时，也会出现一个错误：14个不可用，但这是在大量事务充斥网络之后发生的。 我想我们一批20个还行，但当我们快速连续发送50个或更多时，它无法处理

请记住，至少在IBP starter addition上，一个块最多只能有10个事务，因此它需要等待这些事务被挖掘出来，然后才能处理下一组事务。在这个过程中，我相信缓冲区会被填满，然后你不能发送太多

因此，您的两个错误是订购方被淹没或对等方被太多事务淹没

解决方案 将事务批处理到块中，等待确认这些事务后再发送更多事务。这给了您的同行和订购者一些喘息的空间

---

希望这会有所帮助！

正如Priyav Shah非常清楚地解释的那样，一个完整的修复程序需要您修改API来解决这个问题

---

如果您只是在寻找在对等机上重新启动eventhub侦听器的短期解决方案，那么一个简单的修复方法是重新启动对等机，使其重新加入频道并在其上重新安装链码。

感谢您的详细回复。在您的帮助下，我们已经能够确定我们面临的问题，但仍然无法找到解决方案.你能告诉我我们如何在代码中实现这个blocklistener吗？我们如何将事务批处理到块中？有没有这样的例子？你看过我放的pastebin吗？你在blocklistener的实现上有什么特别的困难？对于事务批处理，没有reall恐怕是个例子。我的建议是使用队列。因此，基本上让node.js api将事务细节推送到队列上。让订阅者“提取”这些细节并将其发送到链外，只有在其侦听的事务完成时才提取。