private void ValidateMessageReceived(ReceiveMessageResponse receiveMessageResponse, SqsMessage message) { Assert.True(receiveMessageResponse.HttpStatusCode == HttpStatusCode.OK); Assert.True(receiveMessageResponse.Messages.Count == 1); var receivedMessage = receiveMessageResponse.Messages.First(); Assert.True(receivedMessage.Body == message.Body); Assert.True(receivedMessage.MD5OfBody == message.Md5Hash); Assert.True(receivedMessage.MessageAttributes.Count() == 1); Assert.True(receivedMessage.MessageAttributes.First().Value.StringValue == "Custom Data"); }
internal async Task ListenLoop(CancellationToken ct) { var queueName = _queue.QueueName; var regionName = _queue.Region.SystemName; ReceiveMessageResponse sqsMessageResponse = null; while (!ct.IsCancellationRequested) { try { sqsMessageResponse = await GetMessagesFromSqsQueue(queueName, regionName, ct).ConfigureAwait(false); var messageCount = sqsMessageResponse.Messages.Count; _log.LogTrace("Polled for messages on queue '{QueueName}' in region '{Region}', and received {MessageCount} messages.", queueName, regionName, messageCount); } catch (InvalidOperationException ex) { _log.LogTrace(0, ex, "Could not determine number of messages to read from queue '{QueueName}' in '{Region}'.", queueName, regionName); } catch (OperationCanceledException ex) { _log.LogTrace(0, ex, "Suspected no message on queue '{QueueName}' in region '{Region}'.", queueName, regionName); } catch (Exception ex) { _log.LogError(0, ex, "Error receiving messages on queue '{QueueName}' in region '{Region}'.", queueName, regionName); } try { if (sqsMessageResponse != null) { foreach (var message in sqsMessageResponse.Messages) { if (ct.IsCancellationRequested) { return; } await HandleMessage(message, ct).ConfigureAwait(false); } } } catch (Exception ex) { _log.LogError(0, ex, "Error in message handling loop for queue '{QueueName}' in region '{Region}'.", queueName, regionName); } } }
private static string GetResponseStatus(ReceiveMessageResponse receiveMessageResponse) { Message message = receiveMessageResponse.Messages[0]; var jss = new JavaScriptSerializer(); var outer = jss.Deserialize <Dictionary <string, string> >(message.Body); var fields = jss.Deserialize <Dictionary <string, object> >(outer["Message"]); string status = fields["StatusCode"] as string; Debug.WriteLine("Message status: " + status); return(status); }
// Returns a list of messages in the queue. Does not delete the messages. Max quantity per request is 10. public static List <Message> GetMessagesFromQueue(int quantity) { ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest { QueueUrl = Config.queueUrl, MaxNumberOfMessages = quantity }; ReceiveMessageResponse response = Client.ReceiveMessage(receiveMessageRequest); return(response.Messages); }
private static async Task RunLambda() { AmazonSQSClient client = new AmazonSQSClient(); LambdaEntryPoint lambdaEntryPoint = new LambdaEntryPoint(); string queueUrl = Environment.GetEnvironmentVariable("SqsQueueUrl"); ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(queueUrl) { MaxNumberOfMessages = 1, WaitTimeSeconds = 20, MessageAttributeNames = new List <string> { "All" }, AttributeNames = new List <string> { "All" }, }; while (true) { Console.WriteLine($"Polling {queueUrl} for messages..."); ReceiveMessageResponse receiveMessageResponse = await client.ReceiveMessageAsync(receiveMessageRequest); Console.WriteLine($"Received {receiveMessageResponse.Messages.Count} messages from {queueUrl}."); if (receiveMessageResponse.Messages.Any()) { try { Console.WriteLine($"Running Lambda..."); SQSEvent sqsEvent = receiveMessageResponse.Messages.ToSqsEvent(); await lambdaEntryPoint.FunctionHandler(sqsEvent, LambdaContext.NonExpiringLambda); Console.WriteLine($"Lambda completed"); Console.WriteLine($"Deleting messages..."); await client.DeleteMessageBatchAsync(queueUrl, sqsEvent.Records.Select(_ => new DeleteMessageBatchRequestEntry { Id = _.MessageId, ReceiptHandle = _.ReceiptHandle }).ToList()); Console.WriteLine($"Deleted messages."); } catch (Exception e) { Console.WriteLine($"An error occured running lambda {e.Message} {Environment.NewLine} {e.StackTrace}"); } } } }
public async Task <bool> Run(ReceiveMessageRequest sqsRequest) { ReceiveMessageResponse sqsResponse = await _sqs.ReceiveMessageAsync(sqsRequest); if (!sqsResponse.Messages.Any()) { return(true); } return(await ExcuteValidator(sqsResponse, sqsRequest)); }
public async Task <IEnumerable <ReceivedMessage> > GetNextMessagesAsync(ReceiveMessageRequest request) { if (_cancellationToken.IsCancellationRequested) { return(new List <ReceivedMessage>()); } ReceiveMessageResponse response = await _sqsClient.ReceiveMessageAsync(request, _cancellationToken); return(_receivedMessageBuilder.BuildMessages(response.Messages, _sqsClient, request.QueueUrl)); }
private ReceiveMessageResponse GetMessage(int waitTime = 0) { ReceiveMessageRequest request = new ReceiveMessageRequest { QueueUrl = _configuration["AWS:SQS:QueueUrl"], WaitTimeSeconds = waitTime }; ReceiveMessageResponse response = Task.Run(async() => await _sqsClient.ReceiveMessageAsync(request)).Result; return(response); }
public async void Poll(object sender, ElapsedEventArgs evt) { logger.LogInformation($"Polling for messages from queue {QueueUrl}"); ReceiveMessageResponse messages = await ReceiveMessages(); logger.LogInformation($"Got {messages.Messages.Count} messages from queue {QueueUrl}"); await metrics.AddCounter("SQS.MessagesReceived", messages.Messages.Count); if (messages.Messages.Count > 0) { foreach (var message in messages.Messages) { var queueMessage = JObject.Parse(message.Body); var dynamoMessage = queueMessage["Message"].ToString(); logger.LogDebug(dynamoMessage); var dynamoEvent = Serializer.Deserialize <Record>(new JsonTextReader(new StringReader(dynamoMessage))); if (dynamoEvent.EventName.Value == "REMOVE") { var cleanupMessage = dynamoEvent.Dynamodb.OldImage; var channelId = ulong.Parse(cleanupMessage["ChannelId"].N); var messageId = ulong.Parse(cleanupMessage["MessageCleanupTableId"].S); try { var channel = await discordClient.GetChannelAsync(channelId); var discordMessage = await channel.GetMessageAsync(messageId); await channel.DeleteMessageAsync(discordMessage, "expired link"); logger.LogInformation($"Deleted discord message with id {messageId} from channel {channelId}"); await LogChannel.SendMessageAsync($"Removed message '{messageId}'"); } catch (NotFoundException ex) { logger.LogWarning($"Tried to delete message {messageId} but it was not found and probably already deleted"); } catch (UnauthorizedException ex) { logger.LogError($"Could not delete message {messageId} in channel {channelId} because of lacking permissions"); } } await DeleteMessage(message); logger.LogInformation($"Successfully deleted message with id {message.ReceiptHandle} from queue"); } } }
private static async Task <List <string> > ProcessMessages(ReceiveMessageResponse response, string queueUrl) { var results = new List <string>(); foreach (var message in response.Messages) { results.Add($"Message {message.Body} received with status {response.HttpStatusCode}"); results.Add(await DeleteMessage(results, message, queueUrl)); } return(results); }
private IEnumerable <T> YieldFromQueue() { var request = new ReceiveMessageRequest() .WithMaxNumberOfMessages(10) .WithQueueUrl(QueueUrl); ReceiveMessageResponse response = null; try { response = _client.ReceiveMessage(request); } catch { } if (response == null || !response.IsSetReceiveMessageResult()) { yield break; } var messages = response.ReceiveMessageResult.Message; var toDelete = new List <DeleteMessageBatchRequestEntry>(); foreach (var message in messages) { T deserialized = null; try { var stream = new MemoryStream(Encoding.UTF8.GetBytes(message.Body)); deserialized = _serializer.DeserializeFromStream <T>(stream); toDelete.Add(new DeleteMessageBatchRequestEntry() .WithId(message.MessageId) .WithReceiptHandle(message.ReceiptHandle) ); } catch { } yield return(deserialized); } if (toDelete.Count == 0) { yield break; } var batch = new DeleteMessageBatchRequest() .WithEntries(toDelete.ToArray()) .WithQueueUrl(QueueUrl); _client.DeleteMessageBatch(batch); }
public virtual List <Message> ReadMessages(AmazonSQSClient sqsClient, string queueUrl) { // Create the request var receiveMessageRequest = new ReceiveMessageRequest { QueueUrl = queueUrl, MaxNumberOfMessages = 10 }; // Submit the request and return the response ReceiveMessageResponse resp = sqsClient.ReceiveMessage(receiveMessageRequest); return(resp.Messages); }
private IEnumerable <TMessage> BuildMessages(ReceiveMessageResponse receiveMessageResponse) { foreach (Message rawMessage in receiveMessageResponse.Messages) { TMessage deserializedMessage = JsonConvert.DeserializeObject <TMessage>(rawMessage.Body); _messageIdsToReceiptHandles.AddOrUpdate(key: deserializedMessage.MessageId, addValue: rawMessage.ReceiptHandle, updateValueFactory: (messageId, receiptHandle) => receiptHandle); yield return(deserializedMessage); } }
public static SQSEvent ToSQSEvent(this ReceiveMessageResponse response) { var @event = new SQSEvent { Records = new List <SQSEvent.SQSMessage>() }; foreach (var message in response.Messages) { @event.Records.Add(message.ToSQSMessage()); } return(@event); }
public void ProcessMessagesFromResponse(ReceiveMessageResponse messageResponse) { if (messageResponse.Messages.Count != 0) { foreach (var message in messageResponse.Messages) { ProcessMessage(message); } } else { Console.WriteLine($"No messages found in the last {_waitTime} seconds."); } }
/// <summary> /// Receives a message from the SQS Queue /// </summary> /// <param name="client"></param> /// <param name="queueUrl"></param> /// <returns></returns> private Message ReceiveMessage(AmazonSQS client) { var request = new ReceiveMessageRequest { MaxNumberOfMessages = 1, QueueUrl = QueueUrl }; ReceiveMessageResponse response = client.ReceiveMessage(request); if (response.IsSetReceiveMessageResult()) { return(response.ReceiveMessageResult.Message.FirstOrDefault()); } return(null); }
private async Task CheckQueueForNewStatus(CancellationToken cancellationToken) { try { var sqs = new AmazonSQSClient(RegionEndpoint.EUWest1); var receiveMessageRequest = new ReceiveMessageRequest { QueueUrl = "https://sqs.eu-west-1.amazonaws.com/166778461577/StatusCheckSchedulerNotifierQueue" }; ReceiveMessageResponse receiveMessageResponse = null; try { receiveMessageResponse = await sqs.ReceiveMessageAsync(receiveMessageRequest, cancellationToken); } catch (Exception ex) { _logger.LogError(ex, "Error in scheduler while working with SQS"); } if (receiveMessageResponse?.Messages != null && receiveMessageResponse.Messages.Any()) { int counter = -1; foreach (var message in receiveMessageResponse.Messages) { counter++; if (!string.IsNullOrEmpty(message.Body)) { var dto = JsonHelper.ReadObject <AwsSnsMessageDto>(message.Body); var status = JsonHelper.ReadObject <VehicleStatusModel>(dto.Message); OnNewStatusArrived(new NewVehicleStatusEventArgs(status)); } var messageRecieptHandle = receiveMessageResponse.Messages[counter].ReceiptHandle; var deleteRequest = new DeleteMessageRequest { QueueUrl = "https://sqs.eu-west-1.amazonaws.com/166778461577/StatusCheckSchedulerNotifierQueue", ReceiptHandle = messageRecieptHandle }; await sqs.DeleteMessageAsync(deleteRequest, cancellationToken); } } } catch (AmazonSQSException ex) { _logger.LogError(ex, "Error in scheduler while working with SQS"); // do nothing, you may want to log, but let it give it another try in the next run } }
protected override async Task <IReadOnlyCollection <QueueMessage> > ReceiveMessagesAsync(int maxBatchSize, CancellationToken cancellationToken) { var request = new ReceiveMessageRequest(_queueUrl) { MessageAttributeNames = new List <string> { ".*" }, MaxNumberOfMessages = Math.Min(10, maxBatchSize) }; ReceiveMessageResponse messages = await _client.ReceiveMessageAsync(request, cancellationToken).ConfigureAwait(false); return(messages.Messages.Select(Converter.ToQueueMessage).ToList()); }
private static void DeleteReceivedMessage(ReceiveMessageResponse receiveMessageResponse, string myQueueUrl, IAmazonSQS sqs) { if (receiveMessageResponse.Messages.Any()) { var messageRecieptHandle = receiveMessageResponse.Messages[0].ReceiptHandle; //Deleting a message Console.WriteLine("Deleting the message.\n"); var deleteRequest = new DeleteMessageRequest { QueueUrl = myQueueUrl, ReceiptHandle = messageRecieptHandle }; sqs.DeleteMessage(deleteRequest); } }
private static void ProcessQueue(string jobId, AmazonGlacierClient client, Amazon.RegionEndpoint region) { ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest() { QueueUrl = s_queueUrl, MaxNumberOfMessages = 1 }; bool jobDone = false; while (!jobDone) { WriteLogConsole("Poll SQS queue"); ReceiveMessageResponse receiveMessageResponse = s_sqsClient.ReceiveMessage(receiveMessageRequest); if (receiveMessageResponse.Messages.Count == 0) { Thread.Sleep(10000 * 60); continue; } WriteLogConsole("Got message"); Message message = receiveMessageResponse.Messages[0]; Dictionary <string, string> outerLayer = JsonConvert.DeserializeObject <Dictionary <string, string> >(message.Body); Dictionary <string, object> fields = JsonConvert.DeserializeObject <Dictionary <string, object> >(outerLayer["Message"]); string statusCode = fields["StatusCode"] as string; if (string.Equals(statusCode, GlacierUtils.JOB_STATUS_SUCCEEDED, StringComparison.InvariantCultureIgnoreCase)) { WriteLogConsole("Downloading job output"); DownloadOutput(jobId, client, region); // Save job output to the specified file location. } else if (string.Equals(statusCode, GlacierUtils.JOB_STATUS_FAILED, StringComparison.InvariantCultureIgnoreCase)) { WriteLogConsole("Job failed... cannot download the inventory."); } jobDone = true; s_sqsClient.DeleteMessage(new DeleteMessageRequest() { QueueUrl = s_queueUrl, ReceiptHandle = message.ReceiptHandle }); } }
public static IEnumerable <T> MessagesAsResponse <T>(this ReceiveMessageResponse response) where T : ServiceResponse { var result = new List <T>(); if (response.IsSetReceiveMessageResult() && response.ReceiveMessageResult.Message.Count > 0) { var receiveMessageResult = response.ReceiveMessageResult; foreach (Message message in receiveMessageResult.Message) { result.Add(message.BodyAsResponse <T>()); } } return(result); }
private static ReceiveMessageResponse MakeResponse() { var response = new ReceiveMessageResponse { Messages = new List <Message> { new Message { Body = "some message" } } }; return(response); }
public IEnumerable <Message> GetNextMessages() { ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(this.queueUrl); receiveMessageRequest.MaxNumberOfMessages = 10; ReceiveMessageResponse receiveMessageResponse = this.sqsClient.ReceiveMessage(receiveMessageRequest); if (receiveMessageResponse.HttpStatusCode == HttpStatusCode.OK) { return(receiveMessageResponse.Messages); } return(new List <Message>()); }
/// <summary> /// Synchronous method that attempts to receive messages triggering async execution of the message handler /// </summary> public Task TriggerReceive() { ReceiveMessageRequest request = new ReceiveMessageRequest(QueueName); request.MaxNumberOfMessages = 1; ReceiveMessageResponse responce = _client.ReceiveMessage(request); foreach (var message in responce.Messages) { return(ProcessRecieveMessage(message)); } return(null); }
public async Task <List <Message> > GetAllMessages(string url) { ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.QueueUrl = url; ReceiveMessageResponse receiveMessageResponse = await Client.ReceiveMessageAsync(receiveMessageRequest); var list = new List <Message>(); foreach (var msg in receiveMessageResponse.Messages) { list.Add(msg); } return(list); }
private static void ReceiveMessage(string queueUrl, AmazonSQSClient sqsClient) { ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.QueueUrl = queueUrl; var counter = 0; var lenght = NumbersOfMessagesInQueue(queueUrl, sqsClient); while (counter < lenght) { ReceiveMessageResponse receiveMessageResponse = Task.Run(async() => await sqsClient.ReceiveMessageAsync(receiveMessageRequest)).Result; if (receiveMessageResponse.HttpStatusCode == HttpStatusCode.OK) { Message message = receiveMessageResponse.Messages[0]; ReportFilters filter = JsonSerializer.Deserialize <ReportFilters>(message.Body); Console.WriteLine("*********************************"); Console.WriteLine($"SQS Message Id: {message.MessageId}"); Console.WriteLine($"SQS Message Id: {message.ReceiptHandle}"); Console.WriteLine($"Message Id: {filter.Id}"); Console.WriteLine($"Message DataIni: {filter.DataIni}"); Console.WriteLine($"Message DateEnd: {filter.DataEnd}"); Console.WriteLine("*********************************"); Console.WriteLine($"Deleting Message..."); DeleteMessageRequest deleteMessageRequest = new DeleteMessageRequest(); deleteMessageRequest.QueueUrl = queueUrl; deleteMessageRequest.ReceiptHandle = message.ReceiptHandle; DeleteMessageResponse response = Task.Run(async() => await sqsClient.DeleteMessageAsync(deleteMessageRequest)).Result; if (response.HttpStatusCode == HttpStatusCode.OK) { Console.WriteLine($"Deleted Message..."); } else { Console.WriteLine($"ERROR: {response.HttpStatusCode}"); } Console.WriteLine(); } counter++; } }
static void Main(string[] args) { Console.WriteLine("Starting.."); string sQueue = "https://sqs.eu-west-1.amazonaws.com/{CODE}/{QUEUENAME}"; // Region / CODE and QueueName try { var config = new AmazonSQSConfig() { ServiceURL = "https://sqs.eu-west-1.amazonaws.com/" // Region and URL }; AmazonSQSClient _client = new AmazonSQSClient("ACCESSKEY", "ACCESSSECRET", config); ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.QueueUrl = sQueue; ReceiveMessageResponse receiveMessageResponse = _client.ReceiveMessage(receiveMessageRequest); foreach (var oMessage in receiveMessageResponse.Messages) { Console.WriteLine(oMessage.Body); // Delete the message from the queue DeleteMessageRequest deleteMessageRequest = new DeleteMessageRequest(); deleteMessageRequest.QueueUrl = sQueue; deleteMessageRequest.ReceiptHandle = oMessage.ReceiptHandle; DeleteMessageResponse response = _client.DeleteMessage(deleteMessageRequest); } } catch (Exception ex) { Console.WriteLine("Error: " + ex.ToString()); } Console.WriteLine("Complete"); Console.WriteLine("Press any key to close"); Console.ReadKey(); }
/// <summary> /// Retrieve messages from the underlying queue /// </summary> /// <param name="cancellationToken">Cancellation token</param> /// <returns>Messages or empty</returns> public async Task <IEnumerable <TransportMessage> > GetMessages(CancellationToken cancellationToken) { ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.WaitTimeSeconds = WaitTimeSeconds; receiveMessageRequest.MaxNumberOfMessages = MaxNumberOfMessages; receiveMessageRequest.AttributeNames = new List <string>() { "ApproximateReceiveCount" }; receiveMessageRequest.QueueUrl = _queueUrl; ReceiveMessageResponse receiveMessageResponse = await _simpleQueueService.ReceiveMessageAsync(receiveMessageRequest, cancellationToken); return(receiveMessageResponse.Messages.Select(x => MessageParser.ParseMessage(x)).ToList()); }
static void ReadFromQueue(AWSCredentials credentials) { AmazonSQSClient client = new AmazonSQSClient(credentials, RegionEndpoint.USEast1); string queueUrl = "https://sqs.us-east-1.amazonaws.com/025631894481/aws-talk"; ReceiveMessageRequest request = new ReceiveMessageRequest(queueUrl); request.MaxNumberOfMessages = 1; ReceiveMessageResponse response = client.ReceiveMessage(request); foreach (var message in response.Messages) { // Do something with the message } }
private int GetNumberOfMessages() { Debug.WriteLine("SqsSnsTest Thread sleeping for {0} seconds...", sleep); System.Threading.Thread.Sleep(sleep); Debug.WriteLine("SqsSnsTest ...Thread running."); int numMessages = 0; ReceiveMessageRequest request = new ReceiveMessageRequest(queueUrl); request.WaitTimeSeconds = 20; request.MaxNumberOfMessages = 10; ReceiveMessageResponse receiveMessageResult = sqsClient.ReceiveMessage(request); numMessages = receiveMessageResult.Messages.Count; return(numMessages); }