public async Task WillSwallowDecodingErrorsAndIgnoreLog()
{
var indexer = new Mock <IEventIndexer <TransferEvent> >();
var indexedLogs = new List <EventLog <TransferEvent> >();
indexer.Setup(i => i.IndexAsync(It.IsAny <IEnumerable <EventLog <TransferEvent> > >()))
.Returns <IEnumerable <EventLog <TransferEvent> > >(
logs => { indexedLogs.AddRange(logs); return(Task.CompletedTask); });
var processor = new EventIndexProcessor <TransferEvent>(indexer.Object, logsPerIndexBatch: 10);
var topicsForAnotherEvent = new object[]
{
"0xEdf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
"0x0000000000000000000000000000000000000000000000000000000000000000",
"0x000000000000000000000000c14934679e71ef4d18b6ae927fe2b953c7fd9b91",
"0x0000000000000000000000000000000000000000000000400000402000000001"
};
await processor.ProcessLogsAsync(new[] { new FilterLog {
Topics = topicsForAnotherEvent
} });
Assert.Empty(indexedLogs);
Assert.Equal(0, processor.Pending);
}
public async Task SendsToIndexerInBatchesAndSendsAnyPendingOnDispose()
{
var indexer = new Mock <IEventIndexer <TransferEvent> >();
var indexedLogs = new List <EventLog <TransferEvent> >();
indexer.Setup(i => i.IndexAsync(It.IsAny <IEnumerable <EventLog <TransferEvent> > >()))
.Returns <IEnumerable <EventLog <TransferEvent> > >(
logs => { indexedLogs.AddRange(logs); return(Task.CompletedTask); });
var processor = new EventIndexProcessor <TransferEvent>(indexer.Object, logsPerIndexBatch: 10);
var topics = new object[]
{
"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
"0x0000000000000000000000000000000000000000000000000000000000000000",
"0x000000000000000000000000c14934679e71ef4d18b6ae927fe2b953c7fd9b91",
"0x0000000000000000000000000000000000000000000000400000402000000001"
};
for (var i = 0; i < 25; i++)
{
var log = new FilterLog {
Topics = topics
};
await processor.ProcessLogsAsync(new[] { log });
}
Assert.Equal(20, indexedLogs.Count);
Assert.Equal(5, processor.Pending);
processor.Dispose();
Assert.Equal(25, indexedLogs.Count);
Assert.Equal(0, processor.Pending);
}
public static ILogsProcessorBuilder AddToSearchIndex <TEventDto>(
this ILogsProcessorBuilder processorBuilder,
IEventIndexer <TEventDto> indexer,
Predicate <EventLog <TEventDto> > predicate = null) where TEventDto : class, new()
{
var processor = new EventIndexProcessor <TEventDto>(indexer, predicate: predicate);
processorBuilder.Add(processor);
return(processorBuilder);
}
public async Task AddEventAsync <TEvent>(string indexName = null) where TEvent : class, new()
{
var index = await SearchService.GetOrCreateEventIndex <TEvent>(indexName);
_indexers.Add(index);
var processor = new EventIndexProcessor <TEvent>(index);
_logProcessors.Add(processor);
}
public async Task IsLogForEvent()
{
var indexer = new Mock <IEventIndexer <TransferEvent> >();
var processor = new EventIndexProcessor <TransferEvent>(indexer.Object);
var transferLog = new FilterLog {
Topics = new object[] { TransferEvent.Signature() }
};
var irrelevantLog = new FilterLog {
Topics = new object[] { "SignatureForAnotherEvent" }
};
Assert.True(processor.IsLogForEvent(transferLog));
Assert.False(processor.IsLogForEvent(irrelevantLog));
}
public async Task UsingTheIndividualComponents()
{
TransferMetadata.CurrentChainUrl = BlockchainUrl;
var web3 =
new Web3.Web3(BlockchainUrl);
using (var azureSearchService = new AzureSearchService(AzureSearchServiceName, _azureSearchApiKey))
{
await azureSearchService.DeleteIndexAsync(AzureTransferIndexName);
try
{
using (var transferIndexer =
await azureSearchService.CreateEventIndexer <TransferEvent_ERC20>(AzureTransferIndexName))
{
using (var transferProcessor =
new EventIndexProcessor <TransferEvent_ERC20>(transferIndexer))
{
var logProcessor = new BlockRangeLogsProcessor(
web3.Eth.Filters.GetLogs,
new ILogProcessor[] { transferProcessor });
var progressRepository =
new JsonBlockProgressRepository(CreateJsonFileToHoldProgress());
var progressService = new StaticBlockRangeProgressService(
3146684, 3146694, progressRepository);
var batchProcessorService = new LogsProcessor(
logProcessor, progressService, maxNumberOfBlocksPerBatch: 2);
BlockRange?lastBlockRangeProcessed;
do
{
lastBlockRangeProcessed = await batchProcessorService.ProcessOnceAsync();
} while (lastBlockRangeProcessed != null);
Assert.Equal(19, transferIndexer.Indexed);
}
}
}
finally
{
await azureSearchService.DeleteIndexAsync(AzureTransferIndexName);
}
}
}
public async Task CustomComposition()
{
TransferMetadata.CurrentChainUrl = BlockchainUrl;
var blockchainProxyService =
new BlockchainProxyService(BlockchainUrl);
using (var azureSearchService = new AzureSearchService(AzureSearchServiceName, _azureSearchApiKey))
{
await azureSearchService.DeleteIndexAsync(AzureTransferIndexName);
using (var transferIndexer = await azureSearchService.GetOrCreateEventIndex <TransferEvent_ERC20>(AzureTransferIndexName))
{
using (var transferProcessor =
new EventIndexProcessor <TransferEvent_ERC20>(transferIndexer))
{
var logProcessor = new BlockchainLogProcessor(
blockchainProxyService,
new ILogProcessor[] { transferProcessor });
var progressRepository =
new JsonBlockProgressRepository(CreateJsonFileToHoldProgress());
var progressService = new StaticBlockRangeProgressService(
3146684, 3146694, progressRepository);
var batchProcessorService = new BlockchainBatchProcessorService(
logProcessor, progressService, maxNumberOfBlocksPerBatch: 2);
BlockRange?lastBlockRangeProcessed;
do
{
lastBlockRangeProcessed = await batchProcessorService.ProcessLatestBlocksAsync();
} while (lastBlockRangeProcessed != null);
Assert.Equal(19, transferIndexer.Indexed);
}
}
await azureSearchService.DeleteIndexAsync(AzureTransferIndexName);
}
}
