public void CanSaveChainIncrementally()
{
var chain = new ChainIndexer(this.regTest);
var data = new DataFolder(TestBase.CreateTestDir(this));
var chainStore = new LevelDbChainStore(this.network, data, chain);
chain[0].SetChainStore(chainStore);
using (var repo = new ChainRepository(chainStore))
{
chain.SetTip(repo.LoadAsync(chain.Genesis).GetAwaiter().GetResult());
Assert.True(chain.Tip == chain.Genesis);
chain = new ChainIndexer(this.regTest);
chain[0].SetChainStore(chainStore);
ChainedHeader tip = this.AppendBlock(chain);
repo.SaveAsync(chain).GetAwaiter().GetResult();
var newChain = new ChainIndexer(this.regTest);
newChain.SetTip(repo.LoadAsync(chain.Genesis).GetAwaiter().GetResult());
Assert.Equal(tip, newChain.Tip);
tip = this.AppendBlock(chain);
repo.SaveAsync(chain).GetAwaiter().GetResult();
newChain = new ChainIndexer(this.regTest);
newChain.SetTip(repo.LoadAsync(chain.Genesis).GetAwaiter().GetResult());
Assert.Equal(tip, newChain.Tip);
}
}
public void LoadChainFromDisk()
{
string dir = CreateTestDir(this);
var chain = new ChainIndexer(KnownNetworks.StraxRegTest);
ChainedHeader tip = this.AppendBlock(chain);
using (var engine = new DB(new Options {
CreateIfMissing = true
}, new DataFolder(dir).ChainPath))
{
using (var batch = new WriteBatch())
{
ChainedHeader toSave = tip;
var blocks = new List <ChainedHeader>();
while (toSave != null)
{
blocks.Insert(0, toSave);
toSave = toSave.Previous;
}
foreach (ChainedHeader block in blocks)
{
batch.Put(1, BitConverter.GetBytes(block.Height),
new ChainRepository.ChainRepositoryData()
{
Hash = block.HashBlock, Work = block.ChainWorkBytes
}
.ToBytes(this.Network.Consensus.ConsensusFactory));
ConsensusFactory consensusFactory = KnownNetworks.StraxRegTest.Consensus.ConsensusFactory;
batch.Put(2, block.Header.GetHash().ToBytes(), block.Header.ToBytes(consensusFactory));
}
engine.Write(batch);
}
}
var chainStore = new LevelDbChainStore(chain.Network, new DataFolder(dir), chain);
using (var repo = new ChainRepository(chainStore))
{
var testChain = new ChainIndexer(KnownNetworks.StraxRegTest);
testChain[0].SetChainStore(chainStore);
testChain.SetTip(repo.LoadAsync(testChain.Genesis).GetAwaiter().GetResult());
Assert.Equal(tip, testChain.Tip);
}
}
/// <summary>
/// Makes the full node use all the required features - <see cref="BaseFeature"/>.
/// </summary>
/// <param name="fullNodeBuilder">Builder responsible for creating the node.</param>
/// <returns>Full node builder's interface to allow fluent code.</returns>
public static IFullNodeBuilder UseBaseFeature(this IFullNodeBuilder fullNodeBuilder, DbType dbType = DbType.Leveldb)
{
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <BaseFeature>()
.FeatureServices(services =>
{
services.AddSingleton(fullNodeBuilder.Network.Consensus.ConsensusFactory);
services.AddSingleton <DBreezeSerializer>();
services.AddSingleton(fullNodeBuilder.NodeSettings.LoggerFactory);
services.AddSingleton(fullNodeBuilder.NodeSettings.DataFolder);
services.AddSingleton <INodeLifetime, NodeLifetime>();
services.AddSingleton <IPeerBanning, PeerBanning>();
services.AddSingleton <FullNodeFeatureExecutor>();
services.AddSingleton <ISignals, Signals.Signals>();
services.AddSingleton <ISubscriptionErrorHandler, DefaultSubscriptionErrorHandler>();
services.AddSingleton <FullNode>().AddSingleton((provider) => { return(provider.GetService <FullNode>() as IFullNode); });
ChainIndexer chainIndexer = new ChainIndexer(fullNodeBuilder.Network);
IChainStore chainStore = null;
if (dbType == DbType.Leveldb)
{
chainStore = new LevelDbChainStore(fullNodeBuilder.Network, fullNodeBuilder.NodeSettings.DataFolder, chainIndexer);
services.AddSingleton <IKeyValueRepository, LevelDbKeyValueRepository>();
}
if (dbType == DbType.RocksDb)
{
chainStore = new RocksDbChainStore(fullNodeBuilder.Network, fullNodeBuilder.NodeSettings.DataFolder, chainIndexer);
services.AddSingleton <IKeyValueRepository, RocksDbKeyValueRepository>();
}
chainIndexer[0].SetChainStore(chainStore);
services.AddSingleton(chainStore);
services.AddSingleton(chainIndexer);
services.AddSingleton(DateTimeProvider.Default);
services.AddSingleton <IInvalidBlockHashStore, InvalidBlockHashStore>();
services.AddSingleton <IChainState, ChainState>();
services.AddSingleton <IChainRepository, ChainRepository>();
services.AddSingleton <IFinalizedBlockInfoRepository, FinalizedBlockInfoRepository>();
services.AddSingleton <ITimeSyncBehaviorState, TimeSyncBehaviorState>();
services.AddSingleton <NodeDeployments>();
services.AddSingleton <IInitialBlockDownloadState, InitialBlockDownloadState>();
services.AddSingleton <ITipsManager, TipsManager>();
services.AddSingleton <IAsyncProvider, AsyncProvider>();
// Consensus
services.AddSingleton <ConsensusSettings>();
services.AddSingleton <ICheckpoints, Checkpoints>();
services.AddSingleton <ConsensusRulesContainer>();
foreach (var ruleType in fullNodeBuilder.Network.Consensus.ConsensusRules.HeaderValidationRules)
{
services.AddSingleton(typeof(IHeaderValidationConsensusRule), ruleType);
}
foreach (var ruleType in fullNodeBuilder.Network.Consensus.ConsensusRules.IntegrityValidationRules)
{
services.AddSingleton(typeof(IIntegrityValidationConsensusRule), ruleType);
}
foreach (var ruleType in fullNodeBuilder.Network.Consensus.ConsensusRules.PartialValidationRules)
{
services.AddSingleton(typeof(IPartialValidationConsensusRule), ruleType);
}
foreach (var ruleType in fullNodeBuilder.Network.Consensus.ConsensusRules.FullValidationRules)
{
services.AddSingleton(typeof(IFullValidationConsensusRule), ruleType);
}
// Connection
services.AddSingleton <INetworkPeerFactory, NetworkPeerFactory>();
services.AddSingleton <NetworkPeerConnectionParameters>();
services.AddSingleton <IConnectionManager, ConnectionManager>();
services.AddSingleton <ConnectionManagerSettings>();
services.AddSingleton(new PayloadProvider().DiscoverPayloads());
services.AddSingleton <IVersionProvider, VersionProvider>();
services.AddSingleton <IBlockPuller, BlockPuller>();
// Peer address manager
services.AddSingleton <IPeerAddressManager, PeerAddressManager>();
services.AddSingleton <IPeerConnector, PeerConnectorAddNode>();
services.AddSingleton <IPeerConnector, PeerConnectorConnectNode>();
services.AddSingleton <IPeerConnector, PeerConnectorDiscovery>();
services.AddSingleton <IPeerDiscovery, PeerDiscovery>();
services.AddSingleton <ISelfEndpointTracker, SelfEndpointTracker>();
// Consensus
// Consensus manager is created like that due to CM's constructor being internal. This is done
// in order to prevent access to CM creation and CHT usage from another features. CHT is supposed
// to be used only by CM and no other component.
services.AddSingleton <IConsensusManager>(provider => new ConsensusManager(
chainedHeaderTree: provider.GetService <IChainedHeaderTree>(),
network: provider.GetService <Network>(),
loggerFactory: provider.GetService <ILoggerFactory>(),
chainState: provider.GetService <IChainState>(),
integrityValidator: provider.GetService <IIntegrityValidator>(),
partialValidator: provider.GetService <IPartialValidator>(),
fullValidator: provider.GetService <IFullValidator>(),
consensusRules: provider.GetService <IConsensusRuleEngine>(),
finalizedBlockInfo: provider.GetService <IFinalizedBlockInfoRepository>(),
signals: provider.GetService <ISignals>(),
peerBanning: provider.GetService <IPeerBanning>(),
ibdState: provider.GetService <IInitialBlockDownloadState>(),
chainIndexer: provider.GetService <ChainIndexer>(),
blockPuller: provider.GetService <IBlockPuller>(),
blockStore: provider.GetService <IBlockStore>(),
connectionManager: provider.GetService <IConnectionManager>(),
nodeStats: provider.GetService <INodeStats>(),
nodeLifetime: provider.GetService <INodeLifetime>(),
consensusSettings: provider.GetService <ConsensusSettings>(),
dateTimeProvider: provider.GetService <IDateTimeProvider>()));
services.AddSingleton <IChainWorkComparer, ChainWorkComparer>();
services.AddSingleton <IChainedHeaderTree, ChainedHeaderTree>();
services.AddSingleton <IHeaderValidator, HeaderValidator>();
services.AddSingleton <IIntegrityValidator, IntegrityValidator>();
services.AddSingleton <IPartialValidator, PartialValidator>();
services.AddSingleton <IFullValidator, FullValidator>();
// Console
services.AddSingleton <INodeStats, NodeStats>();
});
});
return(fullNodeBuilder);
}
