コード例 #1
0
        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);
            }
        }
コード例 #2
0
        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);
        }