示例#1
0
        public async Task IterationSetup()
        {
            var transactions = await _osTestHelper.GenerateTransferTransactions(TransactionCount);

            await _txHub.HandleTransactionsReceivedAsync(new TransactionsReceivedEvent
            {
                Transactions = transactions
            });

            var chain = await _blockchainService.GetChainAsync();

            _block = _osTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, transactions);
            await _blockchainService.AddBlockAsync(_block);

            await _chainBlockLinks.SetAsync(
                chain.Id.ToStorageKey() + KernelConstants.StorageKeySeparator + _block.GetHash().ToStorageKey(),
                new ChainBlockLink()
            {
                BlockHash         = _block.GetHash(),
                Height            = _block.Height,
                PreviousBlockHash = _block.Header.PreviousBlockHash,
                IsLinked          = true
            });

            await _blockchainService.SetBestChainAsync(chain, _block.Height, _block.GetHash());
        }
示例#2
0
        public void Setup(BenchmarkContext context)
        {
            _blockchainService     = GetRequiredService <IBlockchainService>();
            _blockExecutingService = GetRequiredService <IBlockExecutingService>();
            _osTestHelper          = GetRequiredService <OSTestHelper>();

            _counter = context.GetCounter("TestCounter");

            AsyncHelper.RunSync(async() =>
            {
                var chain = await _blockchainService.GetChainAsync();

                _block = new Block
                {
                    Header = new BlockHeader
                    {
                        ChainId           = chain.Id,
                        Height            = chain.BestChainHeight + 1,
                        PreviousBlockHash = chain.BestChainHash,
                        Time = Timestamp.FromDateTime(DateTime.UtcNow)
                    },
                    Body = new BlockBody()
                };

                _transactions = await _osTestHelper.GenerateTransferTransactions(1000);
            });
        }
        public async Task AttachBlockWithTransactions_Test()
        {
            var chain = await _blockchainService.GetChainAsync();

            var transactions = await _osTestHelper.GenerateTransferTransactions(2);

            var block                 = _osTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, transactions);
            var executedBlock         = (await _blockExecutingService.ExecuteBlockAsync(block.Header, transactions)).Block;
            var blockWithTransactions = new BlockWithTransactions
            {
                Header = executedBlock.Header, Transactions = { transactions }
            };

            var attachFinished = false;

            await _blockSyncAttachService.AttachBlockWithTransactionsAsync(blockWithTransactions, "pubkey",
                                                                           () =>
            {
                attachFinished = true;
                return(Task.CompletedTask);
            });

            chain = await _blockchainService.GetChainAsync();

            chain.BestChainHash.ShouldBe(blockWithTransactions.GetHash());
            chain.BestChainHeight.ShouldBe(blockWithTransactions.Height);
            attachFinished.ShouldBeTrue();

            var txs = await _blockchainService.GetTransactionsAsync(transactions.Select(t => t.GetHash()));

            txs.Count.ShouldBe(2);
        }
示例#4
0
        public async Task IterationSetup()
        {
            var chain = await _blockchainService.GetChainAsync();

            var tokenAmount = TransactionCount / GroupCount;

            (_prepareTransactions, _keyPairs) = await _osTestHelper.PrepareTokenForParallel(GroupCount, tokenAmount);

            _block = _osTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, _prepareTransactions);
            await _blockExecutingService.ExecuteBlockAsync(_block.Header, _prepareTransactions);

            await _osTestHelper.BroadcastTransactions(_prepareTransactions);

            _block = (await _minerService.MineAsync(chain.BestChainHash, chain.BestChainHeight,
                                                    TimestampHelper.GetUtcNow(), TimestampHelper.DurationFromSeconds(4))).Block;

            _systemTransactions = await _osTestHelper.GenerateTransferTransactions(1);

            _cancellableTransactions = await _osTestHelper.GenerateTransactionsWithoutConflictAsync(_keyPairs, tokenAmount);

            chain = await _blockchainService.GetChainAsync();

            _block = _osTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight,
                                                 _systemTransactions.Concat(_cancellableTransactions));
        }
