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);
}
