public DeleteMessageBatchResponse DeleteMessageBatch(DeleteMessageBatchRequest request)
{
if (request.Entries == null || request.Entries.Count <= 0)
{
throw new EmptyBatchRequestException("No entires in request");
}
if (request.Entries.Count > SqsQueueDefinition.MaxBatchDeleteItems)
{
throw new TooManyEntriesInBatchRequestException(
$"Count of [{request.Entries.Count}] exceeds limit of [{SqsQueueDefinition.MaxBatchDeleteItems}]");
}
var q = GetQueue(request.QueueUrl);
var response = new DeleteMessageBatchResponse
{
Failed = new List <BatchResultErrorEntry>(),
Successful = new List <DeleteMessageBatchResultEntry>()
};
var entryIds = new HashSet <string>();
foreach (var entry in request.Entries)
{
var success = false;
BatchResultErrorEntry batchError = null;
try
{
if (entryIds.Contains(entry.Id))
{
throw new BatchEntryIdsNotDistinctException($"Duplicate Id of [{entry.Id}]");
}
entryIds.Add(entry.Id);
success = q.DeleteMessage(new DeleteMessageRequest
{
QueueUrl = request.QueueUrl,
ReceiptHandle = entry.ReceiptHandle
});
}
catch (ReceiptHandleIsInvalidException rhex)
{
batchError = new BatchResultErrorEntry
{
Id = entry.Id,
Message = rhex.Message,
Code = rhex.ErrorCode
};
}
catch (MessageNotInflightException mfex)
{
batchError = new BatchResultErrorEntry
{
Id = entry.Id,
Message = mfex.Message,
Code = mfex.ErrorCode
};
}
if (success)
{
response.Successful.Add(new DeleteMessageBatchResultEntry
{
Id = entry.Id
});
}
else
{
var entryToQueue = batchError ?? new BatchResultErrorEntry
{
Id = entry.Id,
Message = "FakeDeleteError",
Code = "456"
};
response.Failed.Add(entryToQueue);
}
}
return(response);
}
public Task <DeleteMessageBatchResponse> DeleteMessageBatchAsync(DeleteMessageBatchRequest request, CancellationToken token = default(CancellationToken))
{
return(DeleteMessageBatch(request).AsTaskResult());
}
public override async Task <DeleteMessageBatchResponse> DeleteMessageBatchAsync(DeleteMessageBatchRequest deleteMessageBatchRequest, CancellationToken cancellationToken = default(CancellationToken))
{
if (deleteMessageBatchRequest == null)
{
throw new AmazonClientException("deleteMessageBatchRequest cannot be null");
}
if (!clientConfiguration.IsLargePayloadSupportEnabled)
{
return(await base.DeleteMessageBatchAsync(deleteMessageBatchRequest, cancellationToken).ConfigureAwait(false));
}
foreach (var entry in deleteMessageBatchRequest.Entries.Where(entry => IsS3ReceiptHandle(entry.ReceiptHandle)))
{
if (!clientConfiguration.RetainS3Messages)
{
await DeleteMessagePayloadFromS3Async(entry.ReceiptHandle, cancellationToken).ConfigureAwait(false);
}
entry.ReceiptHandle = GetOriginalReceiptHandle(entry.ReceiptHandle);
}
return(await base.DeleteMessageBatchAsync(deleteMessageBatchRequest, cancellationToken));
}
public Task <DeleteMessageBatchResponse> DeleteMessageBatchAsync(DeleteMessageBatchRequest request, CancellationToken cancellationToken = new CancellationToken())
{
throw new System.NotImplementedException();
}
public static DeleteMessageBatchResponse DeleteMessageBatch(this IAmazonSQS client, DeleteMessageBatchRequest request)
{
return(client.DeleteMessageBatchAsync(request).GetResult());
}
public virtual Task <DeleteMessageBatchResponse> DeleteMessageBatchAsync(DeleteMessageBatchRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
return(amazonSqsToBeExtended.DeleteMessageBatchAsync(request, cancellationToken));
}
public DeleteMessageBatchResponse DeleteMessageBatch(DeleteMessageBatchRequest request)
{
throw new System.NotImplementedException();
}
public virtual async Task <DeleteMessageBatchResponse> DeleteMessageBatchAsync(DeleteMessageBatchRequest deleteMessageBatchRequest)
{
var deleteMessageResponse = await _amazonSqsClient.DeleteMessageBatchAsync(deleteMessageBatchRequest);
return(deleteMessageResponse);
}
public async Task <bool> DeleteMessagesAsync <T>(IEnumerable <MessageEntry <T> > messages, string queueUrl = "") where T : IIdentifiable <string>
{
try
{
var queueEndpoint = GetQueueEndpoint(queueUrl);
int pageSize = 10;
int messagesCount = 0;
int totalMessages = messages.Count();
IList <Task <DeleteMessageBatchResponse> > responseTasks = new List <Task <DeleteMessageBatchResponse> >();
while (messagesCount < totalMessages)
{
var requests = new List <DeleteMessageBatchRequestEntry>();
int currentMessagesCount = 0;
int objIndex = messagesCount;
while (objIndex < totalMessages && currentMessagesCount < pageSize)
{
var message = messages.ElementAt(objIndex);
requests.Add(new DeleteMessageBatchRequestEntry
{
Id = message.Id,
ReceiptHandle = message.ReceiptHandle
});
currentMessagesCount++;
objIndex = messagesCount + currentMessagesCount;
}
var request = new DeleteMessageBatchRequest(queueEndpoint, requests);
var responseTask = _amazonSQS.DeleteMessageBatchAsync(request);
responseTasks.Add(responseTask);
messagesCount += requests.Count;
}
IEnumerable <DeleteMessageBatchResponse> responses = await Task.WhenAll(responseTasks);
foreach (var response in responses)
{
if (response.HttpStatusCode != HttpStatusCode.OK)
{
throw new Exception($"Error deleting message. HttpStatusCode: {response.HttpStatusCode}");
}
if (response.Failed?.Any() == true)
{
throw new Exception($"Error deleting message. Code: {response.Failed[0].Code}. Error: {response.Failed[0].Message}");
}
}
}
catch (Exception ex)
{
throw new Exception($"Error to delete messages. {ex.Message}");
}
return(true);
}
public DeleteMessageBatchResponse DeleteMessageBatch(DeleteMessageBatchRequest request) => throw new NotImplementedException();
public abstract Task <DeleteMessageBatchResponse> DeleteMessageBatchAsync(DeleteMessageBatchRequest request, CancellationToken cancellationToken = default);
public virtual DeleteMessageBatchResponse DeleteMessageBatch(DeleteMessageBatchRequest request)
{
return(amazonSqsToBeExtended.DeleteMessageBatch(request));
}
