private DeleteMessageBatchRequest GetBatchMessageRequest(List <Message> messages)
        {
            var batchDelete = new DeleteMessageBatchRequestEntry[messages.Count];

            for (int i = 0; i < messages.Count; i++)
            {
                batchDelete[i] = new DeleteMessageBatchRequestEntry(messages[i].MessageId, messages[i].ReceiptHandle);
            }
            return(new DeleteMessageBatchRequest(_config["AwsSqs:QueueUrl"], batchDelete.ToList()));
        }
        private DeleteMessageBatchRequest BuildDeleteMessageBatchRequest(IEnumerable <string> ids)
        {
            var deleteMessageBatchRequest =
                new DeleteMessageBatchRequest {
                QueueUrl = _queueUrl, Entries = new List <DeleteMessageBatchRequestEntry>()
            };

            foreach (var id in ids)
            {
                var entry = new DeleteMessageBatchRequestEntry(Guid.NewGuid().ToString(), id);
                deleteMessageBatchRequest.Entries.Add(entry);
            }

            return(deleteMessageBatchRequest);
        }
        /// <summary>
        /// Processes the events that defines loans updates.
        /// </summary>
        /// <param name="input"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task FunctionHandler(SQSEvent input, ILambdaContext context)
        {
            ILogger logger            = new LambdaLoggerWrapper();
            var     processor         = new SnapshotGenerationUseCase(logger, new DynamoDbLoanRepository(logger));
            var     processedMessages = new List <DeleteMessageBatchRequestEntry>();
            var     exceptions        = new List <Exception>();

            foreach (var record in input.Records)
            {
                try
                {
                    string eventType = record.Attributes.SingleOrDefault(s => s.Key == "EventType").Value;
                    var    @event    = new Event(record.Attributes.SingleOrDefault(s => s.Key == "LoanId").Value,
                                                 record.MessageId,
                                                 eventType,
                                                 long.Parse(record.Attributes.SingleOrDefault(s => s.Key == "SentTimestamp").Value),
                                                 record.Body);

                    await processor.Process(@event);

                    var processedMessageToBeDeleted = new DeleteMessageBatchRequestEntry
                    {
                        Id            = record.MessageId,
                        ReceiptHandle = record.ReceiptHandle
                    };
                    processedMessages.Add(processedMessageToBeDeleted);
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                }
            }
            await RemoveProcessedMessagesFromQueue(processedMessages);

            if (exceptions.Count > 0)
            {
                throw new AggregateException(exceptions);
            }
        }
Beispiel #4
0
        public Task Delete(string receiptHandle, CancellationToken cancellationToken)
        {
            var entry = new DeleteMessageBatchRequestEntry("", receiptHandle);

            return(_batchDeleter.Execute(entry, cancellationToken));
        }
Beispiel #5
0
        public static void SQSDeleteMessageBatch()
        {
            #region SQSDeleteMessageBatch
            var client = new AmazonSQSClient();

            var request = new ReceiveMessageRequest
            {
                AttributeNames = new List <string>()
                {
                    "All"
                },
                MaxNumberOfMessages = 5,
                QueueUrl            = "https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyTestQueue",
                VisibilityTimeout   = (int)TimeSpan.FromMinutes(10).TotalSeconds,
                WaitTimeSeconds     = (int)TimeSpan.FromSeconds(5).TotalSeconds
            };

            var response     = client.ReceiveMessage(request);
            var batchEntries = new List <DeleteMessageBatchRequestEntry>();

            if (response.Messages.Count > 0)
            {
                foreach (var message in response.Messages)
                {
                    var batchEntry = new DeleteMessageBatchRequestEntry
                    {
                        Id            = message.MessageId,
                        ReceiptHandle = message.ReceiptHandle
                    };

                    batchEntries.Add(batchEntry);
                }

                var delRequest = new DeleteMessageBatchRequest
                {
                    Entries  = batchEntries,
                    QueueUrl = "https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyTestQueue"
                };

                var delResponse = client.DeleteMessageBatch(delRequest);

                if (delResponse.Failed.Count > 0)
                {
                    Console.WriteLine("Failed deletions:");

                    foreach (var failure in delResponse.Failed)
                    {
                        Console.WriteLine("  For ID '" + failure.Id + "': ");
                        Console.WriteLine("    Code = " + failure.Code);
                        Console.WriteLine("    Message = " + failure.Message);
                        Console.WriteLine("    Sender's fault? = " + failure.SenderFault);
                    }
                }

                if (delResponse.Successful.Count > 0)
                {
                    Console.WriteLine("Successful deletions:");

                    foreach (var success in delResponse.Successful)
                    {
                        Console.WriteLine("  ID '" + success.Id + "'");
                    }
                }
            }
            else
            {
                Console.WriteLine("No messages to delete.");
            }
            #endregion

            Console.ReadLine();
        }