public ProvenHeadersConsensusManagerBehavior(
ChainIndexer chainIndexer,
IInitialBlockDownloadState initialBlockDownloadState,
IConsensusManager consensusManager,
IPeerBanning peerBanning,
ILoggerFactory loggerFactory,
Network network,
IChainState chainState,
ICheckpoints checkpoints,
IProvenBlockHeaderStore provenBlockHeaderStore,
ConnectionManagerSettings connectionManagerSettings) : base(chainIndexer, initialBlockDownloadState, consensusManager, peerBanning, loggerFactory)
{
this.network = network;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.chainState = chainState;
this.checkpoints = checkpoints;
this.provenBlockHeaderStore = provenBlockHeaderStore;
this.lastCheckpointHeight = this.checkpoints.LastCheckpointHeight;
this.lastCheckpointInfo = this.checkpoints.GetCheckpoint(this.lastCheckpointHeight);
this.connectionManagerSettings = connectionManagerSettings;
#pragma warning disable CS0618 // Type or member is obsolete
this.isGateway = this.connectionManagerSettings.IsGateway;
#pragma warning restore CS0618 // Type or member is obsolete
}
public async Task AddToPending_Store_TipHash_Is_The_Same_As_ChainHeaderTipAsync()
{
var chainWithHeaders = this.BuildProvenHeaderChain(3);
SortedDictionary <int, ProvenBlockHeader> provenBlockheaders = this.ConvertToDictionaryOfProvenHeaders(chainWithHeaders);
// Persist current chain.
await this.provenBlockHeaderRepository.PutAsync(
provenBlockheaders,
new HashHeightPair(provenBlockheaders.Last().Value.GetHash(), provenBlockheaders.Count - 1)).ConfigureAwait(false);
using (IProvenBlockHeaderStore store = this.SetupStore())
{
var header = this.CreateNewProvenBlockHeaderMock();
this.provenBlockHeaderStore.AddToPendingBatch(header, new HashHeightPair(header.GetHash(), chainWithHeaders.Height));
this.provenBlockHeaderStore.InvokeMethod("SaveAsync");
HashHeightPair tipHashHeight = null;
WaitLoop(() =>
{
tipHashHeight = this.provenBlockHeaderStore.GetMemberValue("TipHashHeight") as HashHeightPair;
return(tipHashHeight == this.provenBlockHeaderRepository.TipHashHeight);
});
tipHashHeight.Height.Should().Be(chainWithHeaders.Height);
}
}
public PosConsensusFeature(
Network network,
IChainState chainState,
IConnectionManager connectionManager,
IConsensusManager consensusManager,
NodeDeployments nodeDeployments,
ConcurrentChain chain,
IInitialBlockDownloadState initialBlockDownloadState,
IPeerBanning peerBanning,
Signals.ISignals signals,
ILoggerFactory loggerFactory,
ICheckpoints checkpoints,
IProvenBlockHeaderStore provenBlockHeaderStore,
ConnectionManagerSettings connectionManagerSettings) : base(network, chainState, connectionManager, signals, consensusManager, nodeDeployments)
{
this.network = network;
this.chainState = chainState;
this.connectionManager = connectionManager;
this.consensusManager = consensusManager;
this.nodeDeployments = nodeDeployments;
this.chain = chain;
this.initialBlockDownloadState = initialBlockDownloadState;
this.peerBanning = peerBanning;
this.loggerFactory = loggerFactory;
this.checkpoints = checkpoints;
this.provenBlockHeaderStore = provenBlockHeaderStore;
this.connectionManagerSettings = connectionManagerSettings;
this.chainState.MaxReorgLength = network.Consensus.MaxReorgLength;
}
public ProvenHeadersConsensusManagerBehavior(
ChainIndexer chainIndexer,
IInitialBlockDownloadState initialBlockDownloadState,
IConsensusManager consensusManager,
IPeerBanning peerBanning,
ILoggerFactory loggerFactory,
Network network,
IChainState chainState,
ICheckpoints checkpoints,
IProvenBlockHeaderStore provenBlockHeaderStore,
ConnectionManagerSettings connectionManagerSettings) : base(chainIndexer, initialBlockDownloadState, consensusManager, peerBanning, loggerFactory)
{
this.ChainIndexer = chainIndexer;
this.initialBlockDownloadState = initialBlockDownloadState;
this.consensusManager = consensusManager;
this.peerBanning = peerBanning;
this.network = network;
this.loggerFactory = loggerFactory;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName, $"[{this.GetHashCode():x}] ");
this.chainState = chainState;
this.checkpoints = checkpoints;
this.provenBlockHeaderStore = provenBlockHeaderStore;
this.lastCheckpointHeight = this.checkpoints.GetLastCheckpointHeight();
this.lastCheckpointInfo = this.checkpoints.GetCheckpoint(this.lastCheckpointHeight);
this.connectionManagerSettings = connectionManagerSettings;
this.isGateway = this.connectionManagerSettings.IsGateway;
}
public BaseFeature(NodeSettings nodeSettings,
DataFolder dataFolder,
INodeLifetime nodeLifetime,
ChainIndexer chainIndexer,
IChainState chainState,
IConnectionManager connectionManager,
IChainRepository chainRepository,
IFinalizedBlockInfoRepository finalizedBlockInfo,
IDateTimeProvider dateTimeProvider,
IAsyncProvider asyncProvider,
ITimeSyncBehaviorState timeSyncBehaviorState,
ILoggerFactory loggerFactory,
IInitialBlockDownloadState initialBlockDownloadState,
IPeerBanning peerBanning,
IPeerAddressManager peerAddressManager,
IConsensusManager consensusManager,
IConsensusRuleEngine consensusRules,
IPartialValidator partialValidator,
IBlockPuller blockPuller,
IBlockStore blockStore,
Network network,
ITipsManager tipsManager,
NodeDeployments nodeDeployments,
IKeyValueRepository keyValueRepo,
INodeStats nodeStats,
IBroadcasterManager broadcasterManager,
IProvenBlockHeaderStore provenBlockHeaderStore = null)
{
this.chainState = Guard.NotNull(chainState, nameof(chainState));
this.chainRepository = Guard.NotNull(chainRepository, nameof(chainRepository));
this.finalizedBlockInfoRepository = Guard.NotNull(finalizedBlockInfo, nameof(finalizedBlockInfo));
this.nodeSettings = Guard.NotNull(nodeSettings, nameof(nodeSettings));
this.dataFolder = Guard.NotNull(dataFolder, nameof(dataFolder));
this.nodeLifetime = Guard.NotNull(nodeLifetime, nameof(nodeLifetime));
this.chainIndexer = Guard.NotNull(chainIndexer, nameof(chainIndexer));
this.connectionManager = Guard.NotNull(connectionManager, nameof(connectionManager));
this.consensusManager = consensusManager;
this.consensusRules = consensusRules;
this.blockPuller = blockPuller;
this.blockStore = blockStore;
this.network = network;
this.nodeStats = nodeStats;
this.broadcasterManager = broadcasterManager;
this.provenBlockHeaderStore = provenBlockHeaderStore;
this.partialValidator = partialValidator;
this.peerBanning = Guard.NotNull(peerBanning, nameof(peerBanning));
this.tipsManager = Guard.NotNull(tipsManager, nameof(tipsManager));
this.keyValueRepo = Guard.NotNull(keyValueRepo, nameof(keyValueRepo));
this.nodeDeployments = nodeDeployments;
this.peerAddressManager = Guard.NotNull(peerAddressManager, nameof(peerAddressManager));
this.peerAddressManager.PeerFilePath = this.dataFolder;
this.initialBlockDownloadState = initialBlockDownloadState;
this.dateTimeProvider = dateTimeProvider;
this.asyncProvider = asyncProvider;
this.timeSyncBehaviorState = timeSyncBehaviorState;
this.loggerFactory = loggerFactory;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
}
public async Task AddToPending_Store_TipHash_Is_The_Same_As_ChainHeaderTipAsync()
{
var chainWithHeaders = BuildChainWithProvenHeaders(3, this.network);
var provenBlockheaders = chainWithHeaders.provenBlockHeaders;
// Persist current chain.
await this.provenBlockHeaderRepository.PutAsync(
provenBlockheaders,
new HashHeightPair(provenBlockheaders.Last().GetHash(), provenBlockheaders.Count - 1)).ConfigureAwait(false);
using (IProvenBlockHeaderStore store = this.SetupStore(this.Folder))
{
var header = CreateNewProvenBlockHeaderMock();
this.provenBlockHeaderStore.AddToPendingBatch(header, new HashHeightPair(header.GetHash(), chainWithHeaders.chainedHeader.Height));
this.provenBlockHeaderStore.InvokeMethod("SaveAsync");
HashHeightPair tipHashHeight = null;
WaitLoop(() =>
{
tipHashHeight = this.provenBlockHeaderStore.GetMemberValue("TipHashHeight") as HashHeightPair;
return(tipHashHeight == this.provenBlockHeaderRepository.TipHashHeight);
});
tipHashHeight.Height.Should().Be(chainWithHeaders.chainedHeader.Height);
}
}
public ProvenHeaderConsenusManagerBehaviorTests() : base(new StratisTest())
{
this.chainState = new Mock <IChainState>().Object;
this.checkpoints = new Mock <ICheckpoints>().Object;
this.connectionManagerSettings = new ConnectionManagerSettings(NodeSettings.Default(this.Network));
this.extendedLoggerFactory = new ExtendedLoggerFactory(); this.extendedLoggerFactory.AddConsoleWithFilters();
this.initialBlockDownloadState = new Mock <IInitialBlockDownloadState>().Object;
this.peerBanning = new Mock <IPeerBanning>().Object;
this.provenBlockHeaderStore = new Mock <IProvenBlockHeaderStore>().Object;
}
public ProvenHeaderConsenusManagerBehaviorTests() : base(new StratisTest())
{
this.chainState = new Mock <IChainState>().Object;
this.checkpoints = new Mock <ICheckpoints>().Object;
this.connectionManagerSettings = new ConnectionManagerSettings(NodeSettings.Default(this.Network));
this.extendedLoggerFactory = ExtendedLoggerFactory.Create();
this.initialBlockDownloadState = new Mock <IInitialBlockDownloadState>().Object;
this.peerBanning = new Mock <IPeerBanning>().Object;
this.provenBlockHeaderStore = new Mock <IProvenBlockHeaderStore>().Object;
this.signals = new Signals.Signals(this.extendedLoggerFactory, null);
this.asyncProvider = new AsyncProvider(this.extendedLoggerFactory, this.signals, new Mock <INodeLifetime>().Object);
}
public ProvenHeadersBlockStoreSignaled(
Network network,
IBlockStoreQueue blockStoreQueue,
StoreSettings storeSettings,
IChainState chainState,
IConnectionManager connection,
INodeLifetime nodeLifetime,
ILoggerFactory loggerFactory,
IInitialBlockDownloadState initialBlockDownloadState,
IProvenBlockHeaderStore provenBlockHeaderStore)
: base(blockStoreQueue, storeSettings, chainState, connection, nodeLifetime, loggerFactory, initialBlockDownloadState)
{
this.network = Guard.NotNull(network, nameof(network));
this.provenBlockHeaderStore = Guard.NotNull(provenBlockHeaderStore, nameof(provenBlockHeaderStore));
}
public async Task InitializeAsync_When_Chain_Tip_Reverts_Back_To_Genesis_Store_Tip_Is_In_SyncAsync()
{
var chainWithHeaders = BuildChainWithProvenHeaders(3, this.network);
var provenBlockheaders = chainWithHeaders.provenBlockHeaders;
await this.provenBlockHeaderRepository.PutAsync(
provenBlockheaders,
new HashHeightPair(provenBlockheaders.Last().GetHash(), provenBlockheaders.Count - 1)).ConfigureAwait(false);
using (IProvenBlockHeaderStore store = this.SetupStore(this.Folder))
{
// Revert back to Genesis.
await store.InitializeAsync(chainWithHeaders.chainedHeader.Previous.Previous);
store.TipHashHeight.Hash.Should().Be(chainWithHeaders.chainedHeader.Previous.Previous.HashBlock);
}
}
public async Task GetAsync_Get_Items_From_StoreAsync()
{
var chainWithHeaders = BuildChainWithProvenHeaders(3, this.network);
var inHeaders = chainWithHeaders.provenBlockHeaders;
await this.provenBlockHeaderRepository.PutAsync(inHeaders, new HashHeightPair(inHeaders.Last().GetHash(), inHeaders.Count - 1)).ConfigureAwait(false);
// Then load them.
using (IProvenBlockHeaderStore store = this.SetupStore(this.Folder))
{
var outHeaders = await store.GetAsync(0, inHeaders.Count).ConfigureAwait(false);
outHeaders.Count.Should().Be(inHeaders.Count);
// inHeaders should exist in outHeaders (from the repository).
inHeaders.All(inHeader => outHeaders.Any(outHeader => inHeader.GetHash() == outHeader.GetHash())).Should().BeTrue();
}
}
public async Task InitializeAsync_When_Tip_Reorg_Occurs_Behind_Current_TipAsync()
{
// Chain - 1 - 2 - 3 - 4 - 5 (tip at 5).
var chainWithHeaders = BuildChainWithProvenHeaders(5, this.network);
var provenBlockheaders = chainWithHeaders.provenBlockHeaders;
// Persist current chain.
await this.provenBlockHeaderRepository.PutAsync(
provenBlockheaders,
new HashHeightPair(provenBlockheaders.Last().GetHash(), provenBlockheaders.Count - 1)).ConfigureAwait(false);
using (IProvenBlockHeaderStore store = this.SetupStore(this.Folder))
{
// Reorganised chain - 1 - 2 - 3 (tip at 3).
await store.InitializeAsync(chainWithHeaders.chainedHeader.Previous.Previous).ConfigureAwait(true);
store.TipHashHeight.Hash.Should().Be(chainWithHeaders.chainedHeader.Previous.Previous.Header.GetHash());
}
}
public async Task InitializeAsync_When_Behind_Reorg_Occurs_Throws_Exception_When_New_ChainHeader_Tip_Doesnt_ExistAsync()
{
// Chain - Chain - 1 - 2 - 3
var chainWithHeaders = BuildChainWithProvenHeaders(3, this.network, true);
var provenBlockheaders = chainWithHeaders.provenBlockHeaders;
await this.provenBlockHeaderRepository.PutAsync(
provenBlockheaders.Take(5).ToList(),
new HashHeightPair(provenBlockheaders.Last().GetHash(), provenBlockheaders.Count - 1)).ConfigureAwait(false);
// Create a new chain which a different hash block.
chainWithHeaders = BuildChainWithProvenHeaders(2, this.network, true);
using (IProvenBlockHeaderStore store = this.SetupStore(this.Folder))
{
Func <Task> act = async() => { await store.InitializeAsync(chainWithHeaders.chainedHeader).ConfigureAwait(false); };
act.Should().Throw <ProvenBlockHeaderException>().WithMessage("Chain header tip hash does not match the latest proven block header hash saved to disk.");
}
}
