public BloomMigration(EthereumRunnerContext context) { _context = context; _logger = context.LogManager.GetClassLogger <BloomMigration>(); _bloomConfig = context.Config <IBloomConfig>(); }
private async Task Initialize() { if (_context.DbProvider == null) { throw new StepDependencyException(nameof(_context.DbProvider)); } if (_context.BlockTree == null) { throw new StepDependencyException(nameof(_context.BlockTree)); } if (_context.ReceiptStorage == null) { throw new StepDependencyException(nameof(_context.ReceiptStorage)); } if (_context.BlockValidator == null) { throw new StepDependencyException(nameof(_context.BlockValidator)); } if (_context.SealValidator == null) { throw new StepDependencyException(nameof(_context.SealValidator)); } if (_context.Enode == null) { throw new StepDependencyException(nameof(_context.Enode)); } if (_networkConfig.DiagTracerEnabled) { NetworkDiagTracer.IsEnabled = true; NetworkDiagTracer.Start(); } // Environment.SetEnvironmentVariable("io.netty.allocator.pageSize", "8192"); Environment.SetEnvironmentVariable("io.netty.allocator.maxOrder", _networkConfig.NettyArenaOrder.ToString()); int maxPeersCount = _networkConfig.ActivePeersMaxCount; _context.SyncPeerPool = new EthSyncPeerPool(_context.BlockTree, _context.NodeStatsManager, maxPeersCount, _context.LogManager); _context.DisposeStack.Push(_context.SyncPeerPool); NodeDataFeed feed = new NodeDataFeed(_context.DbProvider.CodeDb, _context.DbProvider.StateDb, _context.LogManager); NodeDataDownloader nodeDataDownloader = new NodeDataDownloader(_context.SyncPeerPool, feed, _context.NodeDataConsumer, _context.LogManager); _context.Synchronizer = new Synchronizer(_context.SpecProvider, _context.BlockTree, _context.ReceiptStorage, _context.BlockValidator, _context.SealValidator, _context.SyncPeerPool, _context.Config <ISyncConfig>(), nodeDataDownloader, _context.NodeStatsManager, _context.LogManager); _context.DisposeStack.Push(_context.Synchronizer); _context.SyncServer = new SyncServer( _context.DbProvider.StateDb, _context.DbProvider.CodeDb, _context.BlockTree, _context.ReceiptStorage, _context.BlockValidator, _context.SealValidator, _context.SyncPeerPool, _context.Synchronizer, _context.Config <ISyncConfig>(), _context.LogManager); InitDiscovery(); await InitPeer().ContinueWith(initPeerTask => { if (initPeerTask.IsFaulted) { _logger.Error("Unable to init the peer manager.", initPeerTask.Exception); } }); await StartSync().ContinueWith(initNetTask => { if (initNetTask.IsFaulted) { _logger.Error("Unable to start the synchronizer.", initNetTask.Exception); } }); await StartDiscovery().ContinueWith(initDiscoveryTask => { if (initDiscoveryTask.IsFaulted) { _logger.Error("Unable to start the discovery protocol.", initDiscoveryTask.Exception); } }); try { StartPeer(); } catch (Exception e) { _logger.Error("Unable to start the peer manager.", e); } ThisNodeInfo.AddInfo("Ethereum :", $"tcp://{_context.Enode.HostIp}:{_context.Enode.Port}"); ThisNodeInfo.AddInfo("Version :", $"{ClientVersion.Description.Replace("Nethermind/v", string.Empty)}"); ThisNodeInfo.AddInfo("This node :", $"{_context.Enode.Info}"); ThisNodeInfo.AddInfo("Node address :", $"{_context.Enode.Address} (do not use as an account)"); }
private async Task Initialize(CancellationToken cancellationToken) { if (_ctx.DbProvider == null) { throw new StepDependencyException(nameof(_ctx.DbProvider)); } if (_ctx.BlockTree == null) { throw new StepDependencyException(nameof(_ctx.BlockTree)); } if (_ctx.ReceiptStorage == null) { throw new StepDependencyException(nameof(_ctx.ReceiptStorage)); } if (_ctx.BlockValidator == null) { throw new StepDependencyException(nameof(_ctx.BlockValidator)); } if (_ctx.SealValidator == null) { throw new StepDependencyException(nameof(_ctx.SealValidator)); } if (_ctx.Enode == null) { throw new StepDependencyException(nameof(_ctx.Enode)); } if (_networkConfig.DiagTracerEnabled) { NetworkDiagTracer.IsEnabled = true; NetworkDiagTracer.Start(); } ThisNodeInfo.AddInfo("Mem est netty:", $"{NettyMemoryEstimator.Estimate((uint)Environment.ProcessorCount, _networkConfig.NettyArenaOrder) / 1000 / 1000}MB".PadLeft(8)); ThisNodeInfo.AddInfo("Mem est peers:", $"{_networkConfig.ActivePeersMaxCount}MB".PadLeft(8)); Environment.SetEnvironmentVariable("io.netty.allocator.maxOrder", _networkConfig.NettyArenaOrder.ToString()); var cht = new CanonicalHashTrie(_ctx.DbProvider.ChtDb); int maxPeersCount = _networkConfig.ActivePeersMaxCount; _ctx.SyncPeerPool = new SyncPeerPool(_ctx.BlockTree, _ctx.NodeStatsManager, maxPeersCount, _ctx.LogManager); _ctx.DisposeStack.Push(_ctx.SyncPeerPool); SyncProgressResolver syncProgressResolver = new SyncProgressResolver(_ctx.BlockTree, _ctx.ReceiptStorage, _ctx.DbProvider.StateDb, _ctx.DbProvider.BeamStateDb, _syncConfig, _ctx.LogManager); MultiSyncModeSelector syncModeSelector = new MultiSyncModeSelector(syncProgressResolver, _ctx.SyncPeerPool, _syncConfig, _ctx.LogManager); if (_ctx.SyncModeSelector != null) { // this is really bad and is a result of lack of proper dependency management PendingSyncModeSelector pendingOne = (PendingSyncModeSelector)_ctx.SyncModeSelector; pendingOne.SetActual(syncModeSelector); } _ctx.SyncModeSelector = syncModeSelector; _ctx.DisposeStack.Push(syncModeSelector); _ctx.Synchronizer = new Synchronizer( _ctx.DbProvider, _ctx.SpecProvider, _ctx.BlockTree, _ctx.ReceiptStorage, _ctx.BlockValidator, _ctx.SealValidator, _ctx.SyncPeerPool, _ctx.NodeStatsManager, _ctx.SyncModeSelector, _syncConfig, _ctx.LogManager); _ctx.DisposeStack.Push(_ctx.Synchronizer); _ctx.SyncServer = new SyncServer( _ctx.DbProvider.StateDb, _ctx.DbProvider.CodeDb, _ctx.BlockTree, _ctx.ReceiptStorage, _ctx.BlockValidator, _ctx.SealValidator, _ctx.SyncPeerPool, _ctx.SyncModeSelector, _ctx.Config <ISyncConfig>(), _ctx.LogManager, cht); _ = _ctx.SyncServer.BuildCHT(); _ctx.DisposeStack.Push(_ctx.SyncServer); InitDiscovery(); if (cancellationToken.IsCancellationRequested) { return; } await InitPeer().ContinueWith(initPeerTask => { if (initPeerTask.IsFaulted) { _logger.Error("Unable to init the peer manager.", initPeerTask.Exception); } }); if (cancellationToken.IsCancellationRequested) { return; } await StartSync().ContinueWith(initNetTask => { if (initNetTask.IsFaulted) { _logger.Error("Unable to start the synchronizer.", initNetTask.Exception); } }); if (cancellationToken.IsCancellationRequested) { return; } await StartDiscovery().ContinueWith(initDiscoveryTask => { if (initDiscoveryTask.IsFaulted) { _logger.Error("Unable to start the discovery protocol.", initDiscoveryTask.Exception); } }); try { if (cancellationToken.IsCancellationRequested) { return; } StartPeer(); } catch (Exception e) { _logger.Error("Unable to start the peer manager.", e); } ThisNodeInfo.AddInfo("Ethereum :", $"tcp://{_ctx.Enode.HostIp}:{_ctx.Enode.Port}"); ThisNodeInfo.AddInfo("Version :", $"{ClientVersion.Description.Replace("Nethermind/v", string.Empty)}"); ThisNodeInfo.AddInfo("This node :", $"{_ctx.Enode.Info}"); ThisNodeInfo.AddInfo("Node address :", $"{_ctx.Enode.Address} (do not use as an account)"); }
public InitializeNetwork(EthereumRunnerContext context) { _context = context; _logger = _context.LogManager.GetClassLogger(); _networkConfig = _context.Config <INetworkConfig>(); }
private Task InitBlockchain() { if (_context.ChainSpec == null) { throw new StepDependencyException(nameof(_context.ChainSpec)); } if (_context.DbProvider == null) { throw new StepDependencyException(nameof(_context.DbProvider)); } if (_context.SpecProvider == null) { throw new StepDependencyException(nameof(_context.SpecProvider)); } ILogger logger = _context.LogManager.GetClassLogger(); IInitConfig initConfig = _context.Config <IInitConfig>(); ISyncConfig syncConfig = _context.Config <ISyncConfig>(); if (syncConfig.DownloadReceiptsInFastSync && !syncConfig.DownloadBodiesInFastSync) { logger.Warn($"{nameof(syncConfig.DownloadReceiptsInFastSync)} is selected but {nameof(syncConfig.DownloadBodiesInFastSync)} - enabling bodies to support receipts download."); syncConfig.DownloadBodiesInFastSync = true; } Account.AccountStartNonce = _context.ChainSpec.Parameters.AccountStartNonce; _context.StateProvider = new StateProvider( _context.DbProvider.StateDb, _context.DbProvider.CodeDb, _context.LogManager); _context.EthereumEcdsa = new EthereumEcdsa(_context.SpecProvider, _context.LogManager); _context.TxPool = new TxPool.TxPool( new PersistentTxStorage(_context.DbProvider.PendingTxsDb, _context.SpecProvider), Timestamper.Default, _context.EthereumEcdsa, _context.SpecProvider, _context.Config <ITxPoolConfig>(), _context.StateProvider, _context.LogManager); var bloomConfig = _context.Config <IBloomConfig>(); var fileStoreFactory = initConfig.DiagnosticMode == DiagnosticMode.MemDb ? (IFileStoreFactory) new InMemoryDictionaryFileStoreFactory() : new FixedSizeFileStoreFactory(Path.Combine(initConfig.BaseDbPath, DbNames.Bloom), DbNames.Bloom, Bloom.ByteLength); _context.BloomStorage = bloomConfig.Index ? new BloomStorage(bloomConfig, _context.DbProvider.BloomDb, fileStoreFactory) : (IBloomStorage)NullBloomStorage.Instance; _context.DisposeStack.Push(_context.BloomStorage); _context.ChainLevelInfoRepository = new ChainLevelInfoRepository(_context.DbProvider.BlockInfosDb); _context.BlockTree = new BlockTree( _context.DbProvider.BlocksDb, _context.DbProvider.HeadersDb, _context.DbProvider.BlockInfosDb, _context.ChainLevelInfoRepository, _context.SpecProvider, _context.TxPool, _context.BloomStorage, _context.Config <ISyncConfig>(), _context.LogManager); // Init state if we need system calls before actual processing starts if (_context.BlockTree.Head != null) { _context.StateProvider.StateRoot = _context.BlockTree.Head.StateRoot; } _context.ReceiptStorage = initConfig.StoreReceipts ? (IReceiptStorage?)new PersistentReceiptStorage(_context.DbProvider.ReceiptsDb, _context.SpecProvider, new ReceiptsRecovery()) : NullReceiptStorage.Instance; _context.ReceiptFinder = new FullInfoReceiptFinder(_context.ReceiptStorage, new ReceiptsRecovery(), _context.BlockTree); _context.RecoveryStep = new TxSignaturesRecoveryStep(_context.EthereumEcdsa, _context.TxPool, _context.LogManager); _context.StorageProvider = new StorageProvider( _context.DbProvider.StateDb, _context.StateProvider, _context.LogManager); // blockchain processing BlockhashProvider blockhashProvider = new BlockhashProvider( _context.BlockTree, _context.LogManager); VirtualMachine virtualMachine = new VirtualMachine( _context.StateProvider, _context.StorageProvider, blockhashProvider, _context.SpecProvider, _context.LogManager); _context.TransactionProcessor = new TransactionProcessor( _context.SpecProvider, _context.StateProvider, _context.StorageProvider, virtualMachine, _context.LogManager); InitSealEngine(); if (_context.SealValidator == null) { throw new StepDependencyException(nameof(_context.SealValidator)); } /* validation */ _context.HeaderValidator = CreateHeaderValidator(); OmmersValidator ommersValidator = new OmmersValidator( _context.BlockTree, _context.HeaderValidator, _context.LogManager); TxValidator txValidator = new TxValidator(_context.SpecProvider.ChainId); _context.BlockValidator = new BlockValidator( txValidator, _context.HeaderValidator, ommersValidator, _context.SpecProvider, _context.LogManager); ReadOnlyDbProvider readOnly = new ReadOnlyDbProvider(_context.DbProvider, false); StateReader stateReader = new StateReader(readOnly.StateDb, readOnly.CodeDb, _context.LogManager); _context.TxPoolInfoProvider = new TxPoolInfoProvider(stateReader, _context.TxPool); _context.MainBlockProcessor = CreateBlockProcessor(); BlockchainProcessor blockchainProcessor = new BlockchainProcessor( _context.BlockTree, _context.MainBlockProcessor, _context.RecoveryStep, _context.LogManager, initConfig.StoreReceipts, !syncConfig.BeamSync); _context.BlockProcessingQueue = blockchainProcessor; _context.BlockchainProcessor = blockchainProcessor; if (syncConfig.BeamSync) { BeamBlockchainProcessor beamBlockchainProcessor = new BeamBlockchainProcessor( new ReadOnlyDbProvider(_context.DbProvider, false), _context.BlockTree, _context.SpecProvider, _context.LogManager, _context.BlockValidator, _context.RecoveryStep, _context.RewardCalculatorSource, _context.BlockProcessingQueue, _context.BlockchainProcessor, _context.SyncModeSelector); _context.DisposeStack.Push(beamBlockchainProcessor); } ThisNodeInfo.AddInfo("Mem est trie :", $"{LruCache<Keccak, byte[]>.CalculateMemorySize(52 + 320, Trie.MemoryAllowance.TrieNodeCacheSize) / 1024 / 1024}MB".PadLeft(8)); return(Task.CompletedTask); }
public virtual Task Execute() { if (_context.RpcModuleProvider == null) { throw new StepDependencyException(nameof(_context.RpcModuleProvider)); } ILogger logger = _context.LogManager.GetClassLogger(); IJsonRpcConfig jsonRpcConfig = _context.Config <IJsonRpcConfig>(); if (!jsonRpcConfig.Enabled) { return(Task.CompletedTask); } // the following line needs to be called in order to make sure that the CLI library is referenced from runner and built alongside if (logger.IsDebug) { logger.Debug($"Resolving CLI ({nameof(CliModuleLoader)})"); } IInitConfig initConfig = _context.Config <IInitConfig>(); INdmConfig ndmConfig = _context.Config <INdmConfig>(); IJsonRpcConfig rpcConfig = _context.Config <IJsonRpcConfig>(); INetworkConfig networkConfig = _context.Config <INetworkConfig>(); if (ndmConfig.Enabled && !(_context.NdmInitializer is null) && ndmConfig.ProxyEnabled) { EthModuleProxyFactory proxyFactory = new EthModuleProxyFactory(_context.EthJsonRpcClientProxy, _context.Wallet); _context.RpcModuleProvider.Register(new SingletonModulePool <IEthModule>(proxyFactory, true)); if (logger.IsInfo) { logger.Info("Enabled JSON RPC Proxy for NDM."); } } else { EthModuleFactory ethModuleFactory = new EthModuleFactory(_context.DbProvider, _context.TxPool, _context.Wallet, _context.BlockTree, _context.EthereumEcdsa, _context.MainBlockProcessor, _context.ReceiptFinder, _context.SpecProvider, rpcConfig, _context.BloomStorage, _context.LogManager, initConfig.IsMining); _context.RpcModuleProvider.Register(new BoundedModulePool <IEthModule>(8, ethModuleFactory)); } ProofModuleFactory proofModuleFactory = new ProofModuleFactory(_context.DbProvider, _context.BlockTree, _context.RecoveryStep, _context.ReceiptFinder, _context.SpecProvider, _context.LogManager); _context.RpcModuleProvider.Register(new BoundedModulePool <IProofModule>(2, proofModuleFactory)); DebugModuleFactory debugModuleFactory = new DebugModuleFactory(_context.DbProvider, _context.BlockTree, _context.BlockValidator, _context.RecoveryStep, _context.RewardCalculatorSource, _context.ReceiptStorage, _context.ConfigProvider, _context.SpecProvider, _context.LogManager); _context.RpcModuleProvider.Register(new BoundedModulePool <IDebugModule>(8, debugModuleFactory)); TraceModuleFactory traceModuleFactory = new TraceModuleFactory(_context.DbProvider, _context.BlockTree, _context.RecoveryStep, _context.RewardCalculatorSource, _context.ReceiptStorage, _context.SpecProvider, _context.LogManager); _context.RpcModuleProvider.Register(new BoundedModulePool <ITraceModule>(8, traceModuleFactory)); if (initConfig.EnableUnsecuredDevWallet) { PersonalBridge personalBridge = new PersonalBridge(_context.EthereumEcdsa, _context.Wallet); PersonalModule personalModule = new PersonalModule(personalBridge, _context.LogManager); _context.RpcModuleProvider.Register(new SingletonModulePool <IPersonalModule>(personalModule, true)); } AdminModule adminModule = new AdminModule(_context.BlockTree, networkConfig, _context.PeerManager, _context.StaticNodesManager, _context.Enode, initConfig.BaseDbPath); _context.RpcModuleProvider.Register(new SingletonModulePool <IAdminModule>(adminModule, true)); TxPoolModule txPoolModule = new TxPoolModule(_context.BlockTree, _context.TxPoolInfoProvider, _context.LogManager); _context.RpcModuleProvider.Register(new SingletonModulePool <ITxPoolModule>(txPoolModule, true)); NetModule netModule = new NetModule(_context.LogManager, new NetBridge(_context.Enode, _context.SyncServer)); _context.RpcModuleProvider.Register(new SingletonModulePool <INetModule>(netModule, true)); ParityModule parityModule = new ParityModule(_context.EthereumEcdsa, _context.TxPool, _context.BlockTree, _context.ReceiptFinder, _context.LogManager); _context.RpcModuleProvider.Register(new SingletonModulePool <IParityModule>(parityModule, true)); SubsystemStateChanged?.Invoke(this, new SubsystemStateEventArgs(EthereumSubsystemState.Running)); return(Task.CompletedTask); }
public async Task Execute() { IEthStatsConfig ethStatsConfig = _context.Config <IEthStatsConfig>(); if (!ethStatsConfig.Enabled) { return; } INetworkConfig networkConfig = _context.Config <INetworkConfig>(); SubsystemStateChanged?.Invoke(this, new SubsystemStateEventArgs(EthereumSubsystemState.Initializing)); if (_context.Enode == null) { throw new StepDependencyException(nameof(_context.Enode)); } if (_context.SpecProvider == null) { throw new StepDependencyException(nameof(_context.SpecProvider)); } string instanceId = $"{ethStatsConfig.Name}-{Keccak.Compute(_context.Enode.Info)}"; if (_logger.IsInfo) { _logger.Info($"Initializing ETH Stats for the instance: {instanceId}, server: {ethStatsConfig.Server}"); } MessageSender sender = new MessageSender(instanceId, _context.LogManager); const int reconnectionInterval = 5000; const string api = "no"; const string client = "0.1.1"; const bool canUpdateHistory = false; string node = ClientVersion.Description ?? string.Empty; int port = networkConfig.P2PPort; string network = _context.SpecProvider.ChainId.ToString(); string protocol = "eth/65"; EthStatsClient ethStatsClient = new EthStatsClient( ethStatsConfig.Server, reconnectionInterval, sender, _context.LogManager); EthStatsIntegration ethStatsIntegration = new EthStatsIntegration( ethStatsConfig.Name, node, port, network, protocol, api, client, ethStatsConfig.Contact, canUpdateHistory, ethStatsConfig.Secret, ethStatsClient, sender, _context.BlockTree, _context.PeerManager, _context.LogManager); await ethStatsIntegration.InitAsync(); _context.DisposeStack.Push(ethStatsIntegration); // TODO: handle failure SubsystemStateChanged?.Invoke(this, new SubsystemStateEventArgs(EthereumSubsystemState.Running)); }
public DatabaseMigrations(EthereumRunnerContext context) { _context = context; _logger = context.LogManager.GetClassLogger(); _bloomConfig = context.Config <IBloomConfig>(); }