示例#5
0
        public void Setup(BenchmarkContext context)
        {
            _blockchainService          = GetRequiredService <IBlockchainService>();
            _blockchainExecutingService = GetRequiredService <IBlockchainExecutingService>();
            _chainManager = GetRequiredService <IChainManager>();
            _osTestHelper = GetRequiredService <OSTestHelper>();

            _counter = context.GetCounter("TestCounter");

            AsyncHelper.RunSync(async() =>
            {
                var chain = await _blockchainService.GetChainAsync();

                var transactions = await _osTestHelper.GenerateTransferTransactions(1000);

                _block = _osTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, transactions);

                await _blockchainService.AddTransactionsAsync(transactions);
                await _blockchainService.AddBlockAsync(_block);

                chain = await _blockchainService.GetChainAsync();

                await _blockchainService.AttachBlockToChainAsync(chain, _block);
            });
        }
        public async Task GlobalSetup()
        {
            _chains = GetRequiredService <IBlockchainStore <Chain> >();
            _chainStateInfoCollection = GetRequiredService <IStateStore <ChainStateInfo> >();
            _blockchainStateService   = GetRequiredService <IBlockchainStateService>();
            _blockStateSetManger      = GetRequiredService <IBlockStateSetManger>();
            _blockchainService        = GetRequiredService <IBlockchainService>();
            _osTestHelper             = GetRequiredService <OSTestHelper>();
            _chainManager             = GetRequiredService <IChainManager>();
            _blockManager             = GetRequiredService <IBlockManager>();
            _transactionManager       = GetRequiredService <ITransactionManager>();
            _transactionPoolService   = GetRequiredService <ITransactionPoolService>();


            _blockStateSets = new List <BlockStateSet>();
            _blocks         = new List <Block>();

            _chain = await _blockchainService.GetChainAsync();

            var blockHash = _chain.BestChainHash;

            while (true)
            {
                var blockState = await _blockStateSetManger.GetBlockStateSetAsync(blockHash);

                _blockStateSets.Add(blockState);

                var blockHeader = await _blockchainService.GetBlockHeaderByHashAsync(blockHash);

                blockHash = blockHeader.PreviousBlockHash;
                if (blockHash == _chain.LastIrreversibleBlockHash)
                {
                    break;
                }
            }

            await _blockchainStateService.MergeBlockStateAsync(_chain.BestChainHeight, _chain.BestChainHash);

            for (var i = 0; i < BlockCount; i++)
            {
                var transactions = await _osTestHelper.GenerateTransferTransactions(TransactionCount);

                await _osTestHelper.BroadcastTransactions(transactions);

                var block = await _osTestHelper.MinedOneBlock();

                _blocks.Add(block);

                var blockState = await _blockStateSetManger.GetBlockStateSetAsync(block.GetHash());

                _blockStateSets.Add(blockState);
            }

            var chain = await _blockchainService.GetChainAsync();

            await _chainManager.SetIrreversibleBlockAsync(chain, chain.BestChainHash);

            _chainStateInfo = await _chainStateInfoCollection.GetAsync(chain.Id.ToStorageKey());
        }
示例#7
0
        public async Task IterationSetup()
        {
            var chain = await _blockchainService.GetChainAsync();

            _transactions = await _osTestHelper.GenerateTransferTransactions(TransactionCount);

            _block = _osTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, _transactions);
        }
