public FileKeyStore(IConfigProvider configurationProvider, IJsonSerializer jsonSerializer, ISymmetricEncrypter symmetricEncrypter, ICryptoRandom cryptoRandom, ILogManager logManager)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_config = configurationProvider?.GetConfig <IKeystoreConfig>() ?? throw new ArgumentNullException(nameof(configurationProvider));
_jsonSerializer = jsonSerializer ?? throw new ArgumentNullException(nameof(jsonSerializer));
_symmetricEncrypter = symmetricEncrypter ?? throw new ArgumentNullException(nameof(symmetricEncrypter));
_cryptoRandom = cryptoRandom ?? throw new ArgumentNullException(nameof(cryptoRandom));
_keyStoreEncoding = Encoding.GetEncoding(_config.KeyStoreEncoding);
_privateKeyGenerator = new PrivateKeyGenerator(_cryptoRandom);
}
public async Task <Dictionary <RestoredDependencyPair, SharedConfig> > CollectDependencies()
{
var config = configProvider.GetConfig();
if (config is null)
{
throw new ConfigException(Resources.ConfigNotFound);
}
if (config.Info is null)
{
throw new ConfigException(Resources.ConfigInfoIsNull);
}
var myDependencies = new Dictionary <RestoredDependencyPair, SharedConfig>();
foreach (var d in config.Dependencies)
{
await CollectDependencies(config.Info.Id, myDependencies, new RestoredDependencyPair { Dependency = d }).ConfigureAwait(false);
}
// Call post dependency resolution code
OnDependenciesCollected?.Invoke(this, myDependencies);
return(myDependencies);
}
public WitAdminProcessService(string argument, IConfigProvider configProvider)
{
var workingDirectory = configProvider.GetConfig("witAdminExecutableAddress");
var witAdminPath = string.Format("{0}\\{1}", workingDirectory, WitAdminExecFileName);
ProcessStartInfo startInfo = new ProcessStartInfo(witAdminPath)
{
Arguments = argument,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
Verb = "runas",
CreateNoWindow = true
};
Process process = new Process()
{
StartInfo = startInfo
};
process.OutputDataReceived += ((sender, e) =>
{
if (e.Data != null)
{
_output.AppendLine(e.Data);
_splitedOutput.Add(e.Data);
}
});
process.ErrorDataReceived += ((sender, e) =>
{
if (e.Data != null)
{
_error.AppendLine(e.Data);
}
});
_process = process;
}
/// <summary>
/// 发送远程请求
/// </summary>
/// <param name="arrMethodArgs"></param>
/// <param name="argmentTypes"></param>
/// <param name="methodInfo"></param>
/// <returns></returns>
public object DoMethodCall(object[] arrMethodArgs, Type[] argmentTypes, MethodInfo methodInfo)
{
var rpcMonitorRequestInfo = new RpcMonitorRequestInfo(methodInfo, argmentTypes?.Length ?? 0);
try
{
var requestInfo = Create(arrMethodArgs, argmentTypes, methodInfo);
var client = RemotingClientFactory.GetClient(_proxyType);
var response = client.InvokeSync(requestInfo, _configProvider.GetConfig().RequestTimeouMillis);
var result = HandleResponse(response, methodInfo);
return(result);
}
catch
{
rpcMonitorRequestInfo.IsSuccess = false;
throw;
}
finally
{
rpcMonitorRequestInfo.RequestEndTime = DateTime.Now;
_rpcMonitor.AddRpcRequest(rpcMonitorRequestInfo);
}
}
public void Proof_module_is_registered_if_configured()
{
JsonRpcConfig jsonRpcConfig = new JsonRpcConfig();
jsonRpcConfig.Enabled = true;
IConfigProvider configProvider = Substitute.For <IConfigProvider>();
configProvider.GetConfig <IJsonRpcConfig>().Returns(jsonRpcConfig);
IRpcModuleProvider rpcModuleProvider = Substitute.For <IRpcModuleProvider>();
EthereumRunnerContext context = Build.ContextWithMocks();
context.ConfigProvider = configProvider;
context.RpcModuleProvider = rpcModuleProvider;
RegisterRpcModules registerRpcModules = new RegisterRpcModules(context);
registerRpcModules.Execute(CancellationToken.None);
rpcModuleProvider.ReceivedWithAnyArgs().Register <IProofModule>(null);
}
public void Proof_module_is_not_registered_when_json_rpc_not_enabled()
{
JsonRpcConfig jsonRpcConfig = new JsonRpcConfig();
jsonRpcConfig.Enabled = false;
IConfigProvider configProvider = Substitute.For <IConfigProvider>();
configProvider.GetConfig <IJsonRpcConfig>().Returns(jsonRpcConfig);
IRpcModuleProvider rpcModuleProvider = Substitute.For <IRpcModuleProvider>();
EthereumRunnerContext context = new EthereumRunnerContext(configProvider, LimboLogs.Instance);
context.ConfigProvider = configProvider;
context.RpcModuleProvider = rpcModuleProvider;
RegisterRpcModules registerRpcModules = new RegisterRpcModules(context);
registerRpcModules.Execute();
rpcModuleProvider.DidNotReceiveWithAnyArgs().Register <IProofModule>(null);
}
PreInitAsync(
IConfigProvider configProvider,
IDbProvider dbProvider,
string baseDbPath,
IBlockTree blockTree,
ITxPool txPool,
ITxSender txSender,
ISpecProvider specProvider,
IReceiptFinder receiptFinder,
IWallet wallet,
IFilterStore filterStore,
IFilterManager filterManager,
ITimestamper timestamper,
IEthereumEcdsa ecdsa,
IRpcModuleProvider rpcModuleProvider,
IKeyStore keyStore,
IJsonSerializer jsonSerializer,
ICryptoRandom cryptoRandom,
IEnode enode,
INdmConsumerChannelManager consumerChannelManager,
INdmDataPublisher dataPublisher,
IGrpcServer grpcServer,
bool enableUnsecuredDevWallet,
IWebSocketsManager webSocketsManager,
ILogManager logManager,
IBlockProcessor blockProcessor,
IJsonRpcClientProxy?jsonRpcClientProxy,
IEthJsonRpcClientProxy?ethJsonRpcClientProxy,
IHttpClient httpClient,
IMonitoringService monitoringService,
IBloomStorage bloomStorage)
{
// what is block processor doing here?
if (!(configProvider.GetConfig <INdmConfig>() is NdmConfig defaultConfig))
{
return(default);
public DiscoveryApp(
INodesLocator nodesLocator,
IDiscoveryManager discoveryManager,
INodeFactory nodeFactory,
INodeTable nodeTable,
IMessageSerializationService messageSerializationService,
ICryptoRandom cryptoRandom,
INetworkStorage discoveryStorage,
IConfigProvider configurationProvider,
ILogManager logManager, IPerfService perfService)
{
_logManager = logManager;
_perfService = perfService;
_logger = _logManager.GetClassLogger();
_configurationProvider = configurationProvider.GetConfig <INetworkConfig>();
_nodesLocator = nodesLocator;
_discoveryManager = discoveryManager;
_nodeFactory = nodeFactory;
_nodeTable = nodeTable;
_messageSerializationService = messageSerializationService;
_cryptoRandom = cryptoRandom;
_discoveryStorage = discoveryStorage;
_discoveryStorage.StartBatch();
}
public EthereumRunnerContextFactory(IConfigProvider configProvider, IJsonSerializer ethereumJsonSerializer, ILogManager logManager)
{
_configProvider = configProvider;
_logManager = logManager;
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
ILogger logger = _logManager.GetClassLogger();
if (logger.IsDebug)
{
logger.Debug($"Loading chain spec from {initConfig.ChainSpecPath}");
}
ThisNodeInfo.AddInfo("Chainspec :", $"{initConfig.ChainSpecPath}");
IChainSpecLoader loader = new ChainSpecLoader(ethereumJsonSerializer);
ChainSpec chainSpec = loader.LoadFromFile(initConfig.ChainSpecPath);
logManager.SetGlobalVariable("chain", chainSpec.Name);
logManager.SetGlobalVariable("chainId", chainSpec.ChainId);
logManager.SetGlobalVariable("engine", chainSpec.SealEngineType);
Context = Create(chainSpec.SealEngineType);
Context.ChainSpec = chainSpec;
Context.SpecProvider = new ChainSpecBasedSpecProvider(Context.ChainSpec);
}
private Task InitDiscovery(InitParams initParams)
{
_logger.Info("Initializing Discovery");
if (initParams.DiscoveryPort.HasValue)
{
_configProvider.GetConfig <NetworkConfig>().MasterPort = initParams.DiscoveryPort.Value;
}
var privateKeyProvider = new PrivateKeyProvider(_privateKey);
var discoveryMessageFactory = new DiscoveryMessageFactory(_configProvider);
var nodeIdResolver = new NodeIdResolver(_signer);
var msgSerializersProvider = new DiscoveryMsgSerializersProvider(_messageSerializationService, _signer, privateKeyProvider, discoveryMessageFactory, nodeIdResolver, _nodeFactory);
msgSerializersProvider.RegisterDiscoverySerializers();
var nodeDistanceCalculator = new NodeDistanceCalculator(_configProvider);
var nodeTable = new NodeTable(_nodeFactory, _keyStore, nodeDistanceCalculator, _configProvider, _logManager);
var evictionManager = new EvictionManager(nodeTable, _logManager);
var nodeLifeCycleFactory = new NodeLifecycleManagerFactory(_nodeFactory, nodeTable, discoveryMessageFactory, evictionManager, _nodeStatsProvider, _configProvider, _logManager);
var discoveryStorage = new DiscoveryStorage(_configProvider, _nodeFactory, _logManager, _perfService);
_discoveryManager = new DiscoveryManager(nodeLifeCycleFactory, _nodeFactory, nodeTable, discoveryStorage, _configProvider, _logManager);
var nodesLocator = new NodesLocator(nodeTable, _discoveryManager, _configProvider, _logManager);
_discoveryApp = new DiscoveryApp(nodesLocator, _discoveryManager, _nodeFactory, nodeTable, _messageSerializationService, _cryptoRandom, discoveryStorage, _configProvider, _logManager);
_discoveryApp.Start(_privateKey.PublicKey);
_logger.Info("Discovery initialization completed");
return(Task.CompletedTask);
}
public WitAdminProcessService(string argument, IConfigProvider configProvider)
{
var workingDirectory = configProvider.GetConfig("witAdminExecutableAddress");
var witAdminPath = string.Format("{0}\\{1}", workingDirectory, WitAdminExecFileName);
ProcessStartInfo startInfo = new ProcessStartInfo(witAdminPath)
{
Arguments = argument,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
Verb = "runas",
CreateNoWindow = true
};
Process process = new Process()
{
StartInfo = startInfo
};
process.OutputDataReceived += ((sender, e) =>
{
if (e.Data != null)
{
_output.AppendLine(e.Data);
_splitedOutput.Add(e.Data);
}
});
process.ErrorDataReceived += ((sender, e) =>
{
if (e.Data != null)
_error.AppendLine(e.Data);
});
_process = process;
}
protected ModuleBase(IConfigProvider configurationProvider, ILogManager logManager, IJsonSerializer jsonSerializer)
{
JsonSerializer = jsonSerializer;
Logger = logManager.GetClassLogger();
JsonRpcConfig = configurationProvider.GetConfig <IJsonRpcConfig>();
}
protected async Task StartRunners(IConfigProvider configProvider)
{
try
{
var initParams = configProvider.GetConfig <IInitConfig>();
var logManager = new NLogManager(initParams.LogFileName, initParams.LogDirectory);
//discovering and setting local, remote ips for client machine
var networkHelper = new NetworkHelper(Logger);
var localHost = networkHelper.GetLocalIp()?.ToString() ?? "127.0.0.1";
var networkConfig = configProvider.GetConfig <INetworkConfig>();
networkConfig.MasterExternalIp = localHost;
networkConfig.MasterHost = localHost;
ChainSpecLoader chainSpecLoader = new ChainSpecLoader(new UnforgivingJsonSerializer());
string path = initParams.ChainSpecPath;
if (!Path.IsPathRooted(path))
{
path = Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, path));
}
byte[] chainSpecData = File.ReadAllBytes(path);
ChainSpec chainSpec = chainSpecLoader.Load(chainSpecData);
var nodes = chainSpec.NetworkNodes.Select(nn => GetNode(nn, localHost)).ToArray();
networkConfig.BootNodes = nodes;
networkConfig.DbBasePath = initParams.BaseDbPath;
_ethereumRunner = new EthereumRunner(configProvider, networkHelper, logManager);
await _ethereumRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during ethereum runner start", x.Exception);
}
});
if (initParams.JsonRpcEnabled)
{
Bootstrap.Instance.ConfigProvider = configProvider;
Bootstrap.Instance.LogManager = logManager;
Bootstrap.Instance.BlockchainBridge = _ethereumRunner.BlockchainBridge;
Bootstrap.Instance.EthereumSigner = _ethereumRunner.EthereumSigner;
_jsonRpcRunner = new JsonRpcRunner(configProvider, logManager);
await _jsonRpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during jsonRpc runner start", x.Exception);
}
});
}
else
{
if (Logger.IsInfo)
{
Logger.Info("Json RPC is disabled");
}
}
}
catch (Exception e)
{
Logger.Error("Error while starting Nethermind.Runner", e);
throw;
}
}
private static void Generate(string projectFolder, string configPath)
{
// get config
configPath = !string.IsNullOrEmpty(configPath)
? Path.Combine(projectFolder, configPath)
: Path.Combine(projectFolder, "tgconfig.json");
TgConfig config = _configProvider.GetConfig(configPath, projectFolder);
LogConfigWarnings(config);
// register assembly resolver
_assemblyResolver.Directories = config.ExternalAssemblyPaths;
_assemblyResolver.Register();
IEnumerable <Assembly> assemblies = GetAssemblies(config.GetAssemblies()).ToArray();
// create generator
GeneratorOptions generatorOptions = _generatorOptionsProvider.GetGeneratorOptions(config, assemblies, projectFolder);
generatorOptions.BaseOutputDirectory = Path.Combine(projectFolder, config.OutputPath);
var generator = new Generator(generatorOptions, _logger);
// generate
if (config.ClearOutputDirectory == true)
{
_fileSystem.ClearDirectory(generatorOptions.BaseOutputDirectory);
}
if (config.BuildProject == true)
{
_projectBuilder.Build(projectFolder);
}
_logger.Log($"Generating files for project \"{projectFolder}\"...", LogLevel.Info);
var generatedFiles = new List <string>();
if (!config.GenerationSpecs.Any() || config.GenerateFromAssemblies == true)
{
generatedFiles.AddRange(generator.Generate(assemblies));
}
if (config.GenerationSpecs.Any())
{
var typeResolver = new TypeResolver(_logger, _fileSystem, projectFolder, assemblies);
IEnumerable <GenerationSpec> generationSpecs = config.GenerationSpecs
.Select(name => typeResolver.Resolve(name, "GenerationSpec"))
.Where(t => t != null)
.Select(t => (GenerationSpec)Activator.CreateInstance(t))
.ToArray();
generatedFiles.AddRange(generator.Generate(generationSpecs));
}
foreach (string file in generatedFiles)
{
_logger.Log($"Generated {file}", LogLevel.Info);
}
if (config.AddFilesToProject ?? TgConfig.DefaultAddFilesToProject)
{
AddFilesToProject(projectFolder, generatedFiles);
}
// unregister assembly resolver
_assemblyResolver.Unregister();
_logger.Log($"Files for project \"{projectFolder}\" generated successfully.{Environment.NewLine}", LogLevel.Info);
}
public virtual async Task <INdmCapabilityConnector> InitAsync(
IConfigProvider configProvider,
IDbProvider dbProvider,
string baseDbPath,
IBlockTree blockTree,
ITxPool txPool,
ITxSender txSender,
ISpecProvider specProvider,
IReceiptFinder receiptFinder,
IWallet wallet,
IFilterStore filterStore,
IFilterManager filterManager,
ITimestamper timestamper,
IEthereumEcdsa ecdsa,
IRpcModuleProvider rpcModuleProvider,
IKeyStore keyStore,
IJsonSerializer jsonSerializer,
ICryptoRandom cryptoRandom,
IEnode enode,
INdmConsumerChannelManager consumerChannelManager,
INdmDataPublisher dataPublisher,
IGrpcServer grpcServer,
INodeStatsManager nodeStatsManager,
IProtocolsManager protocolsManager,
IProtocolValidator protocolValidator,
IMessageSerializationService messageSerializationService,
bool enableUnsecuredDevWallet,
IWebSocketsManager webSocketsManager,
ILogManager logManager,
IBlockProcessor blockProcessor,
IJsonRpcClientProxy?jsonRpcClientProxy,
IEthJsonRpcClientProxy?ethJsonRpcClientProxy,
IHttpClient httpClient,
IMonitoringService monitoringService,
IBloomStorage bloomStorage)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
INdmConfig ndmConfig = configProvider.GetConfig <INdmConfig>();
if (!ndmConfig.Enabled)
{
// can we not even call it here? // can be step and use the subsystems
return(NullNdmCapabilityConnector.Instance);
}
(NdmConfig config, INdmServices services, INdmFaucet faucet, IEthRequestService ethRequestService, IAccountService accountService, IConsumerService consumerService, Address consumerAddress, Address providerAddress) = await PreInitAsync(
configProvider,
dbProvider,
baseDbPath,
blockTree,
txPool,
txSender,
specProvider,
receiptFinder,
wallet,
filterStore,
filterManager,
timestamper,
ecdsa,
rpcModuleProvider,
keyStore,
jsonSerializer,
cryptoRandom,
enode,
consumerChannelManager,
dataPublisher,
grpcServer,
enableUnsecuredDevWallet,
webSocketsManager,
logManager,
blockProcessor,
jsonRpcClientProxy,
ethJsonRpcClientProxy,
httpClient,
monitoringService,
bloomStorage);
NdmSubprotocolFactory subprotocolFactory = new NdmSubprotocolFactory(messageSerializationService, nodeStatsManager,
logManager, accountService, consumerService, consumerChannelManager, ecdsa, wallet, faucet,
enode.PublicKey, providerAddress, consumerAddress, config.VerifyP2PSignature);
ProtocolHandlerFactory protocolHandlerFactory = new ProtocolHandlerFactory(subprotocolFactory, protocolValidator,
ethRequestService, logManager);
NdmCapabilityConnector capabilityConnector = new NdmCapabilityConnector(
protocolsManager,
protocolHandlerFactory,
accountService,
logManager,
ndmConfig.ProviderAddress == null ? Address.Zero : new Address(ndmConfig.ProviderAddress));
return(capabilityConnector);
}
new protected async Task StartRunners(IConfigProvider configProvider)
{
InitRlp();
_configProvider = configProvider;
_initConfig = _configProvider.GetConfig <IInitConfig>();
_logManager = new NLogManager(_initConfig.LogFileName, _initConfig.LogDirectory);
_logger = _logManager.GetClassLogger();
_networkHelper = new NetworkHelper(_logger);
SetupKeyStore();
LoadChainSpec();
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
_dbProvider = new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts);
var stateProvider = new StateProvider(
_dbProvider.StateDb,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
/* blockchain processing */
if (_chainSpec.ChainId == RopstenSpecProvider.Instance.ChainId)
{
_specProvider = RopstenSpecProvider.Instance;
}
else if (_chainSpec.ChainId == MainNetSpecProvider.Instance.ChainId)
{
_specProvider = MainNetSpecProvider.Instance;
}
else if (_chainSpec.ChainId == RinkebySpecProvider.Instance.ChainId)
{
_specProvider = RinkebySpecProvider.Instance;
}
else if (_chainSpec.ChainId == GoerliSpecProvider.Instance.ChainId)
{
_specProvider = GoerliSpecProvider.Instance;
}
else
{
_specProvider = new SingleReleaseSpecProvider(Latest.Release, _chainSpec.ChainId);
}
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_txPool = new TxPool(
new PersistentTransactionStorage(_dbProvider.PendingTxsDb, _specProvider),
new PendingTransactionThresholdValidator(_initConfig.ObsoletePendingTransactionInterval,
_initConfig.RemovePendingTransactionInterval), new Timestamp(),
_ethereumEcdsa, _specProvider, _logManager, _initConfig.RemovePendingTransactionInterval,
_initConfig.PeerNotificationThreshold);
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _specProvider);
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.HeadersDb,
_dbProvider.BlockInfosDb,
_specProvider,
_txPool,
_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");
}
_headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
_headerValidator,
_logManager);
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
var txValidator = new TxValidator(_specProvider.ChainId);
_blockValidator = new BlockValidator(
txValidator,
_headerValidator,
ommersValidator,
_specProvider,
_logManager);
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,
_configProvider.GetConfig <ISyncConfig>(),
_logManager);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
string chainFile = Path.Join(Path.GetDirectoryName(_initConfig.ChainSpecPath), "chain.rlp");
if (!File.Exists(chainFile))
{
_logger.Info($"Chain file does not exist: {chainFile}, skipping");
return;
}
var chainFileContent = File.ReadAllBytes(chainFile);
var context = new Rlp.DecoderContext(chainFileContent);
var blocks = new List <Block>();
while (context.ReadNumberOfItemsRemaining() > 0)
{
context.PeekNextItem();
blocks.Add(Rlp.Decode <Block>(context));
}
for (int i = 0; i < blocks.Count; i++)
{
ProcessBlock(blocks[i]);
}
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IJsonRpcProcessor jsonRpcProcessor, IJsonRpcService jsonRpcService)
{
_jsonSerializer = CreateJsonSerializer();
foreach (JsonConverter converter in jsonRpcService.Converters)
{
_jsonSerializer.RegisterConverter(converter);
}
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseCors("Cors");
IConfigProvider configProvider = app.ApplicationServices.GetService <IConfigProvider>();
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
IJsonRpcConfig jsonRpcConfig = configProvider.GetConfig <IJsonRpcConfig>();
if (initConfig.WebSocketsEnabled)
{
app.UseWebSockets();
app.UseWhen(ctx => ctx.WebSockets.IsWebSocketRequest &&
ctx.Connection.LocalPort == jsonRpcConfig.WebSocketsPort,
builder => builder.UseWebSocketsModules());
}
app.Use(async(ctx, next) =>
{
if (ctx.Request.Method == "GET")
{
await ctx.Response.WriteAsync("Nethermind JSON RPC");
}
else if (ctx.Connection.LocalPort == jsonRpcConfig.Port && ctx.Request.Method == "POST")
{
using StreamReader reader = new StreamReader(ctx.Request.Body, Encoding.UTF8);
string request = await reader.ReadToEndAsync();
JsonRpcResult result = await jsonRpcProcessor.ProcessAsync(request);
ctx.Response.ContentType = "application/json";
Stream resultStream = jsonRpcConfig.BufferResponses ? new MemoryStream() : ctx.Response.Body;
try
{
if (result.IsCollection)
{
_jsonSerializer.Serialize(resultStream, result.Responses);
}
else
{
_jsonSerializer.Serialize(resultStream, result.Response);
}
if (jsonRpcConfig.BufferResponses)
{
ctx.Response.ContentLength = resultStream.Length;
resultStream.Seek(0, SeekOrigin.Begin);
await resultStream.CopyToAsync(ctx.Response.Body);
}
await ctx.Response.CompleteAsync();
}
finally
{
if (jsonRpcConfig.BufferResponses)
{
await resultStream.DisposeAsync();
}
}
}
});
}
public DiscoveryMessageFactory(IConfigProvider configurationProvider, ITimestamp timestamp)
{
_timestamp = timestamp;
_configurationProvider = configurationProvider.GetConfig <INetworkConfig>();
}
public DiscoveryMessageFactory(IConfigProvider configurationProvider)
{
_configurationProvider = configurationProvider.GetConfig <NetworkConfig>();
}
public ModuleProvider(IConfigProvider configurationProvider, INetModule netModule, IEthModule ethModule, IWeb3Module web3Module, IShhModule shhModule)
{
_configurationProvider = configurationProvider.GetConfig <JsonRpcConfig>();
Initialize(netModule, ethModule, web3Module, shhModule);
}
protected async Task StartRunners(IConfigProvider configProvider)
{
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
IJsonRpcConfig jsonRpcConfig = configProvider.GetConfig <IJsonRpcConfig>();
IMetricsConfig metricsConfig = configProvider.GetConfig <IMetricsConfig>();
NLogManager logManager = new NLogManager(initConfig.LogFileName, initConfig.LogDirectory);
IRpcModuleProvider rpcModuleProvider = jsonRpcConfig.Enabled
? new RpcModuleProvider(configProvider.GetConfig <IJsonRpcConfig>(), logManager)
: (IRpcModuleProvider)NullModuleProvider.Instance;
EthereumJsonSerializer jsonSerializer = new EthereumJsonSerializer();
WebSocketsManager webSocketsManager = new WebSocketsManager();
if (!string.IsNullOrEmpty(metricsConfig.NodeName))
{
logManager.SetGlobalVariable("nodeName", metricsConfig.NodeName);
}
if (metricsConfig.Enabled)
{
Metrics.Version = VersionToMetrics.ConvertToNumber(ClientVersion.Version);
MetricsUpdater metricsUpdater = new MetricsUpdater(metricsConfig);
_monitoringService = new MonitoringService(metricsUpdater, metricsConfig, logManager);
_monitoringService.RegisterMetrics(typeof(Nethermind.Blockchain.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Db.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Evm.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.JsonRpc.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Trie.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Network.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Synchronization.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.TxPool.Metrics));
_monitoringService.RegisterMetrics(typeof(Metrics));
await _monitoringService.StartAsync().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during starting a monitoring.", x.Exception);
}
});
}
else
{
if (_logger?.IsInfo ?? false)
{
_logger !.Info("Grafana / Prometheus metrics are disabled in configuration");
}
}
IGrpcConfig grpcConfig = configProvider.GetConfig <IGrpcConfig>();
GrpcServer? grpcServer = null;
if (grpcConfig.Enabled)
{
grpcServer = new GrpcServer(jsonSerializer, logManager);
_grpcRunner = new GrpcRunner(grpcServer, grpcConfig, logManager);
await _grpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during GRPC runner start", x.Exception);
}
});
}
INdmDataPublisher? ndmDataPublisher = null;
INdmConsumerChannelManager?ndmConsumerChannelManager = null;
INdmInitializer? ndmInitializer = null;
INdmConfig ndmConfig = configProvider.GetConfig <INdmConfig>();
bool ndmEnabled = ndmConfig.Enabled;
if (ndmEnabled)
{
ndmDataPublisher = new NdmDataPublisher();
ndmConsumerChannelManager = new NdmConsumerChannelManager();
string initializerName = ndmConfig.InitializerName;
if (_logger?.IsInfo ?? false)
{
_logger !.Info($"NDM initializer: {initializerName}");
}
Type ndmInitializerType = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.GetTypes())
.FirstOrDefault(t =>
t.GetCustomAttribute <NdmInitializerAttribute>()?.Name == initializerName);
NdmModule ndmModule = new NdmModule();
NdmConsumersModule ndmConsumersModule = new NdmConsumersModule();
ndmInitializer = new NdmInitializerFactory(ndmInitializerType, ndmModule, ndmConsumersModule, logManager).CreateOrFail();
if (grpcServer != null)
{
ndmConsumerChannelManager.Add(new GrpcNdmConsumerChannel(grpcServer));
}
webSocketsManager.AddModule(new NdmWebSocketsModule(ndmConsumerChannelManager, ndmDataPublisher, jsonSerializer));
}
_ethereumRunner = new EthereumRunner(
rpcModuleProvider,
configProvider,
logManager,
grpcServer,
ndmConsumerChannelManager,
ndmDataPublisher,
ndmInitializer,
webSocketsManager,
jsonSerializer,
_monitoringService);
await _ethereumRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during ethereum runner start", x.Exception);
}
});
if (jsonRpcConfig.Enabled)
{
rpcModuleProvider.Register(new SingletonModulePool <IWeb3Module>(new Web3Module(logManager), true));
JsonRpcService jsonRpcService = new JsonRpcService(rpcModuleProvider, logManager);
JsonRpcProcessor jsonRpcProcessor = new JsonRpcProcessor(jsonRpcService, jsonSerializer, jsonRpcConfig, new FileSystem(), logManager);
if (initConfig.WebSocketsEnabled)
{
webSocketsManager.AddModule(new JsonRpcWebSocketsModule(jsonRpcProcessor, jsonSerializer), true);
}
Bootstrap.Instance.JsonRpcService = jsonRpcService;
Bootstrap.Instance.LogManager = logManager;
Bootstrap.Instance.JsonSerializer = jsonSerializer;
_jsonRpcRunner = new JsonRpcRunner(configProvider, rpcModuleProvider, logManager, jsonRpcProcessor, webSocketsManager);
await _jsonRpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during jsonRpc runner start", x.Exception);
}
});
}
else
{
if (_logger?.IsInfo ?? false)
{
_logger !.Info("Json RPC is disabled");
}
}
}
private void SetupKeyStore()
{
var encrypter = new AesEncrypter(
_configProvider.GetConfig <IKeyStoreConfig>(),
_logManager);
_keyStore = new FileKeyStore(
_configProvider.GetConfig <IKeyStoreConfig>(),
_ethereumJsonSerializer,
encrypter,
_cryptoRandom,
_logManager);
switch (_initConfig)
{
case var _ when HiveEnabled:
// todo: use the keystore wallet here
_wallet = new HiveWallet();
break;
case var config when config.EnableUnsecuredDevWallet && config.KeepDevWalletInMemory:
_wallet = new DevWallet(_configProvider.GetConfig <IWalletConfig>(), _logManager);
break;
case var config when config.EnableUnsecuredDevWallet && !config.KeepDevWalletInMemory:
_wallet = new DevKeyStoreWallet(_keyStore, _logManager);
break;
default:
_wallet = new NullWallet();
break;
}
INodeKeyManager nodeKeyManager = new NodeKeyManager(_cryptoRandom, _keyStore, _configProvider.GetConfig <IKeyStoreConfig>(), _logManager);
_nodeKey = nodeKeyManager.LoadNodeKey();
var ipVariable = Environment.GetEnvironmentVariable("NETHERMIND_ENODE_IPADDRESS");
var localIp = string.IsNullOrWhiteSpace(ipVariable)
? _networkHelper.GetLocalIp()
: IPAddress.Parse(ipVariable);
_enode = new Enode(_nodeKey.PublicKey, localIp, _initConfig.P2PPort);
}
protected async Task StartRunners(IConfigProvider configProvider)
{
var initParams = configProvider.GetConfig <IInitConfig>();
var metricsParams = configProvider.GetConfig <IMetricsConfig>();
var logManager = new NLogManager(initParams.LogFileName, initParams.LogDirectory);
IRpcModuleProvider rpcModuleProvider = initParams.JsonRpcEnabled
? new RpcModuleProvider(configProvider.GetConfig <IJsonRpcConfig>())
: (IRpcModuleProvider)NullModuleProvider.Instance;
var webSocketsManager = new WebSocketsManager();
_ethereumRunner = new EthereumRunner(rpcModuleProvider, configProvider, logManager);
await _ethereumRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during ethereum runner start", x.Exception);
}
});
if (initParams.JsonRpcEnabled)
{
var serializer = new EthereumJsonSerializer();
rpcModuleProvider.Register <IWeb3Module>(new Web3Module(logManager));
var jsonRpcService = new JsonRpcService(rpcModuleProvider, logManager);
var jsonRpcProcessor = new JsonRpcProcessor(jsonRpcService, serializer, logManager);
webSocketsManager.AddModule(new JsonRpcWebSocketsModule(jsonRpcProcessor, serializer));
Bootstrap.Instance.JsonRpcService = jsonRpcService;
Bootstrap.Instance.LogManager = logManager;
Bootstrap.Instance.JsonSerializer = serializer;
_jsonRpcRunner = new JsonRpcRunner(configProvider, rpcModuleProvider, logManager, jsonRpcProcessor,
webSocketsManager);
await _jsonRpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during jsonRpc runner start", x.Exception);
}
});
}
else
{
if (Logger.IsInfo)
{
Logger.Info("Json RPC is disabled");
}
}
if (metricsParams.MetricsEnabled)
{
var intervalSeconds = metricsParams.MetricsIntervalSeconds;
_monitoringService = new MonitoringService(new MetricsUpdater(intervalSeconds),
metricsParams.MetricsPushGatewayUrl, ClientVersion.Description,
metricsParams.NodeName, intervalSeconds, logManager);
await _monitoringService.StartAsync().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during starting a monitoring.", x.Exception);
}
});
}
else
{
if (Logger.IsInfo)
{
Logger.Info("Monitoring is disabled");
}
}
}
private JsonRpcResponse TestRequest <T>(T module, string method, params string[] parameters) where T : IModule
{
RpcModuleProvider moduleProvider = new RpcModuleProvider(new FileSystem(), _configurationProvider.GetConfig <IJsonRpcConfig>(), LimboLogs.Instance);
moduleProvider.Register(new SingletonModulePool <T>(new SingletonFactory <T>(module), true));
_jsonRpcService = new JsonRpcService(moduleProvider, _logManager);
JsonRpcRequest request = RpcTest.GetJsonRequest(method, parameters);
JsonRpcResponse response = _jsonRpcService.SendRequestAsync(request, JsonRpcContext.Http).Result;
Assert.AreEqual(request.Id, response.Id);
return(response);
}
private static void Run(string[] args)
{
_logger.Info("Nethermind starting initialization.");
AppDomain.CurrentDomain.ProcessExit += CurrentDomainOnProcessExit;
IFileSystem fileSystem = new FileSystem();;
PluginLoader pluginLoader = new PluginLoader(
"plugins", fileSystem, typeof(CliquePlugin), typeof(EthashPlugin), typeof(NethDevPlugin));
pluginLoader.Load(SimpleConsoleLogManager.Instance);
Type configurationType = typeof(IConfig);
IEnumerable <Type> configTypes = new TypeDiscovery().FindNethermindTypes(configurationType)
.Where(ct => ct.IsInterface);
CommandLineApplication app = new CommandLineApplication {
Name = "Nethermind.Runner"
};
app.HelpOption("-?|-h|--help");
app.VersionOption("-v|--version", () => ClientVersion.Version, () => ClientVersion.Description);
GlobalDiagnosticsContext.Set("version", ClientVersion.Version);
CommandOption dataDir = app.Option("-dd|--datadir <dataDir>", "data directory", CommandOptionType.SingleValue);
CommandOption configFile = app.Option("-c|--config <configFile>", "config file path", CommandOptionType.SingleValue);
CommandOption dbBasePath = app.Option("-d|--baseDbPath <baseDbPath>", "base db path", CommandOptionType.SingleValue);
CommandOption logLevelOverride = app.Option("-l|--log <logLevel>", "log level", CommandOptionType.SingleValue);
CommandOption configsDirectory = app.Option("-cd|--configsDirectory <configsDirectory>", "configs directory", CommandOptionType.SingleValue);
CommandOption loggerConfigSource = app.Option("-lcs|--loggerConfigSource <loggerConfigSource>", "path to the NLog config file", CommandOptionType.SingleValue);
foreach (Type configType in configTypes.OrderBy(c => c.Name))
{
if (configType == null)
{
continue;
}
ConfigCategoryAttribute?typeLevel = configType.GetCustomAttribute <ConfigCategoryAttribute>();
if (typeLevel?.HiddenFromDocs ?? false)
{
continue;
}
foreach (PropertyInfo propertyInfo in configType
.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.OrderBy(p => p.Name))
{
ConfigItemAttribute?configItemAttribute = propertyInfo.GetCustomAttribute <ConfigItemAttribute>();
if (!(configItemAttribute?.HiddenFromDocs ?? false))
{
app.Option($"--{configType.Name.Substring(1).Replace("Config", String.Empty)}.{propertyInfo.Name}", $"{(configItemAttribute == null ? "<missing documentation>" : configItemAttribute.Description + $" (DEFAULT: {configItemAttribute.DefaultValue})" ?? "<missing documentation>")}", CommandOptionType.SingleValue);
}
}
}
ManualResetEventSlim appClosed = new ManualResetEventSlim(true);
app.OnExecute(async() =>
{
appClosed.Reset();
IConfigProvider configProvider = BuildConfigProvider(app, loggerConfigSource, logLevelOverride, configsDirectory, configFile);
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
IKeyStoreConfig keyStoreConfig = configProvider.GetConfig <IKeyStoreConfig>();
Console.Title = initConfig.LogFileName;
Console.CancelKeyPress += ConsoleOnCancelKeyPress;
SetFinalDataDirectory(dataDir.HasValue() ? dataDir.Value() : null, initConfig, keyStoreConfig);
NLogManager logManager = new(initConfig.LogFileName, initConfig.LogDirectory);
_logger = logManager.GetClassLogger();
if (_logger.IsDebug)
{
_logger.Debug($"Nethermind version: {ClientVersion.Description}");
}
ConfigureSeqLogger(configProvider);
SetFinalDbPath(dbBasePath.HasValue() ? dbBasePath.Value() : null, initConfig);
LogMemoryConfiguration();
EthereumJsonSerializer serializer = new();
if (_logger.IsDebug)
{
_logger.Debug($"Nethermind config:{Environment.NewLine}{serializer.Serialize(initConfig, true)}{Environment.NewLine}");
}
ApiBuilder apiBuilder = new(configProvider, logManager);
INethermindApi nethermindApi = apiBuilder.Create();
foreach (Type pluginType in pluginLoader.PluginTypes)
{
if (Activator.CreateInstance(pluginType) is INethermindPlugin plugin)
{
nethermindApi.Plugins.Add(plugin);
}
}
EthereumRunner ethereumRunner = new EthereumRunner(nethermindApi);
await ethereumRunner.Start(_processCloseCancellationSource.Token).ContinueWith(x =>
{
if (x.IsFaulted && _logger.IsError)
{
_logger.Error("Error during ethereum runner start", x.Exception);
}
});
await Task.WhenAny(_cancelKeySource.Task, _processExit.Task);
_logger.Info("Closing, please wait until all functions are stopped properly...");
await ethereumRunner.StopAsync();
_logger.Info("All done, goodbye!");
appClosed.Set();
return(0);
});
app.Execute(args);
appClosed.Wait();
}
protected async Task PreInitAsync(INdmApi ndmApi)
{
if (ndmApi == null)
{
throw new ArgumentNullException(nameof(ndmApi));
}
IDbProvider?dbProvider = ndmApi.DbProvider;
if (dbProvider == null)
{
throw new ArgumentNullException(nameof(dbProvider));
}
IConfigProvider configProvider = ndmApi.ConfigProvider;
ILogManager logManager = ndmApi.LogManager;
if (!(configProvider.GetConfig <INdmConfig>() is NdmConfig defaultConfig))
{
return;
}
if (!defaultConfig.Enabled)
{
return;
}
if (defaultConfig.StoreConfigInDatabase && string.IsNullOrWhiteSpace(defaultConfig.Id))
{
throw new ArgumentException("NDM config stored in database requires an id.", nameof(defaultConfig.Id));
}
IConfigRepository configRepository;
IEthRequestRepository ethRequestRepository;
switch (defaultConfig.Persistence?.ToLowerInvariant())
{
case "mongo":
ndmApi.MongoProvider = new MongoProvider(configProvider.GetConfig <INdmMongoConfig>(), logManager);
IMongoDatabase?database = ndmApi.MongoProvider.GetDatabase();
if (database == null)
{
throw new ApplicationException("Failed to initialize Mongo database");
}
configRepository = new ConfigMongoRepository(database);
ethRequestRepository = new EthRequestMongoRepository(database);
break;
default:
ndmApi.MongoProvider = NullMongoProvider.Instance;
var ndmDbProvider = new NdmDbInitializer(defaultConfig, ndmApi.DbProvider, ndmApi.RocksDbFactory, ndmApi.MemDbFactory);
await ndmDbProvider.Init();
configRepository = new ConfigRocksRepository(ndmApi.DbProvider.GetDb <IDb>(NdmDbNames.Configs), new NdmConfigDecoder());
ethRequestRepository = new EthRequestRocksRepository(ndmApi.DbProvider.GetDb <IDb>(NdmDbNames.EthRequests),
new EthRequestDecoder());
break;
}
ndmApi.ConfigManager = new ConfigManager(defaultConfig, configRepository);
ndmApi.NdmConfig = await ndmApi.ConfigManager.GetAsync(defaultConfig.Id);
if (ndmApi.NdmConfig is null)
{
ndmApi.NdmConfig = defaultConfig;
if (defaultConfig.StoreConfigInDatabase)
{
await ndmApi.ConfigManager.UpdateAsync((NdmConfig)ndmApi.NdmConfig);
}
}
IWebSocketsModule webSocketsModule = ndmApi.WebSocketsManager !.GetModule("ndm");
ndmApi.NdmNotifier = new NdmNotifier(webSocketsModule);
ndmApi.EthRequestService = new EthRequestService(ndmApi.NdmConfig.FaucetHost, logManager);
string baseDbPath = configProvider.GetConfig <IInitConfig>().BaseDbPath;
ndmApi.BaseDbPath = DbPath = Path.Combine(baseDbPath, ndmApi.NdmConfig.DatabasePath);
await _ndmModule.InitAsync();
if (ndmApi.NdmConfig.FaucetEnabled)
{
// faucet should be separate from NDM? but it uses MongoDB?
// so maybe we could extract Mongo DB beyond NDM? why would it be related?
if (string.IsNullOrWhiteSpace(ndmApi.NdmConfig.FaucetAddress))
{
ndmApi.NdmFaucet = EmptyFaucet.Instance;
_logger.Warn("Faucet cannot be started due to missing faucet address configuration.");
}
else
{
Address faucetAddress = new(ndmApi.NdmConfig.FaucetAddress);
ndmApi.NdmFaucet = new NdmFaucet(
ndmApi.BlockchainBridge,
ethRequestRepository,
faucetAddress,
ndmApi.NdmConfig.FaucetWeiRequestMaxValue,
ndmApi.NdmConfig.FaucetEthDailyRequestsTotalValue,
ndmApi.NdmConfig.FaucetEnabled,
ndmApi.Timestamper,
ndmApi.Wallet,
logManager);
}
}
else
{
ndmApi.NdmFaucet = EmptyFaucet.Instance;
}
ndmApi.ConsumerAddress = string.IsNullOrWhiteSpace(ndmApi.NdmConfig.ConsumerAddress)
? Address.Zero
: new Address(ndmApi.NdmConfig.ConsumerAddress);
ndmApi.ProviderAddress = string.IsNullOrWhiteSpace(ndmApi.NdmConfig.ProviderAddress)
? Address.Zero
: new Address(ndmApi.NdmConfig.ProviderAddress);
await _ndmConsumersModule.Init();
}
protected async Task StartRunners(IConfigProvider configProvider)
{
var initParams = configProvider.GetConfig <IInitConfig>();
var metricsParams = configProvider.GetConfig <IMetricsConfig>();
var logManager = new NLogManager(initParams.LogFileName, initParams.LogDirectory);
IRpcModuleProvider rpcModuleProvider = initParams.JsonRpcEnabled
? new RpcModuleProvider(configProvider.GetConfig <IJsonRpcConfig>())
: (IRpcModuleProvider)NullModuleProvider.Instance;
var webSocketsManager = new WebSocketsManager();
INdmDataPublisher ndmDataPublisher = null;
INdmConsumerChannelManager ndmConsumerChannelManager = null;
INdmInitializer ndmInitializer = null;
var ndmConfig = configProvider.GetConfig <INdmConfig>();
var ndmEnabled = ndmConfig.Enabled;
if (ndmEnabled)
{
ndmDataPublisher = new NdmDataPublisher();
ndmConsumerChannelManager = new NdmConsumerChannelManager();
ndmInitializer = new NdmInitializerFactory(logManager)
.CreateOrFail(ndmConfig.InitializerName, ndmConfig.PluginsPath);
}
var grpcConfig = configProvider.GetConfig <IGrpcConfig>();
GrpcService grpcService = null;
if (grpcConfig.Enabled)
{
grpcService = new GrpcService(logManager);
if (ndmEnabled)
{
ndmConsumerChannelManager.Add(new GrpcNdmConsumerChannel(grpcService));
}
_grpcRunner = new GrpcRunner(grpcService, grpcConfig, logManager);
await _grpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during GRPC runner start", x.Exception);
}
});
}
GrpcClient grpcClient = null;
var grpcClientConfig = configProvider.GetConfig <IGrpcClientConfig>();
if (grpcClientConfig.Enabled)
{
grpcClient = new GrpcClient(grpcClientConfig, new EthereumJsonSerializer(), logManager);
_grpcClientRunner = new GrpcClientRunner(grpcClient, grpcClientConfig, logManager);
await Task.Factory.StartNew(() => _grpcClientRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during GRPC client runner start", x.Exception);
}
}));
}
_ethereumRunner = new EthereumRunner(rpcModuleProvider, configProvider, logManager, grpcService, grpcClient,
ndmConsumerChannelManager, ndmDataPublisher, ndmInitializer);
await _ethereumRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during ethereum runner start", x.Exception);
}
});
if (initParams.JsonRpcEnabled)
{
var serializer = new EthereumJsonSerializer();
rpcModuleProvider.Register <IWeb3Module>(new Web3Module(logManager));
var jsonRpcService = new JsonRpcService(rpcModuleProvider, logManager);
var jsonRpcProcessor = new JsonRpcProcessor(jsonRpcService, serializer, logManager);
webSocketsManager.AddModule(new JsonRpcWebSocketsModule(jsonRpcProcessor, serializer));
if (ndmEnabled)
{
webSocketsManager.AddModule(new NdmWebSocketsModule(ndmConsumerChannelManager, ndmDataPublisher));
}
Bootstrap.Instance.JsonRpcService = jsonRpcService;
Bootstrap.Instance.LogManager = logManager;
Bootstrap.Instance.JsonSerializer = serializer;
_jsonRpcRunner = new JsonRpcRunner(configProvider, rpcModuleProvider, logManager, jsonRpcProcessor,
webSocketsManager);
await _jsonRpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during jsonRpc runner start", x.Exception);
}
});
}
else
{
if (Logger.IsInfo)
{
Logger.Info("Json RPC is disabled");
}
}
if (metricsParams.MetricsEnabled)
{
var intervalSeconds = metricsParams.MetricsIntervalSeconds;
_monitoringService = new MonitoringService(new MetricsUpdater(intervalSeconds),
metricsParams.MetricsPushGatewayUrl, ClientVersion.Description,
metricsParams.NodeName, intervalSeconds, logManager);
await _monitoringService.StartAsync().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during starting a monitoring.", x.Exception);
}
});
}
else
{
if (Logger.IsInfo)
{
Logger.Info("Monitoring is disabled");
}
}
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IJsonRpcProcessor jsonRpcProcessor, IJsonRpcService jsonRpcService, IJsonRpcLocalStats jsonRpcLocalStats)
{
void SerializeTimeoutException(IJsonRpcService service, Stream resultStream)
{
JsonRpcErrorResponse?error = service.GetErrorResponse(ErrorCodes.Timeout, "Request was canceled due to enabled timeout.");
_jsonSerializer.Serialize(resultStream, error);
}
_jsonSerializer = CreateJsonSerializer();
foreach (JsonConverter converter in jsonRpcService.Converters)
{
_jsonSerializer.RegisterConverter(converter);
}
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseCors("Cors");
IConfigProvider configProvider = app.ApplicationServices.GetService <IConfigProvider>();
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
IJsonRpcConfig jsonRpcConfig = configProvider.GetConfig <IJsonRpcConfig>();
if (initConfig.WebSocketsEnabled)
{
app.UseWebSockets();
app.UseWhen(ctx => ctx.WebSockets.IsWebSocketRequest &&
ctx.Connection.LocalPort == jsonRpcConfig.WebSocketsPort,
builder => builder.UseWebSocketsModules());
}
app.Use(async(ctx, next) =>
{
if (ctx.Request.Method == "GET")
{
await ctx.Response.WriteAsync("Nethermind JSON RPC");
}
else if (ctx.Connection.LocalPort == jsonRpcConfig.Port && ctx.Request.Method == "POST")
{
Stopwatch stopwatch = Stopwatch.StartNew();
using StreamReader reader = new StreamReader(ctx.Request.Body, Encoding.UTF8);
string request = await reader.ReadToEndAsync();
using JsonRpcResult result = await jsonRpcProcessor.ProcessAsync(request);
ctx.Response.ContentType = "application/json";
Stream resultStream = jsonRpcConfig.BufferResponses ? new MemoryStream() : ctx.Response.Body;
try
{
if (result.IsCollection)
{
_jsonSerializer.Serialize(resultStream, result.Responses);
}
else
{
_jsonSerializer.Serialize(resultStream, result.Response);
}
if (jsonRpcConfig.BufferResponses)
{
ctx.Response.ContentLength = resultStream.Length;
resultStream.Seek(0, SeekOrigin.Begin);
await resultStream.CopyToAsync(ctx.Response.Body);
}
}
catch (Exception e) when(e.InnerException is OperationCanceledException)
{
SerializeTimeoutException(jsonRpcService, resultStream);
}
catch (OperationCanceledException)
{
SerializeTimeoutException(jsonRpcService, resultStream);
}
finally
{
await ctx.Response.CompleteAsync();
if (jsonRpcConfig.BufferResponses)
{
await resultStream.DisposeAsync();
}
}
if (result.IsCollection)
{
jsonRpcLocalStats.ReportCalls(result.Reports);
jsonRpcLocalStats.ReportCall(new RpcReport("# collection serialization #", stopwatch.ElapsedMicroseconds(), true));
}
else
{
jsonRpcLocalStats.ReportCall(result.Report, stopwatch.ElapsedMicroseconds());
}
}
});
}
private static void Generate(string projectFolder, string configPath)
{
// get config
configPath = !string.IsNullOrEmpty(configPath)
? Path.Combine(projectFolder, configPath)
: Path.Combine(projectFolder, "tgconfig.json");
TgConfig config = _configProvider.GetConfig(configPath, projectFolder);
// register assembly resolver
_assemblyResolver.Directories = config.ExternalAssemblyPaths;
_assemblyResolver.Register();
IEnumerable <Assembly> assemblies = GetAssemblies(config.GetAssemblies()).ToArray();
// create generator
GeneratorOptions generatorOptions = _generatorOptionsProvider.GetGeneratorOptions(config, assemblies, projectFolder);
generatorOptions.BaseOutputDirectory = Path.Combine(projectFolder, config.OutputPath);
var generator = new Generator(generatorOptions, _logger);
// generate
if (config.ClearOutputDirectory == true)
{
_fileSystem.ClearDirectory(generatorOptions.BaseOutputDirectory);
}
IEnumerable <string> generatedFiles = Enumerable.Empty <string>();
if (!config.GenerationSpecs.Any() || config.GenerateFromAssemblies == true)
{
generatedFiles = generator.Generate(assemblies);
}
if (config.GenerationSpecs.Any())
{
var typeResolver = new TypeResolver(_logger, _fileSystem, projectFolder, assemblies);
generatedFiles = config.GenerationSpecs
.Select(name => typeResolver.Resolve(name, "GenerationSpec"))
.Where(t => t != null)
.Select(t => (GenerationSpec)Activator.CreateInstance(t))
.Aggregate(generatedFiles, (acc, spec) => acc.Concat(generator.Generate(spec)));
}
_logger.Log("");
_logger.Log(generatedFiles.Select(x => $"Generated {x}").ToArray());
_logger.Log("");
if (config.AddFilesToProject ?? TgConfig.DefaultAddFilesToProject)
{
AddFilesToProject(projectFolder, generatedFiles);
}
// unregister assembly resolver
_assemblyResolver.Unregister();
}
protected async Task StartRunners(IConfigProvider configProvider)
{
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
IJsonRpcConfig jsonRpcConfig = configProvider.GetConfig <IJsonRpcConfig>();
var metricsParams = configProvider.GetConfig <IMetricsConfig>();
var logManager = new NLogManager(initConfig.LogFileName, initConfig.LogDirectory);
IRpcModuleProvider rpcModuleProvider = jsonRpcConfig.Enabled
? new RpcModuleProvider(configProvider.GetConfig <IJsonRpcConfig>(), logManager)
: (IRpcModuleProvider)NullModuleProvider.Instance;
var jsonSerializer = new EthereumJsonSerializer();
var webSocketsManager = new WebSocketsManager();
INdmDataPublisher ndmDataPublisher = null;
INdmConsumerChannelManager ndmConsumerChannelManager = null;
INdmInitializer ndmInitializer = null;
var ndmConfig = configProvider.GetConfig <INdmConfig>();
var ndmEnabled = ndmConfig.Enabled;
if (ndmEnabled)
{
ndmDataPublisher = new NdmDataPublisher();
ndmConsumerChannelManager = new NdmConsumerChannelManager();
var initializerName = ndmConfig.InitializerName;
if (Logger.IsInfo)
{
Logger.Info($"NDM initializer: {initializerName}");
}
var ndmInitializerType = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.GetTypes())
.FirstOrDefault(t =>
t.GetCustomAttribute <NdmInitializerAttribute>()?.Name == initializerName);
var ndmModule = new NdmModule();
var ndmConsumersModule = new NdmConsumersModule();
ndmInitializer = new NdmInitializerFactory(ndmInitializerType, ndmModule, ndmConsumersModule,
logManager).CreateOrFail();
}
var grpcConfig = configProvider.GetConfig <IGrpcConfig>();
GrpcServer grpcServer = null;
if (grpcConfig.Enabled)
{
grpcServer = new GrpcServer(jsonSerializer, logManager);
if (ndmEnabled)
{
ndmConsumerChannelManager.Add(new GrpcNdmConsumerChannel(grpcServer));
}
_grpcRunner = new GrpcRunner(grpcServer, grpcConfig, logManager);
await _grpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during GRPC runner start", x.Exception);
}
});
}
if (initConfig.WebSocketsEnabled)
{
if (ndmEnabled)
{
webSocketsManager.AddModule(new NdmWebSocketsModule(ndmConsumerChannelManager, ndmDataPublisher,
jsonSerializer));
}
}
_ethereumRunner = new EthereumRunner(rpcModuleProvider, configProvider, logManager, grpcServer,
ndmConsumerChannelManager, ndmDataPublisher, ndmInitializer, webSocketsManager, jsonSerializer);
await _ethereumRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during ethereum runner start", x.Exception);
}
});
if (jsonRpcConfig.Enabled)
{
rpcModuleProvider.Register(new SingletonModulePool <IWeb3Module>(new Web3Module(logManager)));
var jsonRpcService = new JsonRpcService(rpcModuleProvider, logManager);
var jsonRpcProcessor = new JsonRpcProcessor(jsonRpcService, jsonSerializer, logManager);
if (initConfig.WebSocketsEnabled)
{
webSocketsManager.AddModule(new JsonRpcWebSocketsModule(jsonRpcProcessor, jsonSerializer));
}
Bootstrap.Instance.JsonRpcService = jsonRpcService;
Bootstrap.Instance.LogManager = logManager;
Bootstrap.Instance.JsonSerializer = jsonSerializer;
_jsonRpcRunner = new JsonRpcRunner(configProvider, rpcModuleProvider, logManager, jsonRpcProcessor,
webSocketsManager);
await _jsonRpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during jsonRpc runner start", x.Exception);
}
});
}
else
{
if (Logger.IsInfo)
{
Logger.Info("Json RPC is disabled");
}
}
if (metricsParams.Enabled)
{
var intervalSeconds = metricsParams.IntervalSeconds;
_monitoringService = new MonitoringService(new MetricsUpdater(intervalSeconds),
metricsParams.PushGatewayUrl, ClientVersion.Description,
metricsParams.NodeName, intervalSeconds, logManager);
await _monitoringService.StartAsync().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during starting a monitoring.", x.Exception);
}
});
}
else
{
if (Logger.IsInfo)
{
Logger.Info("Monitoring is disabled");
}
}
}
public AesEncrypter(IConfigProvider configurationProvider, ILogManager logManager)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_configurationProvider = configurationProvider.GetConfig <IKeystoreConfig>();
}
