public PruningWorker(WorkerConfig workerConfig, Func <ChainStateBuilder> getChainStateBuilder, Logger logger, IBlockchainRules rules, BlockTxHashesCache blockTxHashesCache, TransactionCache transactionCache, SpentTransactionsCache spentTransactionsCache, SpentOutputsCache spentOutputsCache)
: base("PruningWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime, logger)
{
this.getChainStateBuilder = getChainStateBuilder;
this.rules = rules;
this.blockTxHashesCache = blockTxHashesCache;
this.transactionCache = transactionCache;
this.spentTransactionsCache = spentTransactionsCache;
this.spentOutputsCache = spentOutputsCache;
this.Mode = PruningMode.SpentOnly;
}
public CoreDaemon(Logger logger, IKernel kernel, IBlockchainRules rules, BlockHeaderCache blockHeaderCache, ChainedHeaderCache chainedHeaderCache, BlockTxHashesCache blockTxHashesCache, TransactionCache transactionCache, BlockCache blockCache)
{
this.logger = logger;
this.shutdownToken = new CancellationTokenSource();
this.kernel = kernel;
this.rules = rules;
this.blockHeaderCache = blockHeaderCache;
this.chainedHeaderCache = chainedHeaderCache;
this.blockTxHashesCache = blockTxHashesCache;
this.transactionCache = transactionCache;
this.blockCache = blockCache;
// write genesis block out to storage
this.blockHeaderCache[this.rules.GenesisBlock.Hash] = this.rules.GenesisBlock.Header;
this.blockCache[this.rules.GenesisBlock.Hash] = this.rules.GenesisBlock;
this.chainedHeaderCache[this.rules.GenesisChainedHeader.Hash] = this.rules.GenesisChainedHeader;
// wire up cache events
this.blockHeaderCache.OnAddition += OnBlockHeaderAddition;
this.blockHeaderCache.OnModification += OnBlockHeaderModification;
this.blockCache.OnAddition += OnBlockAddition;
this.blockCache.OnModification += OnBlockModification;
this.blockTxHashesCache.OnAddition += OnBlockTxHashesAddition;
this.blockTxHashesCache.OnModification += OnBlockTxHashesModification;
this.chainedHeaderCache.OnAddition += OnChainedHeaderAddition;
this.chainedHeaderCache.OnModification += OnChainedHeaderModification;
// create chain state builder
this.chainStateBuilder =
this.kernel.Get <ChainStateBuilder>(
new ConstructorArgument("chain", Chain.CreateForGenesisBlock(this.rules.GenesisChainedHeader).ToBuilder()),
new ConstructorArgument("parentUtxo", Utxo.CreateForGenesisBlock(this.rules.GenesisBlock.Hash)));
this.chainStateLock = new ReaderWriterLockSlim();
// create workers
this.chainingWorker = kernel.Get <ChainingWorker>(
new ConstructorArgument("workerConfig", new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromSeconds(0), maxIdleTime: TimeSpan.FromSeconds(30))));
this.targetChainWorker = kernel.Get <TargetChainWorker>(
new ConstructorArgument("workerConfig", new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromSeconds(0), maxIdleTime: TimeSpan.FromSeconds(30))));
this.chainStateWorker = kernel.Get <ChainStateWorker>(
new ConstructorArgument("workerConfig", new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.Zero, maxIdleTime: TimeSpan.FromSeconds(5))),
new ConstructorArgument("getTargetChain", (Func <Chain>)(() => this.targetChainWorker.TargetChain)),
new ConstructorArgument("targetChainWorker", this.targetChainWorker),
new ConstructorArgument("chainStateBuilder", this.chainStateBuilder));
this.targetChainWorker.OnTargetBlockChanged +=
() =>
{
var handler = this.OnTargetBlockChanged;
if (handler != null)
{
handler(this, EventArgs.Empty);
}
};
this.targetChainWorker.OnTargetChainChanged +=
() =>
{
this.chainStateWorker.NotifyWork();
var handler = this.OnTargetChainChanged;
if (handler != null)
{
handler(this, EventArgs.Empty);
}
};
this.chainStateWorker.OnChainStateChanged +=
() =>
{
this.utxoScanWorker.NotifyWork();
//TODO once fully synced, this should save off the immutable snapshot immediately
//TODO this will allow there to always be an active chain state once synced
this.chainStateLock.DoWrite(() =>
this.chainState = null);
var handler = this.OnChainStateChanged;
if (handler != null)
{
handler(this, EventArgs.Empty);
}
};
this.gcWorker = new WorkerMethod("GC Worker",
() =>
{
this.logger.Info(
string.Join("\n",
new string('-', 80),
"GC Memory: {0,10:#,##0.00} MB",
"Process Memory: {1,10:#,##0.00} MB",
new string('-', 80)
)
.Format2
(
/*0*/ (float)GC.GetTotalMemory(false) / 1.MILLION(),
/*1*/ (float)Process.GetCurrentProcess().PrivateMemorySize64 / 1.MILLION()
));
}, initialNotify: true, minIdleTime: TimeSpan.FromSeconds(30), maxIdleTime: TimeSpan.FromSeconds(30), logger: this.logger);
this.utxoScanWorker = new WorkerMethod("UTXO Scan Worker",
() =>
{
var chainStateLocal = this.GetChainState();
if (chainStateLocal == null)
{
return;
}
new MethodTimer().Time("Full UTXO Scan: {0:#,##0}".Format2(chainStateLocal.Utxo.OutputCount), () =>
{
var sha256 = new SHA256Managed();
foreach (var output in chainStateLocal.Utxo.GetUnspentOutputs())
{
if (new UInt256(sha256.ComputeDoubleHash(output.Value.ScriptPublicKey.ToArray())) == UInt256.Zero)
{
}
}
});
}, initialNotify: true, minIdleTime: TimeSpan.Zero, maxIdleTime: TimeSpan.MaxValue, logger: this.logger);
}
