public async Task TokenTransferParallelTest()
{
var chain = await _blockchainService.GetChainAsync();
var tokenAmount = _transactionCount / _groupCount;
var(prepareTransactions, keyPairs) =
await _parallelTestHelper.PrepareTokenForParallel(_groupCount, tokenAmount);
await _parallelTestHelper.BroadcastTransactions(prepareTransactions);
var block = _parallelTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight,
prepareTransactions);
block = await _blockExecutingService.ExecuteBlockAsync(block.Header, prepareTransactions);
await _blockchainService.AddBlockAsync(block);
await _blockAttachService.AttachBlockAsync(block);
var systemTransactions = await _parallelTestHelper.GenerateTransferTransactions(1);
var cancellableTransactions =
_parallelTestHelper.GenerateTransactionsWithoutConflict(keyPairs, tokenAmount);
var allTransaction = systemTransactions.Concat(cancellableTransactions).ToList();
await _parallelTestHelper.BroadcastTransactions(allTransaction);
var groupedTransactions = await _grouper.GroupAsync(
new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height },
cancellableTransactions);
groupedTransactions.Parallelizables.Count.ShouldBe(_groupCount);
groupedTransactions.NonParallelizables.Count.ShouldBe(0);
block = _parallelTestHelper.GenerateBlock(block.GetHash(), block.Height, allTransaction);
block = await _blockExecutingService.ExecuteBlockAsync(block.Header, systemTransactions,
cancellableTransactions, CancellationToken.None);
await _blockchainService.AddBlockAsync(block);
await _blockAttachService.AttachBlockAsync(block);
var codeRemarks =
await _codeRemarksManager.GetCodeRemarksAsync(Hash.FromRawBytes(_parallelTestHelper.TokenContractCode));
codeRemarks.ShouldBeNull();
groupedTransactions = await _grouper.GroupAsync(
new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height },
cancellableTransactions);
groupedTransactions.Parallelizables.Count.ShouldBe(_groupCount);
groupedTransactions.NonParallelizables.Count.ShouldBe(0);
block.TransactionIds.Count().ShouldBe(allTransaction.Count);
}
private async Task <TransactionResourceInfo> GetResourcesForOneAsync(IChainContext chainContext,
Transaction transaction, CancellationToken ct)
{
IExecutive executive = null;
var address = transaction.To;
try
{
executive = await _smartContractExecutiveService.GetExecutiveAsync(chainContext, address);
var codeRemarks = await _codeRemarksManager.GetCodeRemarksAsync(executive.ContractHash);
if (codeRemarks != null && codeRemarks.NonParallelizable)
{
return(new TransactionResourceInfo
{
TransactionId = transaction.GetHash(),
ParallelType = ParallelType.NonParallelizable
});
}
var resourceInfo = await executive.GetTransactionResourceInfoAsync(chainContext, transaction);
// Try storing in cache here
return(resourceInfo);
}
catch (SmartContractFindRegistrationException e)
{
return(new TransactionResourceInfo
{
TransactionId = transaction.GetHash(),
ParallelType = ParallelType.InvalidContractAddress
});
}
finally
{
if (executive != null)
{
await _smartContractExecutiveService.PutExecutiveAsync(address, executive);
}
}
}