public async Task CanUseCustomMessageMapper()
{
var subscription = new Mock <IEventSubscription>();
var queue = new Mock <IQueue>();
var messageToQueue = new object();
var customMapper = new QueueMessageMapper(decodedEvent => messageToQueue);
var handler = new QueueHandler(subscription.Object, 99, queue.Object, customMapper);
var decodedLog = DecodedEvent.Empty();
object actualQueueMessage = null;
queue
.Setup(q => q.AddMessageAsync(It.IsAny <object>()))
.Callback <object>((msg) => actualQueueMessage = msg)
.Returns(Task.CompletedTask);
var result = await handler.HandleAsync(decodedLog);
Assert.True(result);
Assert.Same(messageToQueue, actualQueueMessage);
}
public async Task WritingCustomMessagesToTheQueue()
{
// Load config
// - this will contain the secrets and connection strings we don't want to hard code
var config = TestConfiguration.LoadConfig();
string azureStorageConnectionString = config["AzureStorageConnectionString"];
// Create a proxy for the blockchain
var web3 = new Web3.Web3(TestConfiguration.BlockchainUrls.Infura.Mainnet);
// Create Queue Factory
// - In this sample we're targetting Azure
// - The factory communicates with Azure to create and get different queues
var queueFactory = new AzureSubscriberQueueFactory(azureStorageConnectionString);
// Create a Queue
// - This is where we're going to put the matching event logs
var queue = await queueFactory.GetOrCreateQueueAsync("makerdaotransferscustom");
// Create an event subscription specifically for ERC20 Transfers
// - Passing in the maker dao address to ensure only logs with a matching address are processed
// - There is an option to pass an implementation of IEventHandlerHistoryRepository in to the constructor
// - This would record history for each event handler and is used to prevent duplication
var eventSubscription = new EventSubscription <TransferEventDto>(
contractAddressesToMatch: new[] { MAKER_CONTRACT_ADDRESS });
// Create a mapper that will convert the DecodedEvent into a custom message we want on the queue
// In this sample we're using a subscription that is specific to an EventDTO (EventSubscription<TransferEventDto>)
// This ensures that the decodedEvent.DecodedEventDto property is populated during processing
// ( If the subscription is not tied to an EventDTO the decodedEvent.DecodedEventDto property would be null
// BUT we can still read the event arguments (aka parameters or topics) from the decodedEvent.Event property)
var queueMessageMapper = new QueueMessageMapper((decodedEvent) =>
{
return(new CustomQueueMessageForTransfers
{
BlockNumber = decodedEvent.Log.BlockNumber.Value.ToString(),
TransactionHash = decodedEvent.Log.TransactionHash,
LogIndex = decodedEvent.Log.LogIndex.Value.ToString(),
Transfer = decodedEvent.DecodedEventDto as TransferEventDto
});
});
// Assign the queue to the event subscription
// - Matching events will be written to this queue
// - Pass a custom mapper to create a suitable queue message
// - Ultimately the message is converted to json
eventSubscription.AddQueueHandler(queue, queueMessageMapper);
// Azure storage setup
// - this example reads and writes block progress to an Azure storage table
// - to avoid collision with other samples we provide a prefix
var storageCloudSetup = new CloudTableSetup(azureStorageConnectionString, prefix: $"makerdaotransferscustom");
// Create a progress repository
// - It stores and retrieves the most recent block processed
var blockProgressRepo = storageCloudSetup.CreateBlockProgressRepository();
// Create a progress service
// - This uses the progress repo to dictate what blocks to process next
// - The MIN_BLOCK_NUMBER dictates the starting point if the progress repo is empty or has fallen too far behind
var progressService = new BlockProgressService(web3, MIN_BLOCK_NUMBER, blockProgressRepo);
// Create a filter
// - This is essentially the query that is sent to the chain when retrieving logs
// - It is OPTIONAL - without it, all logs in the block range are requested
// - The filter is invoked before any event subscriptions evaluate the logs
// - The subscriptions are free to implement their own matching logic
// - In this sample we're only interested in MakerDAO logs
// - Therefore it makes sense to restrict the number of logs to retrieve from the chain
var makerAddressFilter = new NewFilterInput()
{
Address = new[] { MAKER_CONTRACT_ADDRESS }
};
// Create a log processor
// - This uses the blockchainProxy to get the logs
// - It sends each log to the event subscriptions to indicate if the logs matches the subscription criteria
// - It then allocates matching logs to separate batches per event subscription
var logProcessor = new BlockRangeLogsProcessor(web3, new[] { eventSubscription }, makerAddressFilter);
// Create a batch log processor service
// - It uses the progress service to calculates the block range to progress
// - It then invokes the log processor - passing in the range to process
// - It updates progress via the progress service
var batchProcessorService = new LogsProcessor(logProcessor, progressService, MAX_BLOCKS_PER_BATCH);
// execute
try
{
// Optional cancellation token
// - Useful for cancelling long running processing operations
var ctx = new System.Threading.CancellationTokenSource();
// instruct the service to get and process the next range of blocks
// when the rangeProcessed is null - it means there was nothing to process
var rangeProcessed = await batchProcessorService.ProcessOnceAsync(ctx.Token);
// ensure we have processed the expected number of events
// the event subscription has state which can record running totals across many processing batches
Assert.Equal(11, eventSubscription.State.GetInt("EventsHandled"));
// get the message count from the queue
Assert.Equal(11, await queue.GetApproxMessageCountAsync());
//A sample message body from the queue
/*
* {"BlockNumber":"7540010","TransactionHash":"0x8d58abc578f5e321f2e6b7c0637ccc60fbf62b39b120691cbf19ff201f5069b0","LogIndex":"132","Transfer":{"From":"0x296c61eaf5bea208bbabc65ae01c3bc5270fe386","To":"0x2a8f1a6af55b705b7daee0776d6f97302de2a839","Value":119928660890733235}}
*/
}
finally
{
// delete any data from Azure
await ClearDown(queue, storageCloudSetup, queueFactory);
}
}