public async Task InitRpcModules()
{
if (_baselineConfig.Enabled)
{
var baselineDbInitializer = new BaselineDbInitializer(_api.DbProvider, _baselineConfig, _api.RocksDbFactory, _api.MemDbFactory);
await baselineDbInitializer.Init();
BaselineModuleFactory baselineModuleFactory = new BaselineModuleFactory(
_api.TxSender !,
_api.StateReader !,
_api.CreateBlockchainBridge(),
_api.BlockTree !,
_api.AbiEncoder,
_api.FileSystem,
_api.LogManager,
_api.MainBlockProcessor,
_api.DisposeStack,
_api.DbProvider);
var modulePool = new SingletonModulePool <IBaselineModule>(baselineModuleFactory);
_api.RpcModuleProvider !.Register(modulePool);
if (_logger.IsInfo)
{
_logger.Info("Baseline RPC Module has been enabled");
}
}
else
{
if (_logger.IsWarn)
{
_logger.Info("Skipping Baseline RPC due to baseline being disabled in config.");
}
}
}
public void Returns_politely_when_no_method_found()
{
SingletonModulePool <INetModule> pool = new SingletonModulePool <INetModule>(Substitute.For <INetModule>(), true);
_moduleProvider.Register(pool);
ModuleResolution resolution = _moduleProvider.Check("unknown_method");
Assert.AreEqual(ModuleResolution.Unknown, resolution);
}
public void Method_resolution_is_not_case_sensitive()
{
SingletonModulePool <INetModule> pool = new SingletonModulePool <INetModule>(new NetModule(LimboLogs.Instance, Substitute.For <INetBridge>()), true);
_moduleProvider.Register(pool);
ModuleResolution resolution = _moduleProvider.Check("net_VeRsIoN");
Assert.AreEqual(ModuleResolution.Enabled, resolution);
}
public void Method_resolution_is_case_sensitive()
{
SingletonModulePool <INetRpcModule> pool = new SingletonModulePool <INetRpcModule>(new NetRpcModule(LimboLogs.Instance, Substitute.For <INetBridge>()), true);
_moduleProvider.Register(pool);
_moduleProvider.Check("net_VeRsIoN", RpcEndpoint.Http).Should().Be(ModuleResolution.Unknown);
_moduleProvider.Check("net_Version", RpcEndpoint.Http).Should().Be(ModuleResolution.Unknown);
_moduleProvider.Check("Net_Version", RpcEndpoint.Http).Should().Be(ModuleResolution.Unknown);
_moduleProvider.Check("net_version", RpcEndpoint.Http).Should().Be(ModuleResolution.Enabled);
}
public void With_filter_can_reject(string regex, ModuleResolution expectedResult)
{
JsonRpcConfig config = new JsonRpcConfig();
_fileSystem.File.Exists(Arg.Any <string>()).Returns(true);
_fileSystem.File.ReadLines(Arg.Any <string>()).Returns(new[] { regex });
_moduleProvider = new RpcModuleProvider(_fileSystem, config, LimboLogs.Instance);
SingletonModulePool <INetModule> pool = new SingletonModulePool <INetModule>(new NetModule(LimboLogs.Instance, Substitute.For <INetBridge>()), true);
_moduleProvider.Register(pool);
ModuleResolution resolution = _moduleProvider.Check("net_version");
resolution.Should().Be(expectedResult);
}
public Task InitRpcModules()
{
if (_nethermindApi !.SealEngineType != SealEngineType.Clique)
{
return(Task.CompletedTask);
}
var(getFromApi, _) = _nethermindApi !.ForRpc;
CliqueRpcRpcModule cliqueRpcRpcModule = new CliqueRpcRpcModule(
getFromApi !.BlockProducer as ICliqueBlockProducer,
_snapshotManager !,
getFromApi.BlockTree !);
var modulePool = new SingletonModulePool <ICliqueRpcModule>(cliqueRpcRpcModule);
getFromApi.RpcModuleProvider.Register(modulePool);
return(Task.CompletedTask);
}
public void Ensure_unlimited_shared()
{
_modulePool = new SingletonModulePool <IEthModule>(_factory.Create(), true);
_modulePool.GetModule(true);
}
public void Can_return_exclusive_if_allowed()
{
_modulePool = new SingletonModulePool <IEthModule>(_factory.Create(), true);
_modulePool.GetModule(false);
}
public void Cannot_return_exclusive_if_not_allowed()
{
_modulePool = new SingletonModulePool <IEthModule>(_factory.Create(), false);
Assert.Throws <InvalidOperationException>(() => _modulePool.GetModule(false));
}
