public async Task Throw_operation_canceled_after_given_timeout([Values(2, 0.01)] double waitTime)
{
var timeout = TimeSpan.FromMilliseconds(10);
using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(timeout);
CancellationToken cancellationToken = cancellationTokenSource.Token;
StoreTreeBlooms(true);
_receiptStorage = NullReceiptStorage.Instance;
_logFinder = new LogFinder(_blockTree, _receiptStorage, _bloomStorage, LimboLogs.Instance, _receiptsRecovery);
var logFilter = AllBlockFilter().Build();
var logs = _logFinder.FindLogs(logFilter, cancellationToken);
await Task.Delay(timeout *waitTime);
Func <FilterLog[]> action = () => logs.ToArray();
if (waitTime > 1)
{
action.Should().Throw <AggregateException>().WithInnerException <OperationCanceledException>();
}
else
{
action.Should().NotThrow();
}
}
public JsonResult Types(string query, DateTime start, DateTime end)
{
var finder = new LogFinder(contextFactory.Create());
var types = finder.GetTypes(query, start, end);
var rows = types.Select(x => new
{
c = new object[]
{
new { v = x.Type },
new { v = x.Total },
new { v = x.FirstHit, f = x.FirstHit.ToString() },
new { v = x.LastHit, f = x.LastHit.ToString() }
}
});
return(Json(new
{
cols = new[]
{
new { id = "Type", label = "Type", type = "string" },
new { id = "Total", label = "Total", type = "number" },
new { id = "FirstHit", label = "FirstHit", type = "date" },
new { id = "LastHit", label = "LastHit", type = "date" }
},
rows = rows
}));
}
public void GetLogFile_FileExists_ShouldReturnSuccess()
{
//Arrange
const string logId = "123";
var fileInfo = new FileInfo(123, "log_fileName.json", "foobar");
var optionsMock = new Mock <IOptions <LogFinderOptions> >();
optionsMock.Setup(x => x.Value)
.Returns(new LogFinderOptions());
var fileReaderMock = new Mock <IFileReader>();
fileReaderMock
.Setup(x => x.ReadFile(It.IsAny <string>()))
.Returns(new ReadFileResult.Success(fileInfo));
var logFinder = new LogFinder(optionsMock.Object, fileReaderMock.Object);
//Act
var result = logFinder.GetLogFile(logId);
//Assert
result.Should().BeOfType <GetLogFileResult.Success>();
var successResult = result.As <GetLogFileResult.Success>();
successResult.LogFile.Content.Should().Be(fileInfo.Content);
}
public JsonResult Logs(string query, DateTime start, DateTime end, int limit, string[] types)
{
var finder = new LogFinder(contextFactory.Create());
var result = finder.Find(query, start, end, types, limit);
var rows = result.Select(x => new
{
c = new object[]
{
new { v = x.TimeStamp, f = x.TimeStamp.ToString() },
new { v = x.Type },
new { v = x.Message },
new { v = x.Object },
new { v = x.ThreadId },
}
});
return(Json(new
{
cols = new[]
{
new { id = "Timestamp", label = "Timestamp", type = "date" },
new { id = "Type", label = "Type", type = "string" },
new { id = "Message", label = "Message", type = "string" },
new { id = "Object", label = "Object", type = "string" },
new { id = "ThreadId", label = "ThreadId", type = "number" },
},
rows = rows
}));
}
public static INdmBlockchainBridge BuildABridge()
{
IDbProvider memDbProvider = TestMemDbProvider.Init();
StateReader stateReader = new StateReader(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
StateProvider stateProvider = new StateProvider(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
IEthereumEcdsa ecdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
ITxPool txPool = new TxPool.TxPool(new InMemoryTxStorage(), ecdsa, MainnetSpecProvider.Instance, new TxPoolConfig(), stateProvider, LimboLogs.Instance);
BlockTree blockTree = Build.A.BlockTree().OfChainLength(1).TestObject;
IWallet wallet = new DevWallet(new WalletConfig(), LimboLogs.Instance);
ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(ecdsa, MainnetSpecProvider.Instance);
LogFinder logFinder = new LogFinder(blockTree, new InMemoryReceiptStorage(), NullBloomStorage.Instance, LimboLogs.Instance, receiptsRecovery, 1024);
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(memDbProvider, false),
new ReadOnlyBlockTree(blockTree),
MainnetSpecProvider.Instance, LimboLogs.Instance);
BlockchainBridge blockchainBridge = new BlockchainBridge(
processingEnv,
txPool,
new InMemoryReceiptStorage(),
NullFilterStore.Instance,
NullFilterManager.Instance,
ecdsa,
Timestamper.Default,
logFinder,
false,
false);
WalletTxSigner txSigner = new WalletTxSigner(wallet, ChainId.Mainnet);
ITxSealer txSealer0 = new TxSealer(txSigner, Timestamper.Default);
ITxSealer txSealer1 = new NonceReservingTxSealer(txSigner, Timestamper.Default, txPool);
ITxSender txSender = new TxPoolSender(txPool, txSealer0, txSealer1);
return(new NdmBlockchainBridge(blockchainBridge, blockTree, stateReader, txSender));
}
public Task Execute(CancellationToken cancellationToken)
{
IInitConfig initConfig = _get.Config <IInitConfig>();
IBloomConfig bloomConfig = _get.Config <IBloomConfig>();
IFileStoreFactory fileStoreFactory = initConfig.DiagnosticMode == DiagnosticMode.MemDb
? (IFileStoreFactory) new InMemoryDictionaryFileStoreFactory()
: new FixedSizeFileStoreFactory(Path.Combine(initConfig.BaseDbPath, DbNames.Bloom), DbNames.Bloom, Bloom.ByteLength);
var bloomStorage =
_set.BloomStorage = bloomConfig.Index
? new BloomStorage(bloomConfig, _get.DbProvider !.BloomDb, fileStoreFactory)
: (IBloomStorage)NullBloomStorage.Instance;
_get.DisposeStack.Push(bloomStorage);
var chainLevelInfoRepository =
_set.ChainLevelInfoRepository = new ChainLevelInfoRepository(_get.DbProvider !.BlockInfosDb);
var blockTree = _set.BlockTree = new BlockTree(
_get.DbProvider,
chainLevelInfoRepository,
_get.SpecProvider,
bloomStorage,
_get.Config <ISyncConfig>(),
_get.LogManager);
ISigner signer = NullSigner.Instance;
ISignerStore signerStore = NullSigner.Instance;
if (_get.Config <IMiningConfig>().Enabled)
{
Signer signerAndStore = new Signer(_get.SpecProvider !.ChainId, _get.OriginalSignerKey, _get.LogManager);
signer = signerAndStore;
signerStore = signerAndStore;
}
_set.EngineSigner = signer;
_set.EngineSignerStore = signerStore;
ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(_get.EthereumEcdsa, _get.SpecProvider);
var receiptStorage = _set.ReceiptStorage
= initConfig.StoreReceipts ? (IReceiptStorage?)new PersistentReceiptStorage(_get.DbProvider.ReceiptsDb, _get.SpecProvider, receiptsRecovery) : NullReceiptStorage.Instance;
var receiptFinder = _set.ReceiptFinder = new FullInfoReceiptFinder(receiptStorage, receiptsRecovery, blockTree);
LogFinder logFinder = new LogFinder(
blockTree,
receiptFinder,
bloomStorage,
_get.LogManager,
new ReceiptsRecovery(_get.EthereumEcdsa, _get.SpecProvider),
1024);
_set.LogFinder = logFinder;
return(Task.CompletedTask);
}
public void filter_by_blocks_with_limit([ValueSource(nameof(WithBloomValues))] bool withBloomDb)
{
StoreTreeBlooms(withBloomDb);
_logFinder = new LogFinder(_blockTree, _receiptStorage, _bloomStorage, LimboLogs.Instance, _receiptsRecovery, 2);
var filter = FilterBuilder.New().FromLatestBlock().ToLatestBlock().Build();
var logs = _logFinder.FindLogs(filter).ToArray();
logs.Length.Should().Be(3);
}
public void filter_all_logs_when_receipts_ar_missing()
{
_receiptStorage = NullReceiptStorage.Instance;
_logFinder = new LogFinder(new BlockFinder(_blockTree), _receiptStorage);
var logFilter = AllBlockFilter().Build();
var logs = _logFinder.FindLogs(logFilter);
logs.Length.Should().Be(0);
}
public void SetUp()
{
var specProvider = Substitute.For <ISpecProvider>();
specProvider.GetSpec(Arg.Any <long>()).IsEip155Enabled.Returns(true);
_receiptStorage = new InMemoryReceiptStorage();
_blockTree = Build.A.BlockTree().WithTransactions(_receiptStorage, specProvider, LogsForBlockBuilder).OfChainLength(5).TestObject;
_logFinder = new LogFinder(new BlockFinder(_blockTree), _receiptStorage);
}
public void filter_all_logs_when_receipts_are_missing([ValueSource(nameof(WithBloomValues))] bool withBloomDb)
{
StoreTreeBlooms(withBloomDb);
_receiptStorage = NullReceiptStorage.Instance;
_logFinder = new LogFinder(_blockTree, _receiptStorage, _bloomStorage, LimboLogs.Instance, _receiptsRecovery);
var logFilter = AllBlockFilter().Build();
var logs = _logFinder.FindLogs(logFilter);
logs.Should().BeEmpty();
}
private void SetUp(bool allowReceiptIterator)
{
var specProvider = Substitute.For <ISpecProvider>();
specProvider.GetSpec(Arg.Any <long>()).IsEip155Enabled.Returns(true);
_receiptStorage = new InMemoryReceiptStorage(allowReceiptIterator);
_blockTree = Build.A.BlockTree().WithTransactions(_receiptStorage, specProvider, LogsForBlockBuilder).OfChainLength(5).TestObject;
_bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
_receiptsRecovery = Substitute.For <IReceiptsRecovery>();
_logFinder = new LogFinder(_blockTree, _receiptStorage, _bloomStorage, LimboLogs.Instance, _receiptsRecovery);
}
public void throw_exception_when_receipts_are_missing([ValueSource(nameof(WithBloomValues))] bool withBloomDb)
{
StoreTreeBlooms(withBloomDb);
_receiptStorage = NullReceiptStorage.Instance;
_logFinder = new LogFinder(_blockTree, _receiptStorage, _receiptStorage, _bloomStorage, LimboLogs.Instance, _receiptsRecovery);
var logFilter = AllBlockFilter().Build();
_logFinder.Invoking(it => it.FindLogs(logFilter))
.Should()
.Throw <ResourceNotFoundException>();
}
public void filter_all_logs_should_return_empty_array_when_to_block_is_null()
{
var blockFinder = Substitute.For <IBlockFinder>();
_logFinder = new LogFinder(blockFinder, _receiptStorage);
var logFilter = AllBlockFilter().Build();
var logs = _logFinder.FindLogs(logFilter);
logs.Should().BeEmpty();
blockFinder.Received().GetBlock(logFilter.ToBlock);
blockFinder.DidNotReceive().GetBlock(logFilter.FromBlock);
}
private void SetupFileSystemWatchers()
{
foreach (var watcher in fileSystemWatchers)
{
watcher.Dispose();
}
// We do not want to process logs before they are fully written,
// mid-compression and the like, so we add a delay after detecting one.
var delay = TimeSpan.FromSeconds(5);
fileSystemWatchers.Clear();
foreach (var directory in Settings.LogRootPaths)
{
try
{
var watcher = new FileSystemWatcher(directory);
watcher.IncludeSubdirectories = true;
watcher.Filter = "*";
watcher.Created += (sender, args) =>
{
Task.Run(async() =>
{
await Task.Delay(delay);
if (LogFinder.IsLikelyEvtcLog(args.FullPath))
{
Application.Instance.AsyncInvoke(() => AddNewLog(args.FullPath));
}
});
};
watcher.Renamed += (sender, args) =>
{
Task.Run(async() =>
{
await Task.Delay(delay);
if (LogFinder.IsLikelyEvtcLog(args.FullPath))
{
Application.Instance.AsyncInvoke(() => AddNewLog(args.FullPath));
}
});
};
watcher.EnableRaisingEvents = true;
fileSystemWatchers.Add(watcher);
}
catch (Exception e)
{
// TODO: Replace with proper logging
Console.Error.WriteLine($"Failed to set up FileSystemWatcher: {e.Message}");
}
}
}
public void filter_all_logs_should_throw_when_to_block_is_not_found([ValueSource(nameof(WithBloomValues))] bool withBloomDb)
{
StoreTreeBlooms(withBloomDb);
var blockFinder = Substitute.For <IBlockFinder>();
_logFinder = new LogFinder(blockFinder, _receiptStorage, _bloomStorage, LimboLogs.Instance, _receiptsRecovery);
var logFilter = AllBlockFilter().Build();
var action = new Func <IEnumerable <FilterLog> >(() => _logFinder.FindLogs(logFilter));
action.Should().Throw <ArgumentException>();
blockFinder.Received().FindHeader(logFilter.ToBlock);
blockFinder.DidNotReceive().FindHeader(logFilter.FromBlock);
}
public void when_receipts_are_missing_and_header_has_no_receipt_root_do_not_throw_exception_()
{
_receiptStorage = NullReceiptStorage.Instance;
_logFinder = new LogFinder(_blockTree, _receiptStorage, _receiptStorage, _bloomStorage, LimboLogs.Instance, _receiptsRecovery);
SetupHeadWithNoTransaction();
var logFilter = AllBlockFilter().Build();
_logFinder.Invoking(it => it.FindLogs(logFilter))
.Should()
.NotThrow <ResourceNotFoundException>();
}
protected override async Task <TestBlockchain> Build(ISpecProvider specProvider = null)
{
BloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
specProvider ??= MainnetSpecProvider.Instance;
await base.Build(specProvider);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, BlockProcessor, TxPool, LimboLogs.Instance);
LogFinder = new LogFinder(BlockTree, ReceiptStorage, bloomStorage, LimboLogs.Instance, new ReceiptsRecovery());
Bridge ??= new BlockchainBridge(StateReader, State, Storage, BlockTree, TxPool, ReceiptStorage, filterStore, filterManager, TestWallet, TxProcessor, EthereumEcdsa, NullBloomStorage.Instance, Timestamper, LimboLogs.Instance, false);
TxPoolBridge ??= new TxPoolBridge(TxPool, TestWallet, Timestamper, specProvider?.ChainId ?? 0);
EthModule = new EthModule(new JsonRpcConfig(), Bridge, TxPoolBridge, LimboLogs.Instance);
return(this);
}
/// <summary>
/// Discover logs and process them.
/// </summary>
private void FindLogs(CancellationToken cancellationToken)
{
LogDataProcessor.UnscheduleAll();
// TODO: Fix the counters being off if a log is currently being processed
LogDataProcessor.ResetTotalCounters();
try
{
var newLogs = new List <LogData>();
//foreach (var log in LogFinder.GetTesting())
foreach (var log in Settings.LogRootPaths.SelectMany(x => LogFinder.GetFromDirectory(x, LogCache)))
{
newLogs.Add(log);
if (log.ParsingStatus == ParsingStatus.Parsed)
{
ApiProcessor.RegisterLog(log);
}
else
{
LogDataProcessor.Schedule(log);
}
cancellationToken.ThrowIfCancellationRequested();
}
Application.Instance.Invoke(() => { logs.AddRange(newLogs); });
}
catch (Exception e) when(!(e is OperationCanceledException))
{
Application.Instance.Invoke(() =>
{
MessageBox.Show(this, $"Logs could not be found.\nReason: {e.Message}", "Log Discovery Error",
MessageBoxType.Error);
});
}
if (LogCache.ChangedSinceLastSave)
{
LogCache.SaveToFile();
}
}
protected override async Task <TestBlockchain> Build(ISpecProvider specProvider = null, UInt256?initialValues = null)
{
BloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
specProvider ??= MainnetSpecProvider.Instance;
await base.Build(specProvider, initialValues);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, BlockProcessor, TxPool, LimboLogs.Instance);
ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(new EthereumEcdsa(specProvider.ChainId, LimboLogs.Instance), specProvider);
LogFinder = new LogFinder(BlockTree, ReceiptStorage, bloomStorage, LimboLogs.Instance, receiptsRecovery);
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(DbProvider, false),
new TrieStore(DbProvider.StateDb, LimboLogs.Instance).AsReadOnly(),
new ReadOnlyBlockTree(BlockTree),
SpecProvider,
LimboLogs.Instance);
Bridge ??= new BlockchainBridge(processingEnv, TxPool, ReceiptStorage, filterStore, filterManager, EthereumEcdsa, Timestamper, LogFinder, SpecProvider, false, false);
BlockFinder ??= BlockTree;
ITxSigner txSigner = new WalletTxSigner(TestWallet, specProvider?.ChainId ?? 0);
ITxSealer txSealer0 = new TxSealer(txSigner, Timestamper);
ITxSealer txSealer1 = new NonceReservingTxSealer(txSigner, Timestamper, TxPool);
TxSender ??= new TxPoolSender(TxPool, txSealer0, txSealer1);
EthRpcModule = new EthRpcModule(
new JsonRpcConfig(),
Bridge,
BlockFinder,
StateReader,
TxPool,
TxSender,
TestWallet,
LimboLogs.Instance,
SpecProvider);
return(this);
}
public void logFinder_find_test()
{
using (IDataContextFactory contextFactory = new MongoDataContextFactory(client, "testDb"))
{
IDataContext ctx = contextFactory.Create();
GenerateLogs(ctx);
var logFinder = new LogFinder(ctx);
const string query = "{}";
DateTime start = DateTime.MinValue;
DateTime end = DateTime.MaxValue;
var types = new[] { "job.a", "job.b", "job.c" };
const int limit = 250;
IQueryable <LogItemDto> result = logFinder.Find(query, start, end, types, limit);
result.Count().ShouldBeGreaterThan(0);
}
}
private void SetupFileSystemWatchers()
{
foreach (var watcher in fileSystemWatchers)
{
watcher.Dispose();
}
fileSystemWatchers.Clear();
foreach (var directory in Settings.LogRootPaths)
{
try
{
var watcher = new FileSystemWatcher(directory);
watcher.IncludeSubdirectories = true;
watcher.Filter = "*";
watcher.Created += (sender, args) =>
{
if (LogFinder.IsLikelyEvtcLog(args.FullPath))
{
Application.Instance.AsyncInvoke(() => AddNewLog(args.FullPath));
}
};
watcher.Renamed += (sender, args) =>
{
if (LogFinder.IsLikelyEvtcLog(args.FullPath))
{
Application.Instance.AsyncInvoke(() => AddNewLog(args.FullPath));
}
};
watcher.EnableRaisingEvents = true;
fileSystemWatchers.Add(watcher);
}
catch (Exception e)
{
// TODO: Replace with proper logging
Console.Error.WriteLine($"Failed to set up FileSystemWatcher: {e.Message}");
}
}
}
public void GetLogFile_DirectoryDoesNotExist_ShouldReturnNotFound()
{
//Arrange
const string id = "";
var optionsMock = new Mock <IOptions <LogFinderOptions> >();
optionsMock.Setup(x => x.Value)
.Returns(new LogFinderOptions());
var fileReaderMock = new Mock <IFileReader>();
fileReaderMock
.Setup(x => x.ReadFile(It.IsAny <string>()))
.Returns(new ReadFileResult.FileNotFound());
var logFinder = new LogFinder(optionsMock.Object, fileReaderMock.Object);
//Act
var result = logFinder.GetLogFile(id);
//Assert
result.Should().BeOfType <GetLogFileResult.LogFileNotFound>();
var notFoundResult = result.As <GetLogFileResult.LogFileNotFound>();
}
public void GetLogIndex_TwoFilesExist_ShouldReturnSuccess()
{
//Arrange
var directoryInfo = CreateDirectoryInfo();
var mockOptions = new Mock <IOptions <LogFinderOptions> >();
mockOptions
.Setup(x => x.Value)
.Returns(new LogFinderOptions());
var fileReader = new Mock <IFileReader>();
fileReader
.Setup(x => x.ReadDirectory(It.IsAny <string>()))
.Returns(new ReadDirectoryResult.Success(directoryInfo));
var logFinder = new LogFinder(mockOptions.Object, fileReader.Object);
//Act
var result = logFinder.GetLogIndex();
//Assert
result.Should().BeOfType <LogIndex>();
result.LogFiles.Should().HaveCount(2);
}
public virtual Task Execute(CancellationToken cancellationToken)
{
if (_api.RpcModuleProvider == null)
{
throw new StepDependencyException(nameof(_api.RpcModuleProvider));
}
if (_api.TxPool == null)
{
throw new StepDependencyException(nameof(_api.TxPool));
}
if (_api.BlockTree == null)
{
throw new StepDependencyException(nameof(_api.BlockTree));
}
if (_api.Wallet == null)
{
throw new StepDependencyException(nameof(_api.Wallet));
}
if (_api.SpecProvider == null)
{
throw new StepDependencyException(nameof(_api.SpecProvider));
}
if (_api.TxSender == null)
{
throw new StepDependencyException(nameof(_api.TxSender));
}
ILogger logger = _api.LogManager.GetClassLogger();
IJsonRpcConfig jsonRpcConfig = _api.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 = _api.Config <IInitConfig>();
INdmConfig ndmConfig = _api.Config <INdmConfig>();
IJsonRpcConfig rpcConfig = _api.Config <IJsonRpcConfig>();
IBaselineConfig baselineConfig = _api.Config <IBaselineConfig>();
IVaultConfig vaultConfig = _api.Config <IVaultConfig>();
INetworkConfig networkConfig = _api.Config <INetworkConfig>();
if (ndmConfig.Enabled && !(_api.NdmInitializer is null) && ndmConfig.ProxyEnabled)
{
EthModuleProxyFactory proxyFactory = new EthModuleProxyFactory(_api.EthJsonRpcClientProxy, _api.Wallet);
_api.RpcModuleProvider.Register(new SingletonModulePool <IEthModule>(proxyFactory, true));
if (logger.IsInfo)
{
logger.Info("Enabled JSON RPC Proxy for NDM.");
}
}
else
{
EthModuleFactory ethModuleFactory = new EthModuleFactory(
_api.DbProvider,
_api.TxPool,
_api.TxSender,
_api.Wallet,
_api.BlockTree,
_api.EthereumEcdsa,
_api.MainBlockProcessor,
_api.ReceiptFinder,
_api.SpecProvider,
rpcConfig,
_api.BloomStorage,
_api.LogManager,
initConfig.IsMining);
_api.RpcModuleProvider.Register(new BoundedModulePool <IEthModule>(8, ethModuleFactory));
}
ProofModuleFactory proofModuleFactory = new ProofModuleFactory(_api.DbProvider, _api.BlockTree, _api.RecoveryStep, _api.ReceiptFinder, _api.SpecProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <IProofModule>(2, proofModuleFactory));
DebugModuleFactory debugModuleFactory = new DebugModuleFactory(
_api.DbProvider,
_api.BlockTree,
rpcConfig,
_api.BlockValidator,
_api.RecoveryStep,
_api.RewardCalculatorSource,
_api.ReceiptStorage,
new ReceiptMigration(_api),
_api.ConfigProvider,
_api.SpecProvider,
_api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <IDebugModule>(8, debugModuleFactory));
TraceModuleFactory traceModuleFactory = new TraceModuleFactory(_api.DbProvider, _api.BlockTree, rpcConfig, _api.RecoveryStep, _api.RewardCalculatorSource, _api.ReceiptStorage, _api.SpecProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <ITraceModule>(8, traceModuleFactory));
PersonalModule personalModule = new PersonalModule(
_api.EthereumEcdsa,
_api.Wallet,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IPersonalModule>(personalModule, true));
AdminModule adminModule = new AdminModule(_api.BlockTree, networkConfig, _api.PeerManager, _api.StaticNodesManager, _api.Enode, initConfig.BaseDbPath);
_api.RpcModuleProvider.Register(new SingletonModulePool <IAdminModule>(adminModule, true));
LogFinder logFinder = new LogFinder(
_api.BlockTree,
_api.ReceiptFinder,
_api.BloomStorage,
_api.LogManager,
new ReceiptsRecovery(), 1024);
if (baselineConfig.Enabled)
{
IDbProvider dbProvider = _api.DbProvider !;
IStateReader stateReader = new StateReader(dbProvider.StateDb, dbProvider.CodeDb, _api.LogManager);
BaselineModuleFactory baselineModuleFactory = new BaselineModuleFactory(
_api.TxSender,
stateReader,
logFinder,
_api.BlockTree,
_api.AbiEncoder,
_api.FileSystem,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IBaselineModule>(baselineModuleFactory, true));
if (logger?.IsInfo ?? false)
{
logger !.Info($"Baseline RPC Module has been enabled");
}
}
TxPoolModule txPoolModule = new TxPoolModule(_api.BlockTree, _api.TxPoolInfoProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <ITxPoolModule>(txPoolModule, true));
if (vaultConfig.Enabled)
{
VaultService vaultService = new VaultService(vaultConfig, _api.LogManager);
VaultModule vaultModule = new VaultModule(vaultService, _api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IVaultModule>(vaultModule, true));
if (logger?.IsInfo ?? false)
{
logger !.Info($"Vault RPC Module has been enabled");
}
}
NetModule netModule = new NetModule(_api.LogManager, new NetBridge(_api.Enode, _api.SyncServer));
_api.RpcModuleProvider.Register(new SingletonModulePool <INetModule>(netModule, true));
ParityModule parityModule = new ParityModule(
_api.EthereumEcdsa,
_api.TxPool,
_api.BlockTree,
_api.ReceiptFinder,
_api.Enode,
_api.EngineSignerStore,
_api.KeyStore,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IParityModule>(parityModule, true));
return(Task.CompletedTask);
}
public void GlobalSetup()
{
var dbProvider = TestMemDbProvider.Init();
IDb codeDb = dbProvider.CodeDb;
IDb stateDb = dbProvider.StateDb;
IDb blockInfoDb = new MemDb(10, 5);
ISpecProvider specProvider = MainnetSpecProvider.Instance;
IReleaseSpec spec = MainnetSpecProvider.Instance.GenesisSpec;
var trieStore = new TrieStore(stateDb, LimboLogs.Instance);
StateProvider stateProvider = new StateProvider(trieStore, codeDb, LimboLogs.Instance);
stateProvider.CreateAccount(Address.Zero, 1000.Ether());
stateProvider.Commit(spec);
StorageProvider storageProvider = new StorageProvider(trieStore, stateProvider, LimboLogs.Instance);
StateReader stateReader = new StateReader(trieStore, codeDb, LimboLogs.Instance);
ChainLevelInfoRepository chainLevelInfoRepository = new ChainLevelInfoRepository(blockInfoDb);
BlockTree blockTree = new BlockTree(dbProvider, chainLevelInfoRepository, specProvider, NullBloomStorage.Instance, LimboLogs.Instance);
_blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
_virtualMachine = new VirtualMachine(stateProvider, storageProvider, _blockhashProvider, specProvider, LimboLogs.Instance);
Block genesisBlock = Build.A.Block.Genesis.TestObject;
blockTree.SuggestBlock(genesisBlock);
Block block1 = Build.A.Block.WithParent(genesisBlock).WithNumber(1).TestObject;
blockTree.SuggestBlock(block1);
TransactionProcessor transactionProcessor
= new TransactionProcessor(MainnetSpecProvider.Instance, stateProvider, storageProvider, _virtualMachine, LimboLogs.Instance);
BlockProcessor blockProcessor = new BlockProcessor(specProvider, Always.Valid, new RewardCalculator(specProvider), transactionProcessor,
stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, NullWitnessCollector.Instance, LimboLogs.Instance);
EthereumEcdsa ecdsa = new EthereumEcdsa(specProvider.ChainId, LimboLogs.Instance);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(
blockTree,
blockProcessor,
new RecoverSignatures(
ecdsa,
NullTxPool.Instance,
specProvider,
LimboLogs.Instance),
LimboLogs.Instance,
BlockchainProcessor.Options.NoReceipts);
blockchainProcessor.Process(genesisBlock, ProcessingOptions.None, NullBlockTracer.Instance);
blockchainProcessor.Process(block1, ProcessingOptions.None, NullBlockTracer.Instance);
IBloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
LogFinder logFinder = new LogFinder(
blockTree,
new InMemoryReceiptStorage(),
bloomStorage,
LimboLogs.Instance,
new ReceiptsRecovery(ecdsa, specProvider));
BlockchainBridge bridge = new BlockchainBridge(
new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(dbProvider, false),
trieStore.AsReadOnly(),
new ReadOnlyBlockTree(blockTree),
specProvider,
LimboLogs.Instance),
NullTxPool.Instance,
NullReceiptStorage.Instance,
NullFilterStore.Instance,
NullFilterManager.Instance,
ecdsa,
Timestamper.Default,
logFinder,
false,
false);
_ethModule = new EthModule(
new JsonRpcConfig(),
bridge,
blockTree,
stateReader,
NullTxPool.Instance,
NullTxSender.Instance,
NullWallet.Instance,
LimboLogs.Instance);
}
public virtual Task Execute(CancellationToken cancellationToken)
{
if (_context.RpcModuleProvider == null)
{
throw new StepDependencyException(nameof(_context.RpcModuleProvider));
}
if (_context.TxPool == null)
{
throw new StepDependencyException(nameof(_context.TxPool));
}
if (_context.BlockTree == null)
{
throw new StepDependencyException(nameof(_context.BlockTree));
}
if (_context.Wallet == null)
{
throw new StepDependencyException(nameof(_context.Wallet));
}
if (_context.SpecProvider == null)
{
throw new StepDependencyException(nameof(_context.SpecProvider));
}
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>();
IBaselineConfig baselineConfig = _context.Config <IBaselineConfig>();
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));
LogFinder logFinder = new LogFinder(
_context.BlockTree,
_context.ReceiptFinder,
_context.BloomStorage,
_context.LogManager,
new ReceiptsRecovery(), 1024);
if (baselineConfig.Enabled)
{
BaselineModuleFactory baselineModuleFactory = new BaselineModuleFactory(
_context.TxPool,
logFinder,
_context.BlockTree,
_context.AbiEncoder,
_context.Wallet,
_context.SpecProvider,
_context.FileSystem,
_context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IBaselineModule>(baselineModuleFactory, true));
if (logger?.IsInfo ?? false)
{
logger !.Info($"Baseline RPC Module has been enabled");
}
}
IDepositConfig depositConfig = _context.Config <IDepositConfig>();
if (depositConfig.DepositContractAddress != null)
{
TxPoolBridge txPoolBridge = new TxPoolBridge(
_context.TxPool, new WalletTxSigner(_context.Wallet, _context.SpecProvider.ChainId), _context.Timestamper);
DepositModule depositModule = new DepositModule(txPoolBridge, logFinder, depositConfig, _context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IDepositModule>(depositModule, 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 MainWindow() : base()
{
LogFinder = new LogFinder();
app.LogFinder = LogFinder;
// s.Source = app.Files;
// var d = CollectionViewSource.GetDefaultView(app. );
// int c = (from x in d.SortDescriptions select x).Count();
// app.Files.Add(new Item(null));
// Logger.Trace($"{c}");
InitializeComponent();
Binding binding = new Binding
{
Source = Application.Current,
Path = new PropertyPath("LogWindowType")
};
SetBinding(LogWindowTypeProperty, binding);
// DebugWindow debugWindow = new DebugWindow();
// debugWindow.Show();
foreach (FieldInfo f in typeof(StartupActions).GetFields(
BindingFlags.Static | BindingFlags.Public | BindingFlags.ExactBinding))
{
var fieldValue = f.GetValue(null);
Delegate d = fieldValue as Delegate;
if (d != null)
{
if (!d.GetMethodInfo().GetParameters().Any())
{
Action a = d as Action;
Debug.Assert(a != null);
Task.Run(a);
}
}
}
// ConsoleWindow consoleWindow = new ConsoleWindow();
// consoleWindow.Show();
if (LogWindowType != null)
{
_logWindow = LogWindowType.GetConstructor(Type.EmptyTypes).Invoke(null) as Window;
//_logWindow.ShowActivated = true;
_logWindow.Show();
}
Task.Run(() =>
{
});
ObjectDataProvider o = TryFindResource("DrivesProvider") as ObjectDataProvider;
var typ = o.ObjectInstance.GetType().ToString();
Logger.Info($"{o.ObjectInstance}");
CommandBindings.Add(
app.LogFinder.FindLogsCommandBinding);
CommandManager.AddPreviewExecutedHandler(this, (sender, args) =>
{
CommandConverter con = new CommandConverter();
string cmd = WhatCommand(args.Command);
var convertFrom = con.ConvertToString(args.Command);
//Logger.Info($"{convertFrom} {convertFrom.GetType().FullName}");
Logger.Info(
$" executed {cmd} {args.Parameter} {args.Source} {args.OriginalSource} {args.RoutedEvent}");
});
// CollectionViewSource s = new CollectionViewSource();
// var def = CollectionViewSource.GetDefaultView(LogFinder.Files);
// Logger.Debug($"{def}");
// Logger.Debug($"{def}");
//
//
// CollectionViewSource src = new XCol();
//
// Binding binding = new Binding
// {
// Source = def
// };
//
// FilesListView.SetBinding(ItemsControl.ItemsSourceProperty,binding);
//
// // FilesListView.ItemsSource = app.Files;
// FilesListView.
/* Binding binding = new Binding("FullName")
* {
* Source = this.Files
*
* };
*
* var itemsSourceProperty = ItemsControl.ItemsSourceProperty;
*
* BindingOperations.SetBinding(FilesListView, itemsSourceProperty, binding);
*/
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
var typeInfos = assembly.DefinedTypes.Where((info, i) => info.IsSubclassOf(typeof(TraceSource)));
if (typeInfos.Count() > 0)
{
var s2 = String.Join(" ",
typeInfos);
var @join = s2;
NLog.Logger l = NLog.LogManager.GetLogger(
Path.GetFileName(assembly.Location));
foreach (var t in typeInfos)
{
l.Info(t.Name);
}
//l.Info($"{assembly.Location} {@join}");
}
}
}
