TypeScript Channel.newChannelEventHub方法代码示例

			return new Promise((resolve, reject) => {
				// get a new ChannelEventHub when registering a listener
				// with startBlock or endBlock when doing a replay
				// The ChannelEventHub must not have been connected or have other
				// listeners.
				let channel_event_hub: ChannelEventHub = channel.newChannelEventHub('peer0.org1.example.com');

				let handle = setTimeout(() => {
					t.fail('Timeout - Failed to receive replay the event for event1');
					channel_event_hub.unregisterTxEvent(query_tx_id);
					channel_event_hub.disconnect(); //shutdown down since we are done
				}, 10000);

				channel_event_hub.registerTxEvent(query_tx_id, (txnid, code, block_num) => {
					clearTimeout(handle);
					t.pass('Event has been replayed with transaction code:' + code + ' for transaction id:' + txnid + ' for block_num:' + block_num);
					resolve('Got the replayed transaction');
				}, (error) => {
					clearTimeout(handle);
					t.fail('Failed to receive event replay for Event for transaction id ::' + query_tx_id);
					throw (error);
				},
					// a real application would have remembered the last block number
					// received and used that value to start the replay
					// Setting the disconnect to true as we do not want to use this
					// ChannelEventHub after the event we are looking for comes in
					{ startBlock: 0, disconnect: true }
				);
				t.pass('Successfully registered transaction replay for ' + query_tx_id);

				channel_event_hub.connect(); //connect to receive filtered blocks
				t.pass('Successfully called connect on the transaction replay event hub for filtered blocks');
			});

		}).then((results: ProposalResponseObject) => {
			let proposalResponses: ProposalResponse[] = results[0];
			let proposal: Proposal = results[1];
			let all_good = true;
			// Will check to be sure that we see two responses as there are two peers defined on this
			// channel that are endorsing peers
			let endorsed_responses = 0;
			for (let i in proposalResponses) {
				let one_good = false;
				endorsed_responses++;
				let proposal_response: ProposalResponse = proposalResponses[i];
				if (proposal_response.response && proposal_response.response.status === 200) {
					t.pass('transaction proposal has response status of good');
					one_good = true;
				} else {
					t.fail('transaction proposal was bad');
					if (proposal_response.response && proposal_response.response.status) {
						t.comment(' response status:' + proposal_response.response.status +
							' message:' + proposal_response.response.message);
					} else {
						t.fail('transaction response was unknown');
						logger.error('transaction response was unknown %s', proposal_response);
					}
				}
				all_good = all_good && one_good;
			}
			t.equals(endorsed_responses, 2, 'Checking that there are the correct number of endorsed responses');
			if (!all_good) {
				t.fail('Failed to send invoke Proposal or receive valid response. Response null or status is not 200. exiting...');
				throw new Error('Failed to send invoke Proposal or receive valid response. Response null or status is not 200. exiting...');
			}
			let request: TransactionRequest = {
				proposalResponses: proposalResponses,
				proposal: proposal,
				admin: true
			};

			let promises = [];

			// be sure to get an channel event hub the current user is authorized to use
			let eventhub = channel.newChannelEventHub('peer0.org1.example.com');

			let txPromise = new Promise((resolve, reject) => {
				let handle = setTimeout(() => {
					eventhub.unregisterTxEvent(query_tx_id);
					eventhub.disconnect();
					t.fail('REQUEST_TIMEOUT --- eventhub did not report back');
					reject(new Error('REQUEST_TIMEOUT:' + eventhub.getPeerAddr()));
				}, 30000);

				eventhub.registerTxEvent(query_tx_id, (tx, code, block_num) => {
					clearTimeout(handle);
					if (code !== 'VALID') {
						t.fail('transaction was invalid, code = ' + code);
						reject(new Error('INVALID:' + code));
					} else {
						t.pass('transaction has been committed on peer ' + eventhub.getPeerAddr());
						resolve('COMMITTED');
					}
				}, (error) => {
					clearTimeout(handle);
					t.fail('transaction event failed:' + error);
					reject(error);
				},
					{ disconnect: true } //since this is a test and we will not be using later
				);
			});
			// connect(true) to receive full blocks (user must have read rights to the channel)
			// should connect after registrations so that there is an error callback
			// to receive errors if there is a problem on the connect.
			eventhub.connect(true);

			promises.push(txPromise);
			promises.push(channel.sendTransaction(request));

			return Promise.all(promises);
		}).then((results) => {