示例#8
0
        public async Task BroadcastBlockWithTxs_ShouldAddToBlockCache()
        {
            var peer     = _peerPool.GetPeers(true).First();
            var pubkey   = peer.Info.Pubkey;
            var metadata = new Metadata {
                { GrpcConstants.PubkeyMetadataKey, pubkey }
            };

            var block = _osTestHelper.GenerateBlockWithTransactions(Hash.FromString("block1"), 1,
                                                                    (await _osTestHelper.GenerateTransferTransactions(1)).ToList());

            var requestStream = new TestAsyncStreamReader <BlockWithTransactions>(new List <BlockWithTransactions> {
                block
            });
            await _serverService.BlockBroadcastStream(requestStream, BuildServerCallContext(metadata));

            peer.TryAddKnownBlock(block.GetHash()).ShouldBeFalse();
        }
示例#9
0
        public async Task IterationSetup()
        {
            var transactions = await _osTestHelper.GenerateTransferTransactions(TransactionCount);

            await _blockchainService.AddTransactionsAsync(transactions);

            _block = _osTestHelper.GenerateBlock(_chain.BestChainHash, _chain.BestChainHeight, transactions);

            await _blockchainService.AddBlockAsync(_block);
        }
        public void Setup(BenchmarkContext context)
        {
            _osTestHelper = GetRequiredService <OSTestHelper>();
            _txHub        = GetRequiredService <ITxHub>();

            _counter = context.GetCounter("TestCounter");

            AsyncHelper.RunSync(async() =>
            {
                _transactions = await _osTestHelper.GenerateTransferTransactions(1000);
            });
        }
示例#11
0
        public async Task ValidateBlockBeforeAttach_Success()
        {
            var chain = await _blockchainService.GetChainAsync();

            var transactions = await _osTestHelper.GenerateTransferTransactions(3);

            var block = _osTestHelper.GenerateBlockWithTransactions(chain.BestChainHash, chain.BestChainHeight,
                                                                    transactions);

            var result = await _blockSyncValidationService.ValidateBlockBeforeAttachAsync(block);

            result.ShouldBeTrue();
        }
示例#12
0
        public void Setup(BenchmarkContext context)
        {
            _blockchainService     = GetRequiredService <IBlockchainService>();
            _blockExecutingService = GetRequiredService <IBlockExecutingService>();
            _osTestHelper          = GetRequiredService <OSTestHelper>();

            _counter = context.GetCounter("TestCounter");

            AsyncHelper.RunSync(async() =>
            {
                var chain     = await _blockchainService.GetChainAsync();
                _transactions = await _osTestHelper.GenerateTransferTransactions(1000);
                _block        = _osTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, _transactions);
            });
        }
示例#13
0
        public void Setup(BenchmarkContext context)
        {
            _blockchainService  = GetRequiredService <IBlockchainService>();
            _osTestHelper       = GetRequiredService <OSTestHelper>();
            _minerService       = GetRequiredService <IMinerService>();
            _txHub              = GetRequiredService <ITxHub>();
            _blockAttachService = GetRequiredService <IBlockAttachService>();

            _counter = context.GetCounter("TestCounter");

            AsyncHelper.RunSync(async() =>
            {
                var transactions = await _osTestHelper.GenerateTransferTransactions(1000);

                await _osTestHelper.BroadcastTransactions(transactions);
            });
        }
        public async Task BlockBroadcastStream_UnknownPeer_Test()
        {
            var metadata = new Metadata {
                { GrpcConstants.PubkeyMetadataKey, "UnknownPeerPubkey" }
            };

            var block = _osTestHelper.GenerateBlockWithTransactions(HashHelper.ComputeFrom("block1"), 1,
                                                                    (await _osTestHelper.GenerateTransferTransactions(1)).ToList());

            var requestStream = new TestAsyncStreamReader <BlockWithTransactions>(new List <BlockWithTransactions> {
                block
            });
            await _serverService.BlockBroadcastStream(requestStream, BuildServerCallContext(metadata))
            .ShouldThrowAsync <RpcException>();
        }
