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>();
}
