/// <inheritdoc /> public async Task <DateTime> RenewAsync(WorkItem item, CancellationToken cancellationToken) { var lockExpiration = (item.VisibleOn ?? DateTime.UtcNow).AddSeconds(_visibilityTimeout); await _client.ChangeMessageVisibilityAsync(_queueUrl, item.Token, _visibilityTimeout, cancellationToken); return(lockExpiration); }
/// <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> /// Requeues the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="delayMilliseconds">Number of milliseconds to delay delivery of the message.</param> /// <returns>True if the message was requeued successfully</returns> public bool Requeue(Message message, int delayMilliseconds) { if (!message.Header.Bag.ContainsKey("ReceiptHandle")) { return(false); } var receiptHandle = message.Header.Bag["ReceiptHandle"].ToString(); try { s_logger.LogInformation("SqsMessageConsumer: re-queueing the message {Id}", message.Id); using (var client = new AmazonSQSClient(_awsConnection.Credentials, _awsConnection.Region)) { var urlResponse = client.GetQueueUrlAsync(_queueName).Result; client.ChangeMessageVisibilityAsync(new ChangeMessageVisibilityRequest(urlResponse.QueueUrl, receiptHandle, 0)).Wait(); } s_logger.LogInformation("SqsMessageConsumer: re-queued the message {Id}", message.Id); return(true); } catch (Exception exception) { s_logger.LogError(exception, "SqsMessageConsumer: Error during re-queueing the message {Id} with receipt handle {ReceiptHandle} on the queue {ChannelName}", message.Id, receiptHandle, _queueName); return(false); } }
public async Task <JobDetail> GetJobFromSQS(string sqsQueueUrl) { //Build message request, only get one message var receiveMessageRequest = new ReceiveMessageRequest() { QueueUrl = sqsQueueUrl, MaxNumberOfMessages = 1 }; var receiveMessageResponse = await sqsClient.ReceiveMessageAsync(receiveMessageRequest); if (receiveMessageResponse.Messages.Count > 0) { System.Console.WriteLine($"Info: GetSQS, MessageID: {receiveMessageResponse.Messages.FirstOrDefault().MessageId}"); //Change visibility of message so that nothing else picks up the same job await sqsClient.ChangeMessageVisibilityAsync(sqsQueueUrl, receiveMessageResponse.Messages.FirstOrDefault().ReceiptHandle, 40000); Message msg = receiveMessageResponse.Messages.FirstOrDefault(); var jobDetail = JsonConvert.DeserializeObject <JobDetail>(msg.Body); jobDetail.MessageId = msg.MessageId; jobDetail.ReceiptHandle = msg.ReceiptHandle; return(jobDetail); } else { return(null); } }
public async Task ChangeMessageVisibility() { // Create service client using the SDK's default logic for determining AWS credentials and region to use. // For information configuring service clients checkout the .NET developer guide: https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config.html AmazonSQSClient client = new AmazonSQSClient(); string queueUrl = "SQS_QUEUE_URL"; var receiveMessageRequest = new ReceiveMessageRequest { AttributeNames = { "SentTimestamp" }, MaxNumberOfMessages = 1, MessageAttributeNames = { "All" }, QueueUrl = queueUrl }; var response = await client.ReceiveMessageAsync(receiveMessageRequest); var changeMessageVisibilityRequest = new ChangeMessageVisibilityRequest { QueueUrl = queueUrl, ReceiptHandle = response.Messages[0].ReceiptHandle, VisibilityTimeout = 36000, // 10 hour timeout }; await client.ChangeMessageVisibilityAsync(changeMessageVisibilityRequest); }
/// <summary> /// Requeues the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="delayMilliseconds">Number of milliseconds to delay delivery of the message.</param> public void Requeue(Message message, int delayMilliseconds) { if (!message.Header.Bag.ContainsKey("ReceiptHandle")) { return; } var receiptHandle = message.Header.Bag["ReceiptHandle"].ToString(); try { _logger.Value.InfoFormat("SqsMessageConsumer: requeueing the message {0}", message.Id); using (var client = new AmazonSQSClient(_awsConnection.Credentials, _awsConnection.Region)) { var urlResponse = client.GetQueueUrlAsync(_queueName).Result; client.ChangeMessageVisibilityAsync(new ChangeMessageVisibilityRequest(urlResponse.QueueUrl, receiptHandle, 0)).Wait(); } _logger.Value.InfoFormat("SqsMessageConsumer: requeued the message {0}", message.Id); } catch (Exception exception) { _logger.Value.ErrorException("SqsMessageConsumer: Error during requeing the message {0} with receipt handle {1} on the queue {2}", exception, message.Id, receiptHandle, _queueName); throw; } }
public async Task ReturnMessageToQueue(string queueName, string messageId) { var changeMessageVisibilityRequest = new ChangeMessageVisibilityRequest() { QueueUrl = QueueUrlFactory(queueName), ReceiptHandle = messageId, VisibilityTimeout = 0 }; await _sqsClient.ChangeMessageVisibilityAsync(changeMessageVisibilityRequest); }
public override async Task RenewLockAsync(MessageEnvelope message, long lockTimeout) { CheckOpened(message.CorrelationId); // Extend the message visibility var envelope = (Message)message.Reference; if (envelope != null) { var request = new ChangeMessageVisibilityRequest() { QueueUrl = _queue, ReceiptHandle = envelope.ReceiptHandle, VisibilityTimeout = (int)(lockTimeout / 1000) }; await _client.ChangeMessageVisibilityAsync(request, _cancel.Token); _logger.Trace(message.CorrelationId, "Renewed lock for message {0} at {1}", message, this); } }
/// <summary> /// add some time so that we can continue to work on this message /// </summary> /// <param name="recieptHandle"></param> /// <param name="extensionInSeconds"></param> /// <param name="highPriority"></param> /// <returns></returns> public bool ExtendMessageOwnerShip(string recieptHandle, int extensionInSeconds) { ChangeMessageVisibilityRequest changeMessageVisibilityRequest = new ChangeMessageVisibilityRequest { ReceiptHandle = recieptHandle, VisibilityTimeout = extensionInSeconds, QueueUrl = _QueueUrl }; ChangeMessageVisibilityResponse ignoreThis = _AmazonSQSClient.ChangeMessageVisibilityAsync(changeMessageVisibilityRequest).Result; return(ignoreThis.HttpStatusCode == System.Net.HttpStatusCode.OK); }
public void ReleaseWorkItem(WorkItemInfo workItem) { string queueSuffix = workItem.WorkerType; string finalQueueName; AmazonSQSClient sqsClient = constructSqsClient(ConfigurationManager.AppSettings[AWSSQSConfigOptions.AWSQueueURL], queueSuffix, out finalQueueName); var resTask = sqsClient.ChangeMessageVisibilityAsync(finalQueueName, workItem.GetParamOrDefault("ReceiptHandle"), 1); resTask.Wait(); if (resTask.Result.HttpStatusCode != System.Net.HttpStatusCode.OK) { throw new InvalidOperationException("The item was not correctly deleted, error code=" + resTask.Result.HttpStatusCode, resTask.Exception); } }
IAsyncTask CreateRenewalTaskForMessage(Message message, AmazonSQSClient client) { return(_asyncTaskFactory.Create($"RenewPeekLock-{message.MessageId}", async() => { _log.Info("Renewing peek lock for message with ID {0}", message.MessageId); await client.ChangeMessageVisibilityAsync(new ChangeMessageVisibilityRequest(_queueUrl, message.ReceiptHandle, (int)_peekLockDuration.TotalSeconds)); }, intervalSeconds: (int)_peekLockRenewalInterval.TotalSeconds, prettyInsignificant: true)); }
private AsyncTask CreateRenewalTaskForMessage(Message message, AmazonSQSClient client) { var renewalTask = new AsyncTask(string.Format("RenewPeekLock-{0}", message.MessageId), async() => { _log.Info("Renewing peek lock for message with ID {0}", message.MessageId); await client.ChangeMessageVisibilityAsync(new ChangeMessageVisibilityRequest(_queueUrl, message.ReceiptHandle, (int)_peekLockDuration.TotalSeconds)); }, prettyInsignificant: true) { Interval = _peekLockRenewalInterval }; return(renewalTask); }
static void Main(string[] args) { var batch_size = int.Parse(args[0]); var queue_url = args[1]; System.Console.WriteLine($"Reading {batch_size} messages at a time from SQS queue {queue_url}"); var sqs = new AmazonSQSClient(); // need keys and region try { while (true) { var receive_message_request = new ReceiveMessageRequest { AttributeNames = new List <string>() { "All" }, MaxNumberOfMessages = batch_size, QueueUrl = queue_url, WaitTimeSeconds = 20 }; var result = sqs.ReceiveMessageAsync(receive_message_request).Result; foreach (var message in result.Messages) { if (process_message(message)) { sqs.DeleteMessageAsync(new DeleteMessageRequest { QueueUrl = queue_url, ReceiptHandle = message.ReceiptHandle }); } else { sqs.ChangeMessageVisibilityAsync(queue_url, message.ReceiptHandle, 10); } } } } catch (System.Exception) { throw; } }
/// <summary> /// Rejects the specified message. /// </summary> /// <param name="message">The message.</param> public void Reject(Message message) { if (!message.Header.Bag.ContainsKey("ReceiptHandle")) { return; } var receiptHandle = message.Header.Bag["ReceiptHandle"].ToString(); try { s_logger.LogInformation( "SqsMessageConsumer: Rejecting the message {Id} with receipt handle {ReceiptHandle} on the queue {ChannelName}", message.Id, receiptHandle, _queueName ); using (var client = new AmazonSQSClient(_awsConnection.Credentials, _awsConnection.Region)) { var urlResponse = client.GetQueueUrlAsync(_queueName).Result; if (_hasDlq) { client.ChangeMessageVisibilityAsync(new ChangeMessageVisibilityRequest(urlResponse.QueueUrl, receiptHandle, 0)).Wait(); } else { client.DeleteMessageAsync(urlResponse.QueueUrl, receiptHandle).Wait(); } } s_logger.LogInformation( "SqsMessageConsumer: Message {Id} with receipt handle {ReceiptHandle} on the queue {ChannelName} with requeue parameter {3} has been rejected", message.Id, receiptHandle, _queueName ); } catch (Exception exception) { s_logger.LogError(exception, "SqsMessageConsumer: Error during rejecting the message {Id} with receipt handle {ReceiptHandle} on the queue {ChannelName}", message.Id, receiptHandle, _queueName); throw; } }