示例#15
0
        public async Task SendTransactionAsync_Success()
        {
            TransactionsReceivedEvent received = null;

            _eventBus.Subscribe <TransactionsReceivedEvent>(t =>
            {
                received = t;
                return(Task.CompletedTask);
            });
            var transactions = await _osTestHelper.GenerateTransferTransactions(1);

            await _grpcPeer.SendTransactionAsync(transactions.First());

            received.ShouldNotBeNull();
            received.Transactions.Count().ShouldBe(1);
            received.Transactions.First().From.ShouldBe(transactions.First().From);
        }
示例#16
0
        public async Task IterationSetup()
        {
            var chain = await _blockchainService.GetChainAsync();

            _block = new Block
            {
                Header = new BlockHeader
                {
                    ChainId           = chain.Id,
                    Height            = chain.BestChainHeight + 1,
                    PreviousBlockHash = chain.BestChainHash,
                    Time = Timestamp.FromDateTime(DateTime.UtcNow)
                },
                Body = new BlockBody()
            };

            _transactions = await _osTestHelper.GenerateTransferTransactions(TransactionCount);
        }
        public void Setup(BenchmarkContext context)
        {
            _blockchainStateService = GetRequiredService <IBlockchainStateService>();
            _blockchainService      = GetRequiredService <IBlockchainService>();
            _osTestHelper           = GetRequiredService <OSTestHelper>();
            _chainManager           = GetRequiredService <IChainManager>();

            _counter = context.GetCounter("TestCounter");

            AsyncHelper.RunSync(async() =>
            {
                var transactions = await _osTestHelper.GenerateTransferTransactions(1000);
                await _osTestHelper.BroadcastTransactions(transactions);
                await _osTestHelper.MinedOneBlock();

                var chain = await _blockchainService.GetChainAsync();
                await _chainManager.SetIrreversibleBlockAsync(chain, chain.BestChainHash);
            });
        }
        public void Setup(BenchmarkContext context)
        {
            _osTestHelper      = GetRequiredService <OSTestHelper>();
            _txHub             = GetRequiredService <ITxHub>();
            _blockchainService = GetRequiredService <IBlockchainService>();

            _counter = context.GetCounter("TestCounter");

            AsyncHelper.RunSync(async() =>
            {
                var transactions = await _osTestHelper.GenerateTransferTransactions(1000);

                await _txHub.HandleTransactionsReceivedAsync(new TransactionsReceivedEvent
                {
                    Transactions = transactions
                });

                await _osTestHelper.MinedOneBlock();
            });
        }
示例#19
0
        public async Task BroadcastBlockWithTxs_FromStream_Test()
        {
            var received = new List <BlockReceivedEvent>();

            _eventBus.Subscribe <BlockReceivedEvent>(a =>
            {
                received.Add(a);
                return(Task.CompletedTask);
            });

            var blocks = new List <BlockWithTransactions>();

            blocks.Add(_osTestHelper.GenerateBlockWithTransactions(Hash.FromString("block1"), 1, (await _osTestHelper.GenerateTransferTransactions(1)).ToList()));
            blocks.Add(_osTestHelper.GenerateBlockWithTransactions(Hash.FromString("block2"), 2, (await _osTestHelper.GenerateTransferTransactions(2)).ToList()));
            blocks.Add(_osTestHelper.GenerateBlockWithTransactions(Hash.FromString("block3"), 3, (await _osTestHelper.GenerateTransferTransactions(3)).ToList()));

            var context       = BuildServerCallContext();
            var requestStream = new TestAsyncStreamReader <BlockWithTransactions>(blocks.ToArray());

            var result = await _service.BlockBroadcastStream(requestStream, context);

            result.ShouldBe(new VoidReply());
            received.Count.ShouldBe(3);
        }
示例#20
0
文件: MinerTests.cs 项目: zhxymh/AElf
        public async Task IterationSetup()
        {
            _transactions = await _osTestHelper.GenerateTransferTransactions(TransactionCount);

            await _osTestHelper.BroadcastTransactions(_transactions);
        }