public async Task PutAsync_Inserts_MultipleProvenBlockHeadersAsync()
{
string folder = CreateTestDir(this);
PosBlock posBlock = CreatePosBlockMock();
ProvenBlockHeader header1 = CreateNewProvenBlockHeaderMock(posBlock);
ProvenBlockHeader header2 = CreateNewProvenBlockHeaderMock(posBlock);
var items = new List <ProvenBlockHeader> {
header1, header2
};
// Put the items in the repository.
using (IProvenBlockHeaderRepository repo = this.SetupRepository(this.Network, folder))
{
await repo.PutAsync(items, new HashHeightPair(header2.GetHash(), items.Count - 1));
}
// Check the ProvenBlockHeader exists in the database.
using (var engine = new DBreezeEngine(folder))
{
DBreeze.Transactions.Transaction txn = engine.GetTransaction();
txn.SynchronizeTables(ProvenBlockHeaderTable);
txn.ValuesLazyLoadingIsOn = false;
var headersOut = txn.SelectDictionary <byte[], ProvenBlockHeader>(ProvenBlockHeaderTable);
headersOut.Keys.Count.Should().Be(2);
headersOut.First().Value.GetHash().Should().Be(items[0].GetHash());
headersOut.Last().Value.GetHash().Should().Be(items[1].GetHash());
}
}
public ProvenBlockHeaderStore(
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
IProvenBlockHeaderRepository provenBlockHeaderRepository,
INodeStats nodeStats,
IInitialBlockDownloadState initialBlockDownloadState)
{
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(provenBlockHeaderRepository, nameof(provenBlockHeaderRepository));
Guard.NotNull(nodeStats, nameof(nodeStats));
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.provenBlockHeaderRepository = provenBlockHeaderRepository;
this.initialBlockDownloadState = initialBlockDownloadState;
this.lockObject = new object();
this.pendingBatch = new SortedDictionary <int, ProvenBlockHeader>();
this.Cache = new MemorySizeCache <int, ProvenBlockHeader>(this.MemoryCacheSizeLimitInBytes);
this.performanceCounter = new BackendPerformanceCounter(dateTimeProvider);
if (nodeStats.DisplayBenchStats)
{
nodeStats.RegisterStats(this.AddBenchStats, StatsType.Benchmark, this.GetType().Name);
}
nodeStats.RegisterStats(this.AddComponentStats, StatsType.Component, this.GetType().Name);
}
public async Task PutAsync_WritesProvenBlockHeaderAndSavesBlockHashAsync()
{
string folder = CreateTestDir(this);
ProvenBlockHeader provenBlockHeaderIn = CreateNewProvenBlockHeaderMock();
var blockHashHieghtPair = new HashHeightPair(provenBlockHeaderIn.GetHash(), 0);
var items = new List <ProvenBlockHeader> {
provenBlockHeaderIn
};
using (IProvenBlockHeaderRepository repo = this.SetupRepository(this.Network, folder))
{
await repo.PutAsync(items, blockHashHieghtPair);
}
using (var engine = new DBreezeEngine(folder))
{
DBreeze.Transactions.Transaction txn = engine.GetTransaction();
txn.SynchronizeTables(ProvenBlockHeaderTable);
txn.ValuesLazyLoadingIsOn = false;
var headerOut = txn.Select <byte[], ProvenBlockHeader>(ProvenBlockHeaderTable, blockHashHieghtPair.Height.ToBytes(false)).Value;
var hashHeightPairOut = txn.Select <byte[], HashHeightPair>(BlockHashTable, new byte[0].ToBytes()).Value;
headerOut.Should().NotBeNull();
headerOut.GetHash().Should().Be(provenBlockHeaderIn.GetHash());
hashHeightPairOut.Should().NotBeNull();
hashHeightPairOut.Hash.Should().Be(provenBlockHeaderIn.GetHash());
}
}
public async Task PutAsync_WritesProvenBlockHeaderAndSavesBlockHashAsync()
{
string folder = CreateTestDir(this);
ProvenBlockHeader provenBlockHeaderIn = CreateNewProvenBlockHeaderMock();
var blockHashHeightPair = new HashHeightPair(provenBlockHeaderIn.GetHash(), 0);
var items = new SortedDictionary <int, ProvenBlockHeader>()
{
{ 0, provenBlockHeaderIn }
};
using (IProvenBlockHeaderRepository repo = this.SetupRepository(this.Network, folder))
{
await repo.PutAsync(items, blockHashHeightPair);
}
using (var engine = new DB(new Options()
{
CreateIfMissing = true
}, folder))
{
var headerOut = this.dataStoreSerializer.Deserialize <ProvenBlockHeader>(engine.Get(DBH.Key(ProvenBlockHeaderTable, BitConverter.GetBytes(blockHashHeightPair.Height))));
var hashHeightPairOut = this.DataStoreSerializer.Deserialize <HashHeightPair>(engine.Get(DBH.Key(BlockHashHeightTable, new byte[] { 1 })));
headerOut.Should().NotBeNull();
headerOut.GetHash().Should().Be(provenBlockHeaderIn.GetHash());
hashHeightPairOut.Should().NotBeNull();
hashHeightPairOut.Hash.Should().Be(provenBlockHeaderIn.GetHash());
}
}
/// <summary>
/// Initializes a new instance of the object.
/// </summary>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory to create a logger for this type.</param>
/// <param name="provenBlockHeaderRepository">Persistent interface of the <see cref="ProvenBlockHeader"/> DBreeze repository.</param>
/// <param name="nodeLifetime">Allows consumers to perform clean-up during a graceful shutdown.</param>
/// <param name="nodeStats">Registers an action used to append node stats when collected.</param>
/// <param name="asyncLoopFactory">Factory for creating and also possibly starting application defined tasks inside async loop.</param>
public ProvenBlockHeaderStore(
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
IProvenBlockHeaderRepository provenBlockHeaderRepository,
INodeLifetime nodeLifetime,
INodeStats nodeStats,
IAsyncLoopFactory asyncLoopFactory)
{
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(provenBlockHeaderRepository, nameof(provenBlockHeaderRepository));
Guard.NotNull(nodeLifetime, nameof(nodeLifetime));
Guard.NotNull(nodeStats, nameof(nodeStats));
Guard.NotNull(asyncLoopFactory, nameof(asyncLoopFactory));
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.provenBlockHeaderRepository = provenBlockHeaderRepository;
this.nodeLifetime = nodeLifetime;
this.lockObject = new object();
this.PendingBatch = new Dictionary <int, ProvenBlockHeader>();
this.Cache = new MemorySizeCache <int, ProvenBlockHeader>(this.MemoryCacheSizeLimitInBytes);
this.asyncLoopFactory = asyncLoopFactory;
this.performanceCounter = new BackendPerformanceCounter(dateTimeProvider);
nodeStats.RegisterStats(this.AddBenchStats, StatsType.Benchmark);
nodeStats.RegisterStats(this.AddComponentStats, StatsType.Component);
}
public ProvenBlockHeaderStoreTests() : base(new StratisTest())
{
var nodeStats = new NodeStats(DateTimeProvider.Default);
this.provenBlockHeaderRepository = new ProvenBlockHeaderRepository(this.Network, CreateTestDir(this), this.LoggerFactory.Object);
this.provenBlockHeaderStore = new ProvenBlockHeaderStore(DateTimeProvider.Default, this.LoggerFactory.Object, this.provenBlockHeaderRepository, nodeStats);
}
public async Task Initializes_Genesis_ProvenBlockHeader_OnLoadAsync()
{
string folder = CreateTestDir(this);
// Initialise the repository - this will set-up the genesis blockHash (blockId).
using (IProvenBlockHeaderRepository repository = this.SetupRepository(this.Network, folder))
{
// Check the BlockHash (blockId) exists.
repository.TipHashHeight.Height.Should().Be(0);
repository.TipHashHeight.Hash.Should().Be(this.Network.GetGenesis().GetHash());
}
}
public ProvenBlockHeaderStoreTests() : base(new StraxTest())
{
var nodeStats = new NodeStats(DateTimeProvider.Default, NodeSettings.Default(this.Network), new Mock <IVersionProvider>().Object);
var dBreezeSerializer = new DBreezeSerializer(this.Network.Consensus.ConsensusFactory);
var ibdMock = new Mock <IInitialBlockDownloadState>();
ibdMock.Setup(s => s.IsInitialBlockDownload()).Returns(false);
this.provenBlockHeaderRepository = new LevelDbProvenBlockHeaderRepository(this.Network, CreateTestDir(this), this.LoggerFactory.Object, dBreezeSerializer);
this.provenBlockHeaderStore = new ProvenBlockHeaderStore(DateTimeProvider.Default, this.LoggerFactory.Object, this.provenBlockHeaderRepository, nodeStats, ibdMock.Object);
}
public ProvenBlockHeaderStoreTests() : base(KnownNetworks.StratisTest)
{
this.consensusManager = new Mock <IConsensusManager>();
this.nodeLifetime = new Mock <INodeLifetime>();
this.nodeStats = new NodeStats(DateTimeProvider.Default);
this.asyncLoopFactoryLoop = new Mock <IAsyncLoopFactory>();
this.Folder = CreateTestDir(this);
this.provenBlockHeaderRepository = new ProvenBlockHeaderRepository(this.network, this.Folder, this.LoggerFactory.Object);
this.provenBlockHeaderStore = new ProvenBlockHeaderStore(
DateTimeProvider.Default, this.LoggerFactory.Object, this.provenBlockHeaderRepository,
this.nodeLifetime.Object, this.nodeStats, this.asyncLoopFactoryLoop.Object);
}
public async Task PutAsync_Inserts_MultipleProvenBlockHeadersAsync()
{
string folder = CreateTestDir(this);
PosBlock posBlock = CreatePosBlock();
ProvenBlockHeader header1 = CreateNewProvenBlockHeaderMock(posBlock);
ProvenBlockHeader header2 = CreateNewProvenBlockHeaderMock(posBlock);
var items = new SortedDictionary <int, ProvenBlockHeader>()
{
{ 0, header1 }, { 1, header2 }
};
// Put the items in the repository.
using (IProvenBlockHeaderRepository repo = this.SetupRepository(this.Network, folder))
{
await repo.PutAsync(items, new HashHeightPair(header2.GetHash(), items.Count - 1));
}
// Check the ProvenBlockHeader exists in the database.
using (var engine = new DB(new Options()
{
CreateIfMissing = true
}, folder))
{
var headersOut = new Dictionary <byte[], byte[]>();
var enumeator = engine.GetEnumerator();
while (enumeator.MoveNext())
{
if (enumeator.Current.Key[0] == ProvenBlockHeaderTable)
{
headersOut.Add(enumeator.Current.Key, enumeator.Current.Value);
}
}
headersOut.Keys.Count.Should().Be(2);
this.dataStoreSerializer.Deserialize <ProvenBlockHeader>(headersOut.First().Value).GetHash().Should().Be(items[0].GetHash());
this.dataStoreSerializer.Deserialize <ProvenBlockHeader>(headersOut.Last().Value).GetHash().Should().Be(items[1].GetHash());
}
}
public async Task PutAsync_Add_Ten_ProvenBlockHeaders_Dispose_On_Initialise_Repo_TipHeight_Should_Be_At_Last_Saved_TipAsync()
{
string folder = CreateTestDir(this);
PosBlock posBlock = CreatePosBlockMock();
var headers = new List <ProvenBlockHeader>();
for (int i = 0; i < 10; i++)
{
headers.Add(CreateNewProvenBlockHeaderMock(posBlock));
}
// Put the items in the repository.
using (IProvenBlockHeaderRepository repo = this.SetupRepository(this.Network, folder))
{
await repo.PutAsync(headers, new HashHeightPair(headers.Last().GetHash(), headers.Count - 1));
}
using (IProvenBlockHeaderRepository newRepo = this.SetupRepository(this.Network, folder))
{
newRepo.TipHashHeight.Hash.Should().Be(headers.Last().GetHash());
newRepo.TipHashHeight.Height.Should().Be(headers.Count - 1);
}
}
public async Task PutAsyncsDisposeOnInitialiseShouldBeAtLastSavedTipAsync()
{
string folder = CreateTestDir(this);
PosBlock posBlock = CreatePosBlock();
var headers = new SortedDictionary <int, ProvenBlockHeader>();
for (int i = 0; i < 10; i++)
{
headers.Add(i, CreateNewProvenBlockHeaderMock(posBlock));
}
// Put the items in the repository.
using (IProvenBlockHeaderRepository repo = this.SetupRepository(this.Network, folder))
{
await repo.PutAsync(headers, new HashHeightPair(headers.Last().Value.GetHash(), headers.Count - 1));
}
using (IProvenBlockHeaderRepository newRepo = this.SetupRepository(this.Network, folder))
{
newRepo.TipHashHeight.Hash.Should().Be(headers.Last().Value.GetHash());
newRepo.TipHashHeight.Height.Should().Be(headers.Count - 1);
}
}
