|
public DeleteMessageAsync ( |
||
| request | Container for the necessary parameters to execute the DeleteMessage operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| Résultat | Task |
|
public async Task ConsumeAsync(int maxMessages = 5, CancellationToken token = default)
{
Console.WriteLine("\nConsuming messages:");
using (var client = new Amazon.SQS.AmazonSQSClient(accessKey, secretKey, region))
{
var queueUrlResult = await client.GetQueueUrlAsync(queueName, token);
var queueUrl = queueUrlResult.QueueUrl;
while (true)
{
/// Console.WriteLine("Fetching messages:");
var req = new ReceiveMessageRequest(queueUrl);
req.WaitTimeSeconds = 20; // long pooling
req.MaxNumberOfMessages = maxMessages;
var r = await client.ReceiveMessageAsync(req, token);
if (r.Messages.Count > 0)
{
foreach (var m in r.Messages)
{
Console.WriteLine("[" + DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss.fff") + "] [C] " + m.Body + " | " + m.MessageId);
// ack
await client.DeleteMessageAsync(queueUrl, m.ReceiptHandle);
}
}
}
}
}
public void Acknowledge(Message message)
{
if(!message.Header.Bag.ContainsKey("ReceiptHandle"))
return;
var receiptHandle = message.Header.Bag["ReceiptHandle"].ToString();
try
{
using (var client = new AmazonSQSClient())
{
client.DeleteMessageAsync(new DeleteMessageRequest(_queueUrl, receiptHandle));
_logger.InfoFormat("SqsMessageConsumer: Deleted the message {0} with receipt handle {1} on the queue {2}", message.Id, receiptHandle, _queueUrl);
}
}
catch (Exception exception)
{
_logger.ErrorException("SqsMessageConsumer: Error during deleting the message {0} with receipt handle {1} on the queue {2}", exception, message.Id, receiptHandle, _queueUrl);
throw;
}
}
/// <summary>
/// Rejects the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="requeue">if set to <c>true</c> [requeue].</param>
public void Reject(Message message, bool requeue)
{
if (!message.Header.Bag.ContainsKey("ReceiptHandle"))
return;
var receiptHandle = message.Header.Bag["ReceiptHandle"].ToString();
try
{
_logger.Value.InfoFormat("SqsMessageConsumer: Rejecting the message {0} with receipt handle {1} on the queue {2} with requeue paramter {3}", message.Id, receiptHandle, _queueUrl, requeue);
using (var client = new AmazonSQSClient(_credentials))
{
if (requeue)
{
client.ChangeMessageVisibilityAsync(new ChangeMessageVisibilityRequest(_queueUrl, receiptHandle, 0)).Wait();
}
else
{
client.DeleteMessageAsync(_queueUrl, receiptHandle).Wait();
}
}
_logger.Value.InfoFormat("SqsMessageConsumer: Message {0} with receipt handle {1} on the queue {2} with requeue paramter {3} has been rejected", message.Id, receiptHandle, _queueUrl, requeue);
}
catch (Exception exception)
{
_logger.Value.ErrorException("SqsMessageConsumer: Error during rejecting the message {0} with receipt handle {1} on the queue {2}", exception, message.Id, receiptHandle, _queueUrl);
throw;
}
}
/// <summary>
/// The main entrypoint for the thread that listens to messages.
/// </summary>
private void AWSMessageListener()
{
// Used to eliminate over logging
bool receivedMessage = true;
while (!stopping)
{
try
{
var receiveMessageRequest = new SQS.Model.ReceiveMessageRequest()
{
WaitTimeSeconds = 10,
QueueUrl = sqsQueueUrl
};
if (receivedMessage)
{
Logger.LogTrace("Waiting for message from queue");
}
receivedMessage = false;
var messageResponse = AsyncTaskHelper.RunSync(() => sqsClient.ReceiveMessageAsync(receiveMessageRequest));
if (messageResponse.HttpStatusCode == HttpStatusCode.OK &&
messageResponse.Messages.Count > 0 &&
!stopping)
{
receivedMessage = true;
Logger.LogDebug($"Received {messageResponse.Messages.Count} message(s)");
foreach (var messageResponseMessage in messageResponse.Messages)
{
try
{
ProcessMessage(messageResponseMessage);
}
finally
{
#if (!DONTDELETEMESSAGE)
// Delete the message even in error since it will keep coming back
// Perhaps a better action would be to put in a dead letter queue
DeleteMessage(messageResponseMessage);
#endif
}
}
}
}
catch (Exception ex)
{
Logger.LogError("Error processing message: {0}", ex);
}
}
// Process the received message
void ProcessMessage(SQS.Model.Message messageResponseMessage)
{
Logger.LogTrace($"Received Message ({messageResponseMessage.MessageId}): {messageResponseMessage.Body}");
var snsMessage = SNS.Util.Message.ParseMessage(messageResponseMessage.Body);
var feedEvent = JsonConvert.DeserializeObject <FeedEvent>(snsMessage.MessageText);
Logger.LogInformation($"Feed: {feedEvent.Feed}, Event: {feedEvent.Event}, Package: {feedEvent.Package}, Version: {feedEvent.Version}");
Logger.LogTrace($"Package URL: {feedEvent.PackageUrl}");
var actionableActions =
ApplicationSettings.Actions.Where(action => string.Equals(action.SourceFeed, feedEvent.Feed, StringComparison.InvariantCultureIgnoreCase) && action.Enabled);
Package retrievedPackage = null;
foreach (var actionableAction in actionableActions)
{
Logger.LogTrace($"Found Action ({actionableAction.Name}) for {feedEvent.Feed}");
if (feedEvent.Version.IsPrerelease() && !actionableAction.IncludePrerelease)
{
Logger.LogDebug($"{actionableAction.Name} is ignoring prelease package ({feedEvent.Package}.{feedEvent.Version})");
continue;
}
using (var scope = ServiceProvider.CreateScope())
{
var action = ActionProcessor.CreateAction(scope, actionableAction);
switch (feedEvent.Event)
{
case EventType.Added:
if (retrievedPackage == null)
{
retrievedPackage = AsyncTaskHelper.RunSync(() => action.SourceRepository.FetchAsync(feedEvent.Package, feedEvent.Version));
}
if (retrievedPackage == null)
{
Logger.LogWarning($"{feedEvent.Package}.{feedEvent.Version} not found in feed {feedEvent.Feed}. Ignoring.");
}
else
{
AsyncTaskHelper.RunSync(() => action.ProcessPackageAsync(retrievedPackage, PackageEvent.Added));
}
break;
case EventType.Deleted:
case EventType.Purged:
// We can't retrieve the package because it has been deleted
var deletePackage = new Package
{
Id = feedEvent.Package,
Version = feedEvent.Version
};
AsyncTaskHelper.RunSync(() => action.ProcessPackageAsync(deletePackage, PackageEvent.Deleted));
break;
}
}
}
}
#if (!DONTDELETEMESSAGE)
// Delete the processed message from the queue
void DeleteMessage(SQS.Model.Message messageResponseMessage)
{
var deleteMessageRequest = new SQS.Model.DeleteMessageRequest
{
QueueUrl = sqsQueueUrl,
ReceiptHandle = messageResponseMessage.ReceiptHandle
};
Logger.LogTrace($"Deleting Message: {messageResponseMessage.ReceiptHandle}");
var deleteMessageResponse = AsyncTaskHelper.RunSync(() => sqsClient.DeleteMessageAsync(deleteMessageRequest));
if (deleteMessageResponse.HttpStatusCode == HttpStatusCode.OK)
{
Logger.LogTrace($"Delete Message: {messageResponseMessage.ReceiptHandle}");
}
else
{
Logger.LogWarning($"Unable to delete Message: {messageResponseMessage.ReceiptHandle}. Ignoring.");
}
}
#endif
}
