private void TestPeerServiceEventingReplay(HFClient client, Channel replayTestChannel, long start, long stop, bool useFilteredBlocks)
{
if (testConfig.IsRunningAgainstFabric10())
{
return; // not supported for v1.0
}
Assert.IsFalse(replayTestChannel.IsInitialized); //not yet initialized
Assert.IsFalse(replayTestChannel.IsShutdown); // not yet shutdown.
//Remove all peers just have one ledger peer and one eventing peer.
List <Peer> savedPeers = new List <Peer>(replayTestChannel.Peers);
foreach (Peer peer in savedPeers)
{
replayTestChannel.RemovePeer(peer);
}
Assert.IsTrue(savedPeers.Count > 1); //need at least two
Peer eventingPeer = savedPeers[0];
eventingPeer = client.NewPeer(eventingPeer.Name, eventingPeer.Url, eventingPeer.Properties);
Peer ledgerPeer = savedPeers[1];
ledgerPeer = client.NewPeer(ledgerPeer.Name, ledgerPeer.Url, ledgerPeer.Properties);
savedPeers.RemoveAt(0);
savedPeers.RemoveAt(0);
Assert.IsTrue(replayTestChannel.Peers.Count == 0); // no more peers.
Assert.IsTrue(replayTestChannel.GetPeers(new[] { PeerRole.CHAINCODE_QUERY, PeerRole.ENDORSING_PEER }).Count == 0); // just checking :)
Assert.IsTrue(replayTestChannel.GetPeers(new[] { PeerRole.LEDGER_QUERY }).Count == 0); // just checking
Assert.IsNotNull(client.GetChannel(replayTestChannel.Name)); // should be known by client.
PeerOptions eventingPeerOptions = PeerOptions.CreatePeerOptions().SetPeerRoles(new List <PeerRole> {
PeerRole.EVENT_SOURCE
});
if (useFilteredBlocks)
{
eventingPeerOptions.RegisterEventsForFilteredBlocks();
}
if (-1L == stop)
{
//the height of the blockchain
replayTestChannel.AddPeer(eventingPeer, eventingPeerOptions.StartEvents(start)); // Eventing peer start getting blocks from block 0
}
else
{
replayTestChannel.AddPeer(eventingPeer, eventingPeerOptions.StartEvents(start).StopEvents(stop)); // Eventing peer start getting blocks from block 0
}
//add a ledger peer
replayTestChannel.AddPeer(ledgerPeer, PeerOptions.CreatePeerOptions().SetPeerRoles(new List <PeerRole> {
PeerRole.LEDGER_QUERY
}));
TaskCompletionSource <long> done = new TaskCompletionSource <long>(); // future to set when done.
// some variable used by the block listener being set up.
long bcount = 0;
long stopValue = stop == -1L ? long.MaxValue : stop;
Channel finalChannel = replayTestChannel;
ConcurrentDictionary <long, BlockEvent> blockEvents = new ConcurrentDictionary <long, BlockEvent>();
string blockListenerHandle = replayTestChannel.RegisterBlockListener((blockEvent) =>
{
try
{
long blockNumber = blockEvent.BlockNumber;
if (blockEvents.ContainsKey(blockNumber))
{
Assert.Fail($"Block number {blockNumber} seen twice");
}
blockEvents[blockNumber] = blockEvent;
Assert.IsTrue(useFilteredBlocks ? blockEvent.IsFiltered : !blockEvent.IsFiltered, $"Wrong type of block seen block number {blockNumber}. expected filtered block {useFilteredBlocks} but got {blockEvent.IsFiltered}");
long count = Interlocked.Increment(ref bcount) - 1;
//out("Block count: %d, block number: %d received from peer: %s", count, blockNumber, blockEvent.getPeer().getName());
if (count == 0 && stop == -1L)
{
BlockchainInfo blockchainInfo = finalChannel.QueryBlockchainInfo();
long lh = blockchainInfo.Height;
stopValue = lh - 1L; // blocks 0L 9L are on chain height 10 .. stop on 9
// out("height: %d", lh);
if (Interlocked.Read(ref bcount) + start > stopValue)
{
// test with latest count.
done.SetResult(Interlocked.Read(ref bcount));
}
}
else
{
if (Interlocked.Read(ref bcount) + start > stopValue)
{
done.SetResult(count);
}
}
}
catch (System.Exception e)
{
done.SetException(e);
}
});
try
{
replayTestChannel.Initialize(); // start it all up.
done.Task.Wait(30 * 1000);
Thread.Sleep(1000); // sleep a little to see if more blocks trickle in .. they should not
replayTestChannel.UnregisterBlockListener(blockListenerHandle);
long expectNumber = stopValue - start + 1L; // Start 2 and stop is 3 expect 2
Assert.AreEqual(expectNumber, blockEvents.Count, $"Didn't get number we expected {expectNumber} but got {blockEvents.Count} block events. Start: {start}, end: {stop}, height: {stopValue}");
for (long i = stopValue; i >= start; i--)
{
//make sure all are there.
BlockEvent blockEvent = blockEvents[i];
Assert.IsNotNull(blockEvent, $"Missing block event for block number {i}. Start= {start}", blockEvent);
}
//light weight test just see if we get reasonable values for traversing the block. Test just whats common between
// Block and FilteredBlock.
int transactionEventCounts = 0;
int chaincodeEventsCounts = 0;
for (long i = stopValue; i >= start; i--)
{
BlockEvent blockEvent = blockEvents[i];
// out("blockwalker %b, start: %d, stop: %d, i: %d, block %d", useFilteredBlocks, start, stopValue.longValue(), i, blockEvent.getBlockNumber());
Assert.AreEqual(useFilteredBlocks, blockEvent.IsFiltered); // check again
if (useFilteredBlocks)
{
Assert.IsNull(blockEvent.Block); // should not have raw block event.
Assert.IsNotNull(blockEvent.FilteredBlock); // should have raw filtered block.
}
else
{
Assert.IsNotNull(blockEvent.Block); // should not have raw block event.
Assert.IsNull(blockEvent.FilteredBlock); // should have raw filtered block.
}
Assert.AreEqual(replayTestChannel.Name, blockEvent.ChannelId);
foreach (EnvelopeInfo envelopeInfo in blockEvent.EnvelopeInfos)
{
if (envelopeInfo.EnvelopeType == EnvelopeType.TRANSACTION_ENVELOPE)
{
TransactionEnvelopeInfo transactionEnvelopeInfo = (TransactionEnvelopeInfo)envelopeInfo;
Assert.IsTrue(envelopeInfo.IsValid); // only have valid blocks.
Assert.AreEqual(envelopeInfo.ValidationCode, 0);
++transactionEventCounts;
foreach (TransactionActionInfo ta in transactionEnvelopeInfo.TransactionActionInfos)
{
// out("\nTA:", ta + "\n\n");
ChaincodeEventDeserializer evnt = ta.Event;
if (evnt != null)
{
Assert.IsNotNull(evnt.ChaincodeId);
Assert.IsNotNull(evnt.EventName);
chaincodeEventsCounts++;
}
}
}
else
{
Assert.AreEqual(blockEvent.BlockNumber, 0, "Only non transaction block should be block 0.");
}
}
}
Assert.IsTrue(transactionEventCounts > 0);
if (expectNumber > 4)
{
// this should be enough blocks with CC events.
Assert.IsTrue(chaincodeEventsCounts > 0);
}
replayTestChannel.Shutdown(true); //all done.
}
catch (System.Exception e)
{
Assert.Fail(e.Message);
}
}
private Channel ReconstructChannel(string name, HFClient client, SampleOrg sampleOrg)
{
Util.COut("Reconstructing {0} channel", name);
client.UserContext = sampleOrg.GetUser(TESTUSER_1_NAME);
Channel newChannel;
if (BAR_CHANNEL_NAME.Equals(name))
{
// bar channel was stored in samplestore in End2endIT testcase.
/**
* sampleStore.getChannel uses {@link HFClient#deSerializeChannel(byte[])}
*/
newChannel = sampleStore.GetChannel(client, name);
if (!IS_FABRIC_V10)
{
// Make sure there is one of each type peer at the very least. see End2end for how peers were constructed.
Assert.IsFalse(newChannel.GetPeers(new[] { PeerRole.EVENT_SOURCE }).Count == 0);
Assert.IsFalse(newChannel.GetPeers(new[] { PeerRole.EVENT_SOURCE }).Count == 0);
}
Assert.AreEqual(testConfig.IsFabricVersionAtOrAfter("1.3") ? 0 : 2, newChannel.EventHubs.Count);
Util.COut("Retrieved channel {0} from sample store.", name);
}
else
{
newChannel = client.NewChannel(name);
foreach (string ordererName in sampleOrg.GetOrdererNames())
{
newChannel.AddOrderer(client.NewOrderer(ordererName, sampleOrg.GetOrdererLocation(ordererName), testConfig.GetOrdererProperties(ordererName)));
}
bool everyOther = false;
foreach (string peerName in sampleOrg.GetPeerNames())
{
string peerLocation = sampleOrg.GetPeerLocation(peerName);
Properties peerProperties = testConfig.GetPeerProperties(peerName);
Peer peer = client.NewPeer(peerName, peerLocation, peerProperties);
PeerOptions peerEventingOptions = // we have two peers on one use block on other use filtered
everyOther ? PeerOptions.CreatePeerOptions().RegisterEventsForBlocks().SetPeerRoles(PeerRole.ENDORSING_PEER, PeerRole.LEDGER_QUERY, PeerRole.CHAINCODE_QUERY, PeerRole.EVENT_SOURCE) : PeerOptions.CreatePeerOptions().RegisterEventsForFilteredBlocks().SetPeerRoles(PeerRole.ENDORSING_PEER, PeerRole.LEDGER_QUERY, PeerRole.CHAINCODE_QUERY, PeerRole.EVENT_SOURCE);
newChannel.AddPeer(peer, IS_FABRIC_V10 ? PeerOptions.CreatePeerOptions().SetPeerRoles(PeerRole.ENDORSING_PEER, PeerRole.LEDGER_QUERY, PeerRole.CHAINCODE_QUERY) : peerEventingOptions);
everyOther = !everyOther;
}
//For testing mix it up. For v1.1 use just peer eventing service for foo channel.
if (IS_FABRIC_V10)
{
//Should have no peers with event sources.
Assert.IsTrue(newChannel.GetPeers(new[] { PeerRole.EVENT_SOURCE }).Count == 0);
//Should have two peers with all roles but event source.
Assert.AreEqual(2, newChannel.Peers.Count);
foreach (string eventHubName in sampleOrg.GetEventHubNames())
{
EventHub eventHub = client.NewEventHub(eventHubName, sampleOrg.GetEventHubLocation(eventHubName), testConfig.GetEventHubProperties(eventHubName));
newChannel.AddEventHub(eventHub);
}
}
else
{
//Peers should have all roles. Do some sanity checks that they do.
//Should have two peers with event sources.
Assert.AreEqual(2, newChannel.GetPeers(new[] { PeerRole.EVENT_SOURCE }).Count);
//Check some other roles too..
Assert.AreEqual(2, newChannel.GetPeers(new[] { PeerRole.CHAINCODE_QUERY, PeerRole.LEDGER_QUERY }).Count);
Assert.AreEqual(2, newChannel.GetPeers(PeerRoleExtensions.All()).Count); //really same as newChannel.getPeers()
}
Assert.AreEqual(IS_FABRIC_V10 ? sampleOrg.GetEventHubNames().Count : 0, newChannel.EventHubs.Count);
}
//Just some sanity check tests
Assert.IsTrue(newChannel == client.GetChannel(name));
Assert.IsTrue(client == newChannel.client);
Assert.AreEqual(name, newChannel.Name);
Assert.AreEqual(2, newChannel.Peers.Count);
Assert.AreEqual(1, newChannel.Orderers.Count);
Assert.IsFalse(newChannel.IsShutdown);
Assert.IsFalse(newChannel.IsInitialized);
string serializedChannelBytes = newChannel.Serialize();
//Just checks if channel can be serialized and deserialized .. otherwise this is just a waste :)
// Get channel back.
newChannel.Shutdown(true);
newChannel = client.DeSerializeChannel(serializedChannelBytes);
Assert.AreEqual(2, newChannel.Peers.Count);
Assert.AreEqual(1, newChannel.Orderers.Count);
Assert.IsNotNull(client.GetChannel(name));
Assert.AreEqual(newChannel, client.GetChannel(name));
Assert.IsFalse(newChannel.IsInitialized);
Assert.IsFalse(newChannel.IsShutdown);
Assert.AreEqual(TESTUSER_1_NAME, client.UserContext.Name);
newChannel.Initialize();
Assert.IsTrue(newChannel.IsInitialized);
Assert.IsFalse(newChannel.IsShutdown);
//Begin tests with de-serialized channel.
//Query the actual peer for which channels it belongs to and check it belongs to this channel
foreach (Peer peer in newChannel.Peers)
{
HashSet <string> channels = client.QueryChannels(peer);
if (!channels.Contains(name))
{
Assert.Fail($"Peer {peer.Name} does not appear to belong to channel {name}");
}
}
//Just see if we can get channelConfiguration. Not required for the rest of scenario but should work.
byte[] channelConfigurationBytes = newChannel.GetChannelConfigurationBytes();
Config channelConfig = Config.Parser.ParseFrom(channelConfigurationBytes);
Assert.IsNotNull(channelConfig);
ConfigGroup channelGroup = channelConfig.ChannelGroup;
Assert.IsNotNull(channelGroup);
Dictionary <string, ConfigGroup> groupsMap = channelGroup.Groups.ToDictionary(a => a.Key, a => a.Value);
Assert.IsNotNull(groupsMap.GetOrNull("Orderer"));
Assert.IsNotNull(groupsMap.GetOrNull("Application"));
//Before return lets see if we have the chaincode on the peers that we expect from End2endIT
//And if they were instantiated too. this requires peer admin user
client.UserContext = sampleOrg.PeerAdmin;
foreach (Peer peer in newChannel.Peers)
{
if (!CheckInstalledChaincode(client, peer, CHAIN_CODE_NAME, CHAIN_CODE_PATH, CHAIN_CODE_VERSION))
{
Assert.Fail($"Peer {peer.Name} is missing chaincode name: {CHAIN_CODE_NAME}, path:{CHAIN_CODE_PATH}, version: {CHAIN_CODE_VERSION}");
}
if (!CheckInstantiatedChaincode(newChannel, peer, CHAIN_CODE_NAME, CHAIN_CODE_PATH, CHAIN_CODE_VERSION))
{
Assert.Fail($"Peer {peer.Name} is missing instantiated chaincode name: {CHAIN_CODE_NAME}, path:{CHAIN_CODE_PATH}, version: {CHAIN_CODE_VERSION}");
}
}
client.UserContext = sampleOrg.GetUser(TESTUSER_1_NAME);
Assert.IsTrue(newChannel.IsInitialized);
Assert.IsFalse(newChannel.IsShutdown);
Util.COut("Finished reconstructing channel {0}.", name);
return(newChannel);
}