|
public GetQueueAttributes ( |
||
| request | Container for the necessary parameters to execute the GetQueueAttributes service method. | |
| return | ||
public virtual string GetQueueArn(AmazonSQSClient sqsClient, string queueUrl)
{
string queueArn;
// Construct a GetQueueAttributesRequest for the URL to retrieve the ARN
var getQueueAttributesRequest = new GetQueueAttributesRequest
{
QueueUrl = queueUrl,
AttributeNames =
{
"QueueArn"
}
};
// Submit the request
GetQueueAttributesResponse getQueueAttributesResponse =
sqsClient.GetQueueAttributes(getQueueAttributesRequest);
// Add the discovered ARN to the queueArnList variable.
queueArn = getQueueAttributesResponse.QueueARN;
return queueArn;
}
/// <summary>
/// Callback for windowing the SQS messages ordered by time queued
/// </summary>
/// <param name="state"></param>
private void WindowCallback(Object state)
{
try
{
CancellationToken ct = (CancellationToken)state;
List<Message> messages = new List<Message>();
// syncronize the processing of windows
if ((!ct.IsCancellationRequested) &
(Monitor.TryEnter(_windowLock, 1000)))
{
try
{
long epochWindowTime = ToEpochTimeInMilliseconds(DateTime.UtcNow.Subtract(this.SQSWindow));
int numberOfMessages = 0;
// 1st query to determine the # of Messages available in the queue
using (AmazonSQSClient client = new AmazonSQSClient(
this.AWSAccessKey, this.AWSSecretAccessKey,
new AmazonSQSConfig() { ServiceURL = this.AWSSQSServiceUrl }))
{
// get the NumberOfMessages to optimize how to Receive all of the messages from the queue
GetQueueAttributesRequest attributesRequest = new GetQueueAttributesRequest();
attributesRequest.QueueUrl = this.QueueUrl;
attributesRequest.AttributeName.Add("ApproximateNumberOfMessages");
numberOfMessages = client.GetQueueAttributes(attributesRequest).GetQueueAttributesResult.ApproximateNumberOfMessages;
}
// determine if we need to Receive messages from the Queue
if (numberOfMessages > 0)
{
if (numberOfMessages < 10)
{
// just do it inline it's less expensive than spinning threads
ReceiveTask(ct, numberOfMessages);
}
else
{
// use the default partitioner to determine the number of tasks
// TODO Create a custom partitioner that takes into account the batch x 10 of SQS
Parallel.ForEach(Partitioner.Create(0, numberOfMessages),
(range) => ReceiveTask(ct, range.Item2 - range.Item1));
}
}
// ok so all messages have been Receieved and ordered or no more messages can be popped
if (!ct.IsCancellationRequested)
{
// get all messages less than the window time from the rb tree
// probably don't have to lock on _setLock because of the _windowLock but let's be safe
lock (_setLock)
{
messages.AddRange(_set.Where((m) => long.Parse(m.Attribute[0].Value) < epochWindowTime));
_set.RemoveWhere((m) => long.Parse(m.Attribute[0].Value) < epochWindowTime);
}
// remove duplicates
//TODO Find a better way to dedup that doesn't destroy the order of the array
IEnumerable<Message> dedupMessages = messages.Distinct(new MessageEqualityComparer());
// distinct doesn't presever order so we need to reorder the window
IEnumerable<Message> orderedMessages = dedupMessages.OrderBy(m => m, new MessageSentTimeStampComparer());
// raise the WindowEvent with the results
if (!ct.IsCancellationRequested)
{
OnNewWindow(dedupMessages);
}
}
}
finally
{
Monitor.Exit(_windowLock);
}
}
// check if we should delete the messages
if ((!ct.IsCancellationRequested) &
(messages.Count > 0))
{
if (messages.Count < 10)
{
DeleteTask(ct, messages, new Tuple<int, int>(0, messages.Count));
}
else
{
// use the default partitioner to determine the number of tasks
// TODO Create a custom partitioner that takes into account the batch x 10 of SQS
Parallel.ForEach(Partitioner.Create(0, messages.Count),
(range) => DeleteTask(ct, messages, range));
}
}
}
catch (Exception ex)
{
EventLog.WriteEntry(this.GetType().Name,
ex.Message + "\n" + ex.StackTrace,
EventLogEntryType.Error);
}
}
public void MessageDeleted()
{
AddConfigValue("SQSWindow", "0.00:00:15");
int visibilityTimeout = -1;
// change the visibility timeout of the queue
using (Amazon.SQS.AmazonSQSClient client = new AmazonSQSClient(
ConfigurationManager.AppSettings["AWSAccessKey"],
ConfigurationManager.AppSettings["AWSSecretAccessKey"],
new AmazonSQSConfig()))
{
// store the visibilitytimeout so we can reset it
GetQueueAttributesRequest getRequest = new GetQueueAttributesRequest();
getRequest.QueueUrl = ConfigurationManager.AppSettings["QueueUrl"];
getRequest.AttributeName.Add("VisibilityTimeout");
GetQueueAttributesResponse response = client.GetQueueAttributes(getRequest);
visibilityTimeout = response.GetQueueAttributesResult.VisibilityTimeout;
// set it to 1 second
SetQueueAttributesRequest setRequest = new SetQueueAttributesRequest();
setRequest.QueueUrl = ConfigurationManager.AppSettings["QueueUrl"];
setRequest.Attribute.Add(new Amazon.SQS.Model.Attribute() { Name = "VisibilityTimeout", Value = "1" });
client.SetQueueAttributes(setRequest);
String[] messageIds = new String[] { QueueMessage() };
MockSQSService service = new MockSQSService();
service.Start();
PollForMessages(messageIds, service);
ReceiveMessageRequest receiveRequest = new ReceiveMessageRequest();
receiveRequest.QueueUrl = ConfigurationManager.AppSettings["QueueUrl"];
ReceiveMessageResponse receiveResponse = client.ReceiveMessage(receiveRequest);
Assert.AreEqual(0, receiveResponse.ReceiveMessageResult.Message.Where((m) => m.MessageId == messageIds[0]).Count());
// set the visibility timeout back
setRequest = new SetQueueAttributesRequest();
setRequest.QueueUrl = ConfigurationManager.AppSettings["QueueUrl"];
setRequest.Attribute.Add(new Amazon.SQS.Model.Attribute() { Name = "VisibilityTimeout", Value = visibilityTimeout.ToString() });
client.SetQueueAttributes(setRequest);
RemoveConfigValue("SQSWindow");
}
}
public static void SQSGetQueueAttributes()
{
#region SQSGetQueueAttributes
var client = new AmazonSQSClient();
var request = new GetQueueAttributesRequest
{
QueueUrl = "https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyTestQueue",
AttributeNames = new List<string>() { "All" }
};
var response = client.GetQueueAttributes(request);
Console.WriteLine("Attributes for queue ARN '" + response.QueueARN + "':");
Console.WriteLine(" Approximate number of messages:" +
response.ApproximateNumberOfMessages);
Console.WriteLine(" Approximate number of messages delayed: " +
response.ApproximateNumberOfMessagesDelayed);
Console.WriteLine(" Approximate number of messages not visible: " +
response.ApproximateNumberOfMessagesNotVisible);
Console.WriteLine(" Queue created on: " + response.CreatedTimestamp);
Console.WriteLine(" Delay seconds: " + response.DelaySeconds);
Console.WriteLine(" Queue last modified on: " +
response.LastModifiedTimestamp);
Console.WriteLine(" Maximum message size: " +
response.MaximumMessageSize);
Console.WriteLine(" Message retention period: " +
response.MessageRetentionPeriod);
Console.WriteLine(" Visibility timeout: " + response.VisibilityTimeout);
Console.WriteLine(" Policy: " + response.Policy);
Console.WriteLine(" Attributes:");
foreach (var attr in response.Attributes)
{
Console.WriteLine(" " + attr.Key + ": " + attr.Value);
}
#endregion
Console.ReadLine();
}
public static int QueueLengthByQueueUrl(string queueUrl)
{
using (var client = new AmazonSQSClient(Settings.AccessKey, Settings.Secret))
{
var request = new GetQueueAttributesRequest
{
QueueUrl = queueUrl,
AttributeNames = new List<string> { "ApproximateNumberOfMessages" }
};
return client.GetQueueAttributes(request).ApproximateNumberOfMessages;
}
}
