public override void Subscribe(ISubscriber <R>[] subscribers) { if (!this.Validate(subscribers)) { return; } int n = subscribers.Length; var parents = new ISubscriber <T> [n]; for (int i = 0; i < n; i++) { R accumulator; try { accumulator = initialFactory(); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); foreach (var s in subscribers) { EmptySubscription <R> .Error(s, ex); } return; } parents[i] = new PublisherReduceWith <T, R> .ReduceWithSubscriber(subscribers[i], accumulator, reducer); } source.Subscribe(parents); }
public void Subscribe(ISubscriber <R> s) { var pp = new PublishProcessor <T>(prefetch); IPublisher <R> o; try { o = transformer(pp); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <R> .Error(s, ex); return; } if (s is IConditionalSubscriber <R> ) { o.Subscribe(new PublishSelectorConditionalSubscriber(pp, (IConditionalSubscriber <R>)s)); } else { o.Subscribe(new PublishSelectorSubscriber(pp, s)); } source.Subscribe(pp); }
public void Subscribe(ISubscriber <V> s) { if (Interlocked.CompareExchange(ref once, 1, 0) == 0) { s.OnSubscribe(this); if (s is IConditionalSubscriber <V> ) { Volatile.Write(ref conditional, (IConditionalSubscriber <V>)s); if (Volatile.Read(ref cancelled) != 0) { conditional = null; return; } } else { Volatile.Write(ref regular, s); if (Volatile.Read(ref cancelled) != 0) { regular = null; return; } } Drain(); } else { EmptySubscription <V> .Error(s, new InvalidOperationException("The IGroupedFlux allows only a single ISubscriber!")); } }
/// <inheritDoc/> public void Subscribe(ISubscriber <T> s) { PublishSubscription ps = new PublishSubscription(s, this); s.OnSubscribe(ps); if (subscribers.Add(ps)) { if (ps.IsCancelled()) { subscribers.Remove(ps); } else { Drain(); } } else { var ex = error; if (ex != null) { EmptySubscription <T> .Error(s, ex); } else { EmptySubscription <T> .Complete(s); } } }
public void Subscribe(ISubscriber <T> s) { S state; try { state = stateFactory(); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <T> .Error(s, ex); return; } if (s is IConditionalSubscriber <T> ) { s.OnSubscribe(new GenerateConditionalSubscriber((IConditionalSubscriber <T>)s, state, generator, stateDisposer)); } else { s.OnSubscribe(new GenerateSubscriber(s, state, generator, stateDisposer)); } }
public void Subscribe(ISubscriber <T> s) { IPublisher <T> p; try { p = supplier(); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <T> .Error(s, ex); return; } if (p == null) { EmptySubscription <T> .Error(s, new NullReferenceException("The supplier returned a null IPublisher")); return; } p.Subscribe(s); }
public void Subscribe(ISubscriber <R> s) { IEnumerator <U> enumerator; bool hasValue; try { enumerator = other.GetEnumerator(); hasValue = enumerator.MoveNext(); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <R> .Error(s, ex); return; } if (!hasValue) { EmptySubscription <R> .Complete(s); return; } var parent = new ZipEnumerableSubscriber(s, enumerator, zipper); source.Subscribe(parent); }
public void Subscribe(ISubscriber <T> s) { if (!whenRequested) { EmptySubscription <T> .Error(s, error); } else { s.OnSubscribe(new ErrorSubscription(s, error)); } }
/// <summary> /// Validate that the parallelism of the IParallelFlux equals to the number of elements in /// the ISubscriber array. If not, each ISubscriber is notified with an ArgumentException. /// </summary> /// <typeparam name="T">The element type of the parallel flux</typeparam> /// <typeparam name="U">The element type of the ISubscriber array (could be T or IOrderedItem{T})</typeparam> /// <param name="pf">The parent IParallelFlux instance</param> /// <param name="subscribers">The ISubscriber array</param> /// <returns>True if the subscribers were valid</returns> internal static bool Validate <T, U>(this IParallelFlux <T> pf, ISubscriber <U>[] subscribers) { if (pf.Parallelism != subscribers.Length) { Exception ex = new ArgumentException("Parallelism(" + pf.Parallelism + ") != Subscriber count (" + subscribers.Length + ")"); foreach (ISubscriber <U> s in subscribers) { EmptySubscription <U> .Error(s, ex); } return(false); } return(true); }
public void Subscribe(ISubscriber <T> s) { try { action(); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <T> .Error(s, ex); return; } EmptySubscription <T> .Complete(s); }
public void Subscribe(ISubscriber <R> s) { ISubscriber <T> sr; try { sr = onLift(s); } catch (Exception ex) { EmptySubscription.Error(s, ex); return; } source.Subscribe(sr); }
public void Subscribe(ISubscriber <A> s) { A accumulator; try { accumulator = initialSupplier(); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <A> .Error(s, ex); return; } source.Subscribe(new ScanWithSubscriber(s, accumulator, scanner)); }
public void Subscribe(ISubscriber <T> s) { if (Interlocked.CompareExchange(ref once, 1, 0) == 0) { s.OnSubscribe(this); Volatile.Write(ref actual, s); if (Volatile.Read(ref cancelled)) { actual = null; return; } Drain(); } else { EmptySubscription <T> .Error(s, new InvalidOperationException("The group can be subscribed to at most once")); } }
public static bool ToArray <T, U>(T[] values, IEnumerable <T> valuesEnumerable, ISubscriber <U> s, out int n, out T[] array) { if (values != null) { array = values; n = values.Length; } else { var i = 0; var a = new T[8]; try { foreach (var e in valuesEnumerable) { if (i == a.Length) { var b = new T[i + (i >> 1)]; Array.Copy(a, 0, b, 0, i); a = b; } a[i] = e; i++; } } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <U> .Error(s, ex); array = null; n = 0; return(false); } array = a; n = i; } return(true); }
public void Subscribe(ISubscriber <T> s) { IEnumerator <IPublisher <T> > enumerator; bool hasValue; try { enumerator = sources.GetEnumerator(); hasValue = enumerator.MoveNext(); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <T> .Error(s, ex); return; } if (!hasValue) { EmptySubscription <T> .Complete(s); return; } if (s is IConditionalSubscriber <T> ) { ConcatConditionalSubscriber parent = new ConcatConditionalSubscriber((IConditionalSubscriber <T>)s, enumerator, delayError); s.OnSubscribe(parent); parent.Drain(); } else { ConcatSubscriber parent = new ConcatSubscriber(s, enumerator, delayError); s.OnSubscribe(parent); parent.Drain(); } }
public void Subscribe(ISubscriber <C> s) { C c; try { c = collectionSupplier(); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <C> .Error(s, ex); return; } CollectSubscriber parent = new CollectSubscriber(s, c, collector); source.Subscribe(parent); }
public void Subscribe(ISubscriber <T> s) { int n; IPublisher <T>[] a; if (!MultiSourceHelper.ToArray(sources, sourcesEnumerable, s, out n, out a)) { return; } if (n == 0) { EmptySubscription <T> .Complete(s); return; } else if (n == 1) { a[0].Subscribe(s); return; } if (s is IConditionalSubscriber <T> ) { AmbConditionalSubscription parent = new AmbConditionalSubscription((IConditionalSubscriber <T>)s, n); s.OnSubscribe(parent); parent.Subscribe(a, n); } else { AmbSubscription parent = new AmbSubscription(s, n); s.OnSubscribe(parent); parent.Subscribe(a, n); } }
public void Subscribe(ISubscriber <R> s) { int n; IPublisher <T>[] a; if (!MultiSourceHelper.ToArray(sources, sourcesEnumerable, s, out n, out a)) { return; } if (n == 0) { EmptySubscription <R> .Complete(s); return; } else if (n == 1) { new PublisherMap <T, R>(a[0], v => combiner(new T[] { v })).Subscribe(s); return; } if (s is IConditionalSubscriber <R> ) { CombineLatestConditionalSubscription parent = new CombineLatestConditionalSubscription((IConditionalSubscriber <R>)s, prefetch, delayError, combiner, n); s.OnSubscribe(parent); parent.Subscribe(a, n); } else { CombineLatestSubscription parent = new CombineLatestSubscription(s, prefetch, delayError, combiner, n); s.OnSubscribe(parent); parent.Subscribe(a, n); } }
internal bool TryConnect( IPublisher <T> source, Action <IDisposable> action, Func <IProcessor <T, T> > processorSupplier, Func <IFlux <T>, IPublisher <U> > selector) { if (Volatile.Read(ref done) != 0) { return(false); } if (Interlocked.CompareExchange(ref once, 1, 0) == 0) { try { processor = processorSupplier(); result = selector(Flux.Wrap(processor)); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); Volatile.Write(ref done, 1); foreach (var s in subscribers.Terminate()) { EmptySubscription <U> .Error(s, ex); } return(false); } foreach (var s in subscribers.Terminate()) { result.Subscribe(s); } action?.Invoke(this); source.Subscribe(this); } return(true); }
public void Subscribe(ISubscriber <T> s) { IEnumerator <T> enumerator; bool hasValue; try { enumerator = enumerable.GetEnumerator(); hasValue = enumerator.MoveNext(); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <T> .Error(s, ex); return; } if (!hasValue) { EmptySubscription <T> .Complete(s); return; } if (s is IConditionalSubscriber <T> ) { s.OnSubscribe(new EnumerableConditionalSubscription((IConditionalSubscriber <T>)s, enumerator)); } else { s.OnSubscribe(new EnumerableSubscription(s, enumerator)); } }
/// <inheritdoc/> public void Subscribe(ISubscriber <T> s) { if (Interlocked.CompareExchange(ref once, 1, 0) == 0) { s.OnSubscribe(this); if (s is IConditionalSubscriber <T> ) { Volatile.Write(ref conditional, (IConditionalSubscriber <T>)s); if (lvCancelled()) { conditional = null; } else { Drain(); } } else { Volatile.Write(ref regular, s); if (lvCancelled()) { regular = null; } else { Drain(); } } } else { EmptySubscription <T> .Error(s, new InvalidOperationException("Only a one ISubscriber allowed. Use Publish() or Replay() to share an UnicastProcessor.")); } }
/// <summary> /// Applies shortcuts if the source is the empty instance or an ICallable. /// </summary> /// <param name="source">The source IPublisher.</param> /// <param name="s">The ISubscriber</param> /// <param name="mapper">The function that takes a source value and maps it into an IPublisher.</param> /// <returns>True if the optimizations were applied.</returns> internal static bool CallableXMap(IPublisher <T> source, ISubscriber <R> s, Func <T, IPublisher <R> > mapper) { if (source == PublisherEmpty <T> .Instance) { EmptySubscription <R> .Complete(s); return(true); } if (source is ICallable <T> ) { T t; try { t = (source as ICallable <T>).Value; } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <R> .Error(s, ex); return(true); } IPublisher <R> p; try { p = mapper(t); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <R> .Error(s, ex); return(true); } if (p == null) { EmptySubscription <R> .Error(s, new NullReferenceException("The mapper returned a null IPublisher")); return(true); } if (p == PublisherEmpty <R> .Instance) { EmptySubscription <R> .Complete(s); return(true); } if (p is ICallable <R> ) { R r; try { r = (p as ICallable <R>).Value; } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <R> .Error(s, ex); return(true); } s.OnSubscribe(new ScalarSubscription <R>(s, r)); return(true); } p.Subscribe(s); return(true); } return(false); }
private async Task InitBlockchain() { _specProvider = new ChainSpecBasedSpecProvider(_chainSpec); Account.AccountStartNonce = _chainSpec.Parameters.AccountStartNonce; /* sync */ IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>(); _syncConfig = _configProvider.GetConfig <ISyncConfig>(); foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties()) { if (_logger.IsDebug) { _logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}"); } } _dbProvider = HiveEnabled ? (IDbProvider) new MemDbProvider() : new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts || _syncConfig.DownloadReceiptsInFastSync); _ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager); _txPool = new TxPool( new PersistentTxStorage(_dbProvider.PendingTxsDb, _specProvider), Timestamp.Default, _ethereumEcdsa, _specProvider, _txPoolConfig, _logManager); var _rc7FixDb = _initConfig.EnableRc7Fix ? _dbProvider.HeadersDb : NullDb.Instance; _receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _rc7FixDb, _specProvider, _logManager); // IDbProvider debugRecorder = new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig); // _dbProvider = new RpcDbProvider(_jsonSerializer, new BasicJsonRpcClient(KnownRpcUris.NethVm1, _jsonSerializer, _logManager), _logManager, debugRecorder); // IDbProvider debugReader = new ReadOnlyDbProvider(new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig)); // _dbProvider = debugReader; _blockTree = new BlockTree( _dbProvider.BlocksDb, _dbProvider.HeadersDb, _dbProvider.BlockInfosDb, _specProvider, _txPool, _syncConfig, _logManager); _recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager); CliqueConfig cliqueConfig = null; _snapshotManager = null; switch (_chainSpec.SealEngineType) { case SealEngineType.None: _sealer = NullSealEngine.Instance; _sealValidator = NullSealEngine.Instance; _rewardCalculator = NoBlockRewards.Instance; break; case SealEngineType.Clique: _rewardCalculator = NoBlockRewards.Instance; cliqueConfig = new CliqueConfig(); cliqueConfig.BlockPeriod = _chainSpec.Clique.Period; cliqueConfig.Epoch = _chainSpec.Clique.Epoch; _snapshotManager = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager); _sealValidator = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager); _recoveryStep = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager)); if (_initConfig.IsMining) { _sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager); } else { _sealer = NullSealEngine.Instance; } break; case SealEngineType.NethDev: _sealer = NullSealEngine.Instance; _sealValidator = NullSealEngine.Instance; _rewardCalculator = NoBlockRewards.Instance; break; case SealEngineType.Ethash: _rewardCalculator = new RewardCalculator(_specProvider); var difficultyCalculator = new DifficultyCalculator(_specProvider); if (_initConfig.IsMining) { _sealer = new EthashSealer(new Ethash(_logManager), _logManager); } else { _sealer = NullSealEngine.Instance; } _sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager)); break; default: throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind"); } /* validation */ _headerValidator = new HeaderValidator( _blockTree, _sealValidator, _specProvider, _logManager); var ommersValidator = new OmmersValidator( _blockTree, _headerValidator, _logManager); var txValidator = new TxValidator(_specProvider.ChainId); _blockValidator = new BlockValidator( txValidator, _headerValidator, ommersValidator, _specProvider, _logManager); var stateProvider = new StateProvider( _dbProvider.StateDb, _dbProvider.CodeDb, _logManager); _stateProvider = stateProvider; var storageProvider = new StorageProvider( _dbProvider.StateDb, stateProvider, _logManager); _txPoolInfoProvider = new TxPoolInfoProvider(stateProvider); _transactionPoolInfoProvider = new TxPoolInfoProvider(stateProvider); /* blockchain processing */ var blockhashProvider = new BlockhashProvider( _blockTree, _logManager); var virtualMachine = new VirtualMachine( stateProvider, storageProvider, blockhashProvider, _logManager); var transactionProcessor = new TransactionProcessor( _specProvider, stateProvider, storageProvider, virtualMachine, _logManager); _blockProcessor = new BlockProcessor( _specProvider, _blockValidator, _rewardCalculator, transactionProcessor, _dbProvider.StateDb, _dbProvider.CodeDb, _dbProvider.TraceDb, stateProvider, storageProvider, _txPool, _receiptStorage, _logManager); _blockchainProcessor = new BlockchainProcessor( _blockTree, _blockProcessor, _recoveryStep, _logManager, _initConfig.StoreReceipts, _initConfig.StoreTraces); // create shared objects between discovery and peer manager IStatsConfig statsConfig = _configProvider.GetConfig <IStatsConfig>(); _nodeStatsManager = new NodeStatsManager(statsConfig, _logManager); if (_initConfig.IsMining) { IReadOnlyDbProvider minerDbProvider = new ReadOnlyDbProvider(_dbProvider, false); AlternativeChain producerChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator, _specProvider, minerDbProvider, _recoveryStep, _logManager, _txPool, _receiptStorage); switch (_chainSpec.SealEngineType) { case SealEngineType.Clique: { if (_logger.IsWarn) { _logger.Warn("Starting Clique block producer & sealer"); } _blockProducer = new CliqueBlockProducer(_txPool, producerChain.Processor, _blockTree, _timestamp, _cryptoRandom, producerChain.StateProvider, _snapshotManager, (CliqueSealer)_sealer, _nodeKey.Address, cliqueConfig, _logManager); break; } case SealEngineType.NethDev: { if (_logger.IsWarn) { _logger.Warn("Starting Dev block producer & sealer"); } _blockProducer = new DevBlockProducer(_txPool, producerChain.Processor, _blockTree, _timestamp, _logManager); break; } default: throw new NotSupportedException($"Mining in {_chainSpec.SealEngineType} mode is not supported"); } _blockProducer.Start(); } _blockchainProcessor.Start(); LoadGenesisBlock(_chainSpec, string.IsNullOrWhiteSpace(_initConfig.GenesisHash) ? null : new Keccak(_initConfig.GenesisHash), _blockTree, stateProvider, _specProvider); if (_initConfig.ProcessingEnabled) { #pragma warning disable 4014 LoadBlocksFromDb(); #pragma warning restore 4014 } else { if (_logger.IsWarn) { _logger.Warn($"Shutting down the blockchain processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false"); } await _blockchainProcessor.StopAsync(); } if (HiveEnabled) { await InitHive(); } if (HiveEnabled) { await InitHive(); } var producers = new List <IProducer>(); if (_initConfig.PubSubEnabled) { var kafkaProducer = await PrepareKafkaProducer(_blockTree, _configProvider.GetConfig <IKafkaConfig>()); producers.Add(kafkaProducer); } var grpcClientConfig = _configProvider.GetConfig <IGrpcClientConfig>(); if (grpcClientConfig.Enabled) { var grpcProducer = new GrpcProducer(_grpcClient, _logManager); producers.Add(grpcProducer); } ISubscription subscription; if (producers.Any()) { subscription = new Subscription(producers, _blockProcessor, _logManager); } else { subscription = new EmptySubscription(); } _disposeStack.Push(subscription); _dataBridge = new DataBridge(subscription, _receiptStorage, _blockTree, _logManager); _dataBridge.Start(); await InitializeNetwork(); }
public void Subscribe(ISubscriber <T> s) { S state; try { state = stateFactory(); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); EmptySubscription <T> .Error(s, ex); return; } IPublisher <T> p; try { p = sourceFactory(state); if (p == null) { throw new NullReferenceException("The sourceFactory returned a null IPublisher"); } } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); if (eager) { try { stateDisposer(state); } catch (Exception exc) { ExceptionHelper.ThrowIfFatal(ex); ex = new AggregateException(ex, exc); } } EmptySubscription <T> .Error(s, ex); if (!eager) { try { stateDisposer(state); } catch (Exception exc) { ExceptionHelper.ThrowOrDrop(exc); } } return; } if (s is IConditionalSubscriber <T> ) { p.Subscribe(new UsingConditionalSubscriber((IConditionalSubscriber <T>)s, state, stateDisposer, eager)); } else { p.Subscribe(new UsingSubscriber(s, state, stateDisposer, eager)); } }
public void Subscribe(ISubscriber <T> s) { EmptySubscription <T> .Complete(s); }
private async Task InitBlockchain() { _specProvider = new ChainSpecBasedSpecProvider(_chainSpec); Account.AccountStartNonce = _chainSpec.Parameters.AccountStartNonce; /* sync */ IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>(); _syncConfig = _configProvider.GetConfig <ISyncConfig>(); foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties()) { if (_logger.IsDebug) { _logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}"); } } _dbProvider = HiveEnabled ? (IDbProvider) new MemDbProvider() : new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts || _syncConfig.DownloadReceiptsInFastSync); // IDbProvider debugRecorder = new RocksDbProvider(Path.Combine(_initConfig.BaseDbPath, "debug"), dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts); // _dbProvider = new RpcDbProvider(_jsonSerializer, new BasicJsonRpcClient(KnownRpcUris.Localhost, _jsonSerializer, _logManager), _logManager, debugRecorder); // IDbProvider debugReader = new ReadOnlyDbProvider(new RocksDbProvider(Path.Combine(_initConfig.BaseDbPath, "debug"), dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts), false); // _dbProvider = debugReader; _stateProvider = new StateProvider( _dbProvider.StateDb, _dbProvider.CodeDb, _logManager); _ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager); _txPool = new TxPool( new PersistentTxStorage(_dbProvider.PendingTxsDb, _specProvider), Timestamper.Default, _ethereumEcdsa, _specProvider, _txPoolConfig, _stateProvider, _logManager); var _rc7FixDb = _initConfig.EnableRc7Fix ? _dbProvider.HeadersDb : NullDb.Instance; _receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _rc7FixDb, _specProvider, _logManager); _blockTree = new BlockTree( _dbProvider.BlocksDb, _dbProvider.HeadersDb, _dbProvider.BlockInfosDb, _specProvider, _txPool, _syncConfig, _logManager); _recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager); _snapshotManager = null; _storageProvider = new StorageProvider( _dbProvider.StateDb, _stateProvider, _logManager); IList <IAdditionalBlockProcessor> blockPreProcessors = new List <IAdditionalBlockProcessor>(); // blockchain processing var blockhashProvider = new BlockhashProvider( _blockTree, _logManager); var virtualMachine = new VirtualMachine( _stateProvider, _storageProvider, blockhashProvider, _specProvider, _logManager); _transactionProcessor = new TransactionProcessor( _specProvider, _stateProvider, _storageProvider, virtualMachine, _logManager); InitSealEngine(blockPreProcessors); /* validation */ _headerValidator = new HeaderValidator( _blockTree, _sealValidator, _specProvider, _logManager); var ommersValidator = new OmmersValidator( _blockTree, _headerValidator, _logManager); var txValidator = new TxValidator(_specProvider.ChainId); _blockValidator = new BlockValidator( txValidator, _headerValidator, ommersValidator, _specProvider, _logManager); _txPoolInfoProvider = new TxPoolInfoProvider(_stateProvider, _txPool); _blockProcessor = new BlockProcessor( _specProvider, _blockValidator, _rewardCalculator, _transactionProcessor, _dbProvider.StateDb, _dbProvider.CodeDb, _dbProvider.TraceDb, _stateProvider, _storageProvider, _txPool, _receiptStorage, _logManager, blockPreProcessors); _blockchainProcessor = new BlockchainProcessor( _blockTree, _blockProcessor, _recoveryStep, _logManager, _initConfig.StoreReceipts, _initConfig.StoreTraces); // create shared objects between discovery and peer manager IStatsConfig statsConfig = _configProvider.GetConfig <IStatsConfig>(); _nodeStatsManager = new NodeStatsManager(statsConfig, _logManager); InitBlockProducers(); _blockchainProcessor.Start(); LoadGenesisBlock(string.IsNullOrWhiteSpace(_initConfig.GenesisHash) ? null : new Keccak(_initConfig.GenesisHash)); if (_initConfig.ProcessingEnabled) { #pragma warning disable 4014 RunBlockTreeInitTasks(); #pragma warning restore 4014 } else { if (_logger.IsWarn) { _logger.Warn($"Shutting down the blockchain processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false"); } await _blockchainProcessor.StopAsync(); } if (HiveEnabled) { await InitHive(); } var producers = new List <IProducer>(); var kafkaConfig = _configProvider.GetConfig <IKafkaConfig>(); if (kafkaConfig.Enabled) { var kafkaProducer = await PrepareKafkaProducer(_blockTree, _configProvider.GetConfig <IKafkaConfig>()); producers.Add(kafkaProducer); } var grpcConfig = _configProvider.GetConfig <IGrpcConfig>(); if (grpcConfig.Enabled && grpcConfig.ProducerEnabled) { var grpcProducer = new GrpcProducer(_grpcServer); producers.Add(grpcProducer); } ISubscription subscription; if (producers.Any()) { subscription = new Subscription(producers, _blockProcessor, _logManager); } else { subscription = new EmptySubscription(); } _disposeStack.Push(subscription); await InitializeNetwork(); }