public void ChangeHeight_Test()
{
_blockchainExecutedDataCacheProvider.SetChangeHeight("key1", long.MaxValue);
_blockchainExecutedDataCacheProvider.TryGetChangeHeight("key1", out var value);
value.ShouldBe(long.MaxValue);
_blockchainExecutedDataCacheProvider.CleanChangeHeight(long.MaxValue);
_blockchainExecutedDataCacheProvider.TryGetChangeHeight("key1", out _).ShouldBeFalse();
}
public async Task NonparallelContractCodeSetAndGet_Test()
{
var chain = await _blockchainService.GetChainAsync();
var blockExecutedDataKey = $"BlockExecutedData/NonparallelContractCode/{SampleAddress.AddressList[0]}";
var blockStateSet = await _blockStateSetManger.GetBlockStateSetAsync(chain.BestChainHash);
blockStateSet.BlockExecutedData.ShouldNotContainKey(blockExecutedDataKey);
var nonparallelContractCode = new NonparallelContractCode
{
CodeHash = HashHelper.ComputeFrom(blockExecutedDataKey)
};
var dictionary = new Dictionary <Address, NonparallelContractCode>
{
{ SampleAddress.AddressList[0], nonparallelContractCode }
};
await _nonparallelContractCodeProvider.SetNonparallelContractCodeAsync(new BlockIndex
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
}, dictionary);
blockStateSet = await _blockStateSetManger.GetBlockStateSetAsync(chain.BestChainHash);
blockStateSet.BlockExecutedData.ShouldContainKey(blockExecutedDataKey);
_blockchainExecutedDataCacheProvider.TryGetChangeHeight(blockExecutedDataKey, out _).ShouldBeTrue();
var nonparallelContractCodeFromState = await _nonparallelContractCodeProvider.GetNonparallelContractCodeAsync(
new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
}, SampleAddress.AddressList[0]);
nonparallelContractCodeFromState.ShouldBe(nonparallelContractCode);
await _cleanBlockExecutedDataChangeHeightEventHandler.HandleEventAsync(
new CleanBlockExecutedDataChangeHeightEventData
{
IrreversibleBlockHeight = chain.BestChainHeight
});
_blockchainExecutedDataCacheProvider.TryGetChangeHeight(blockExecutedDataKey, out _).ShouldBeFalse();
}
private void CheckBlockExecutedDataCache(BlockIndex blockIndex, Chain chain,
TransactionResult transactionResult, Dictionary <string, Transaction> transactionDic, bool existChangeHeight,
bool existExecutedData)
{
{
_chainBlockchainExecutedDataCacheProvider
.TryGetChangeHeight(GetBlockExecutedDataKey <Chain>(), out var chainChangeHeight)
.ShouldBe(existChangeHeight);
if (existChangeHeight)
{
chainChangeHeight.ShouldBe(blockIndex.BlockHeight);
}
_chainBlockchainExecutedDataCacheProvider
.TryGetBlockExecutedData(GetBlockExecutedDataKey <Chain>(), out var chainExecutedData)
.ShouldBe(existExecutedData);
if (existExecutedData)
{
chainExecutedData.ShouldBe(chain);
}
}
{
_transactionResultBlockchainExecutedDataCacheProvider
.TryGetChangeHeight(GetBlockExecutedDataKey <TransactionResult>(transactionResult.TransactionId),
out var transactionResultChangeHeight).ShouldBe(existChangeHeight);
if (existChangeHeight)
{
transactionResultChangeHeight.ShouldBe(blockIndex.BlockHeight);
}
_transactionResultBlockchainExecutedDataCacheProvider
.TryGetBlockExecutedData(
GetBlockExecutedDataKey <TransactionResult>(transactionResult.TransactionId),
out var transactionResultExecutedData).ShouldBe(existExecutedData);
if (existExecutedData)
{
transactionResultExecutedData.ShouldBe(transactionResult);
}
}
foreach (var transaction in transactionDic)
{
_transactionBlockchainExecutedDataCacheProvider
.TryGetChangeHeight(transaction.Key, out var transactionChangeHeight)
.ShouldBe(existChangeHeight);
if (existChangeHeight)
{
transactionChangeHeight.ShouldBe(blockIndex.BlockHeight);
}
_transactionBlockchainExecutedDataCacheProvider
.TryGetBlockExecutedData(transaction.Key, out var transactionExecutedData)
.ShouldBe(existExecutedData);
if (existExecutedData)
{
transactionExecutedData.ShouldBe(transaction.Value);
}
}
}
public T GetBlockExecutedData(IBlockIndex chainContext, string key)
{
if (!_blockchainExecutedDataCacheProvider.TryGetChangeHeight(key, out _) &&
_blockchainExecutedDataCacheProvider.TryGetBlockExecutedData(key, out var value))
{
return(value);
}
var ret = AsyncHelper.RunSync(() => _blockchainExecutedDataManager.GetExecutedCacheAsync(key,
chainContext.BlockHeight,
chainContext.BlockHash));
var blockExecutedData = Deserialize(ret.Value);
//if executed is in Store, it will not change when forking
if (ret.IsInStore && !_blockchainExecutedDataCacheProvider.TryGetChangeHeight(key, out _))
{
_blockchainExecutedDataCacheProvider.SetBlockExecutedData(key, blockExecutedData);
}
return(blockExecutedData);
}
public async Task BlockExecutedData_Test()
{
var genesisBlock = _kernelTestHelper.GenerateBlock(0, Hash.Empty, new List <Transaction>());
var chain = await _blockchainService.CreateChainAsync(genesisBlock, new List <Transaction>());
var blockStateSet = new BlockStateSet
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
await _blockStateSetManger.SetBlockStateSetAsync(blockStateSet);
var transactionDic = new Dictionary <string, Transaction>();
for (var i = 0; i < 5; i++)
{
var transaction = new Transaction
{
From = SampleAddress.AddressList[i],
To = SampleAddress.AddressList[i + 1],
RefBlockNumber = chain.BestChainHeight - 1,
MethodName = "Test"
};
transactionDic.Add(GetBlockExecutedDataKey <Transaction>(transaction.GetHash()), transaction);
}
await _transactionBlockchainExecutedDataService.AddBlockExecutedDataAsync(new BlockIndex
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
}, transactionDic);
var transactionResult = new TransactionResult
{
TransactionId = transactionDic.First().Value.GetHash()
};
var transactionResultKey = GetBlockExecutedDataKey <TransactionResult>(transactionResult.TransactionId);
await _transactionResultBlockchainExecutedDataService.AddBlockExecutedDataAsync(new BlockIndex
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
},
transactionResultKey,
transactionResult);
var chainKey = GetBlockExecutedDataKey <Chain>();
await _chainBlockchainExecutedDataService.AddBlockExecutedDataAsync(new BlockIndex
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
},
chainKey, chain);
CheckBlockExecutedDataCache(new BlockIndex
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
}, chain, transactionResult, transactionDic, false, false);
var newBlockStateSet = await _blockStateSetManger.GetBlockStateSetAsync(chain.BestChainHash);
newBlockStateSet.BlockHash.ShouldBe(blockStateSet.BlockHash);
newBlockStateSet.BlockHeight.ShouldBe(blockStateSet.BlockHeight);
newBlockStateSet.BlockExecutedData.Count.ShouldBe(7);
newBlockStateSet.BlockExecutedData.Keys.ShouldContain(key => key.Contains(typeof(Transaction).Name));
newBlockStateSet.BlockExecutedData.Keys.ShouldContain(key => key.Contains(typeof(TransactionResult).Name));
newBlockStateSet.BlockExecutedData.Keys.ShouldContain(key => key.Contains(typeof(Chain).Name));
blockStateSet = await AddBlockStateSetAsync(blockStateSet);
CheckBlockExecutedData(blockStateSet, chain, transactionResult, transactionDic);
CheckBlockExecutedDataCache(new BlockIndex
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
}, chain, transactionResult, transactionDic, false, false);
await _blockchainStateService.MergeBlockStateAsync(chain.BestChainHeight, chain.BestChainHash);
CheckBlockExecutedData(blockStateSet, chain, transactionResult, transactionDic);
CheckBlockExecutedDataCache(new BlockIndex
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
}, chain, transactionResult, transactionDic, false, true);
blockStateSet = await AddBlockStateSetAsync(blockStateSet);
CheckBlockExecutedData(blockStateSet, chain, transactionResult, transactionDic);
chain = await _blockchainService.GetChainAsync();
await _chainBlockchainExecutedDataService.AddBlockExecutedDataAsync(new BlockIndex
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
},
chainKey, chain);
_chainBlockchainExecutedDataCacheProvider
.TryGetChangeHeight(GetBlockExecutedDataKey <Chain>(), out var chainChangeHeight)
.ShouldBeTrue();
chainChangeHeight.ShouldBe(chain.BestChainHeight);
_chainBlockchainExecutedDataCacheProvider
.TryGetBlockExecutedData(GetBlockExecutedDataKey <Chain>(), out var chainExecutedData)
.ShouldBeFalse();
await _blockchainStateService.MergeBlockStateAsync(chain.BestChainHeight, chain.BestChainHash);
_chainBlockchainExecutedDataService.CleanChangeHeight(chain.BestChainHeight);
_chainBlockchainExecutedDataCacheProvider
.TryGetChangeHeight(GetBlockExecutedDataKey <Chain>(), out chainChangeHeight)
.ShouldBeFalse();
_chainBlockchainExecutedDataService.GetBlockExecutedData(new ChainContext
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
}, GetBlockExecutedDataKey <Chain>());
_chainBlockchainExecutedDataCacheProvider
.TryGetBlockExecutedData(GetBlockExecutedDataKey <Chain>(), out chainExecutedData)
.ShouldBeTrue();
chainExecutedData.ShouldBe(chain);
}
