public async Task <GetQueueAttributesResponse> GetQueueAttributesAsync(string queueUrl,
CancellationToken cancellationToken = default)
{
this.Logger.LogDebug($"[{nameof(this.GetQueueAttributesAsync)}]");
this.Logger.LogTrace(JsonConvert.SerializeObject(new { queueUrl }));
if (string.IsNullOrWhiteSpace(queueUrl))
{
throw new ArgumentNullException(nameof(queueUrl));
}
var request = new Amazon.SQS.Model.GetQueueAttributesRequest
{
QueueUrl = queueUrl,
AttributeNames = new List <string>()
{
Text.All
},
};
this.Logger.LogTrace(JsonConvert.SerializeObject(value: request));
var response = await this.Repository.GetQueueAttributesAsync(request : request,
cancellationToken : cancellationToken == default?this.CancellationToken.Token : cancellationToken);
this.Logger.LogTrace(JsonConvert.SerializeObject(value: response));
return(response);
}
private async Task<int> GetSqsCount()
{
var url = queueClient.GetQueueUrl(queueName);
var request = new GetQueueAttributesRequest { QueueUrl = url.QueueUrl };
request.AttributeNames.Add("ApproximateNumberOfMessages");
request.AttributeNames.Add("ApproximateNumberOfMessagesNotVisible");
var response = await queueClient.GetQueueAttributesAsync(request);
return response == null ? 0 : response.ApproximateNumberOfMessages + response.ApproximateNumberOfMessagesNotVisible;
}
protected GetQueueAttributesResult GetAttrs(IEnumerable<string> attrKeys)
{
var request = new GetQueueAttributesRequest {
QueueUrl = Url,
AttributeNames = new List<string>(attrKeys)
};
var result = Client.GetQueueAttributes(request);
return result;
}
/// <summary>
///
/// Gets one or all attributes of a queue. Queues currently have two attributes you can get: ApproximateNumberOfMessages and VisibilityTimeout.
///
/// </summary>
/// <param name="service">Instance of AmazonSQS service</param>
/// <param name="request">GetQueueAttributesRequest request</param>
public static void InvokeGetQueueAttributes(AmazonSQS service, GetQueueAttributesRequest request)
{
try
{
GetQueueAttributesResponse response = service.GetQueueAttributes(request);
Console.WriteLine ("Service Response");
Console.WriteLine ("=============================================================================");
Console.WriteLine ();
Console.WriteLine(" GetQueueAttributesResponse");
if (response.IsSetGetQueueAttributesResult())
{
Console.WriteLine(" GetQueueAttributesResult");
GetQueueAttributesResult getQueueAttributesResult = response.GetQueueAttributesResult;
List<Attribute> attributeList = getQueueAttributesResult.Attribute;
foreach (Attribute attribute in attributeList)
{
Console.WriteLine(" Attribute");
if (attribute.IsSetName())
{
Console.WriteLine(" Name");
Console.WriteLine(" {0}", attribute.Name);
}
if (attribute.IsSetValue())
{
Console.WriteLine(" Value");
Console.WriteLine(" {0}", attribute.Value);
}
}
}
if (response.IsSetResponseMetadata())
{
Console.WriteLine(" ResponseMetadata");
ResponseMetadata responseMetadata = response.ResponseMetadata;
if (responseMetadata.IsSetRequestId())
{
Console.WriteLine(" RequestId");
Console.WriteLine(" {0}", responseMetadata.RequestId);
}
}
}
catch (AmazonSQSException ex)
{
Console.WriteLine("Caught Exception: " + ex.Message);
Console.WriteLine("Response Status Code: " + ex.StatusCode);
Console.WriteLine("Error Code: " + ex.ErrorCode);
Console.WriteLine("Error Type: " + ex.ErrorType);
Console.WriteLine("Request ID: " + ex.RequestId);
Console.WriteLine("XML: " + ex.XML);
}
}
public static int Count(string queue_url)
{
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
GetQueueAttributesRequest gqreq = new GetQueueAttributesRequest();
gqreq.QueueUrl = queue_url;
List<string> attr = new List<string>();
attr.Add("All");
gqreq.AttributeName = attr;
GetQueueAttributesResponse gqres = sqs.GetQueueAttributes(gqreq);
GetQueueAttributesResult gqrst = gqres.GetQueueAttributesResult;
//Console.WriteLine("Invisible Messages:" + gqrst.ApproximateNumberOfMessagesNotVisible.ToString());
//Console.WriteLine("Messages:" + gqrst.ApproximateNumberOfMessages);
return gqrst.ApproximateNumberOfMessages;
}
public void subscribe_to_topic()
{
var getArnRequest = new GetQueueAttributesRequest().WithQueueUrl(_queueUrl).WithAttributeName("QueueArn");
var clientArn = _client.GetQueueAttributes(getArnRequest).GetQueueAttributesResult.Attribute[0].Value;
var sns = Amazon.AWSClientFactory.CreateAmazonSNSClient("AKIAIN2KJH4QJIUV7CGQ",
"18ypN0y7SGA+L0XDVMHm9lBVmQ2oF2bdm7CGIijA");
var subscriptionRequest = new SubscribeRequest()
.WithEndpoint(clientArn)
.WithProtocol("sqs")
.WithTopicArn("arn:aws:sns:us-east-1:451419498740:EventMessage");
var response = sns.Subscribe(subscriptionRequest);
Console.WriteLine(response.SubscribeResult.SubscriptionArn);
}
public void Subscribe()
{
SetPermissions();
var getArnRequest = new GetQueueAttributesRequest().WithQueueUrl(_config.SqsQueueUrl).WithAttributeName("QueueArn");
var clientArn = _client.GetQueueAttributes(getArnRequest).GetQueueAttributesResult.Attribute[0].Value;
var sns = AWSClientFactory.CreateAmazonSNSClient(_config.AccessKeyId,
_config.SecretKey);
var subscriptionRequest = new SubscribeRequest()
.WithEndpoint(clientArn)
.WithProtocol("sqs")
.WithTopicArn(_config.TopicAccessResourceName);
sns.Subscribe(subscriptionRequest);
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
// create request
var request = new Amazon.SQS.Model.GetQueueAttributesRequest();
if (cmdletContext.AttributeName != null)
{
request.AttributeNames = cmdletContext.AttributeName;
}
if (cmdletContext.QueueUrl != null)
{
request.QueueUrl = cmdletContext.QueueUrl;
}
CmdletOutput output;
// issue call
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
pipelineOutput = cmdletContext.Select(response, this);
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
}
catch (Exception e)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
return(output);
}
public ISubscribeReponseMessage Subscribe(string queueUrl)
{
var sqsConfig = new AmazonSQSConfig {ServiceURL = SqsServiceUrl};
var snsConfig = new AmazonSimpleNotificationServiceConfig {ServiceURL = SnsServiceUrl};
using (var sqsClient = _awsConfig.CreateAwsClient<AmazonSQSClient>(sqsConfig))
{
var attributesRequest = new GetQueueAttributesRequest(queueUrl, new List<string> {"QueueArn"});
var attributesResponse = sqsClient.GetQueueAttributes(attributesRequest);
using (var snsClient = _awsConfig.CreateAwsClient<AmazonSimpleNotificationServiceClient>(snsConfig))
{
var subribeResonse =
snsClient.Subscribe(new SubscribeRequest(TopicArn, "sqs", attributesResponse.QueueARN));
}
var actions = new ActionIdentifier[2];
actions[0] = SQSActionIdentifiers.SendMessage;
actions[1] = SQSActionIdentifiers.ReceiveMessage;
var sqsPolicy =
new Policy().WithStatements(
new Statement(Statement.StatementEffect.Allow).WithPrincipals(Principal.AllUsers)
.WithResources(
new Resource(attributesResponse.QueueARN))
.WithConditions(
ConditionFactory.NewSourceArnCondition(
TopicArn))
.WithActionIdentifiers(actions));
var setQueueAttributesRequest = new SetQueueAttributesRequest();
var attributes = new Dictionary<string, string> {{"Policy", sqsPolicy.ToJson()}};
var attRequest = new SetQueueAttributesRequest(attributesRequest.QueueUrl, attributes);
sqsClient.SetQueueAttributes(attRequest);
return new SubcriptionMessage("Ok");
}
}
public void create_sqs_queue()
{
GetUserNameAndPassword();
var sqsClient = Amazon.AWSClientFactory.CreateAmazonSQSClient(_key, _secret);
var snsTopic = Amazon.AWSClientFactory.CreateAmazonSNSClient(_key, _secret);
var topicArn = "arn:aws:sns:us-east-1:451419498740:Elliott-has-an-awesome-blog";
//Create a new SQS queue
var createQueueRequest = new CreateQueueRequest().WithQueueName("elliotts-blog");
var createQueueResponse = sqsClient.CreateQueue(createQueueRequest);
// keep the queueUrl handy
var queueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
// get the Access Resource Name so we can allow the SNS to put messages on it
var getQueueArnRequest = new GetQueueAttributesRequest()
.WithQueueUrl(queueUrl)
.WithAttributeName("QueueArn");
var getQueueArnResponse = sqsClient.GetQueueAttributes(getQueueArnRequest);
var queueArn = getQueueArnResponse.GetQueueAttributesResult.Attribute[0].Value;
//create a Policy for the SQS queue that allows SNS to publish to it
var allowSnsStatement = new Statement(Statement.StatementEffect.Allow)
.WithPrincipals(Principal.AllUsers)
.WithResources(new Resource(queueArn))
.WithConditions(ConditionFactory.NewSourceArnCondition(topicArn))
.WithActionIdentifiers(SQSActionIdentifiers.SendMessage);
var policy = new Policy("allow sns").WithStatements(new[] {allowSnsStatement});
var attribute = new Attribute().WithName("Policy").WithValue(policy.ToJson());
var setQueueAttributesRequest =
new SetQueueAttributesRequest().WithQueueUrl(queueUrl).WithAttribute(attribute);
sqsClient.SetQueueAttributes(setQueueAttributesRequest);
// ok, now lets create the subscription for sqs with the queueArn we created
var subscribeRequest = new SubscribeRequest()
.WithEndpoint(queueArn)
.WithTopicArn(topicArn)
.WithProtocol("sqs");
snsTopic.Subscribe(subscribeRequest);
}
/// <summary>
/// Gets attributes for the specified queue. The following attributes are supported:
/// <ul> <li><code>All</code> - returns all values.</li> <li><code>ApproximateNumberOfMessages</code>
/// - returns the approximate number of visible messages in a queue. For more
/// information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ApproximateNumber.html">Resources
/// Required to Process Messages</a> in the <i>Amazon SQS Developer Guide</i>.</li>
/// <li><code>ApproximateNumberOfMessagesNotVisible</code> - returns the
/// approximate number of messages that are not timed-out and not deleted.
/// For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ApproximateNumber.html">Resources
/// Required to Process Messages</a> in the <i>Amazon SQS Developer Guide</i>.</li>
/// <li><code>VisibilityTimeout</code> - returns the visibility timeout for
/// the queue. For more information about visibility timeout, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html">Visibility
/// Timeout</a> in the <i>Amazon SQS Developer Guide</i>.</li> <li><code>CreatedTimestamp</code>
/// - returns the time when the queue was created (epoch time in seconds).</li>
/// <li><code>LastModifiedTimestamp</code> - returns the time when the queue
/// was last changed (epoch time in seconds).</li> <li><code>Policy</code>
/// - returns the queue's policy.</li> <li><code>MaximumMessageSize</code> - returns
/// the limit of how many bytes a message can contain before Amazon SQS rejects
/// it.</li> <li><code>MessageRetentionPeriod</code> - returns the number of seconds
/// Amazon SQS retains a message.</li> <li><code>QueueArn</code> - returns
/// the queue's Amazon resource name (ARN).</li> <li><code>ApproximateNumberOfMessagesDelayed</code>
/// - returns the approximate number of messages that are pending to be added
/// to the queue.</li> <li><code>DelaySeconds</code> - returns the default
/// delay on the queue in seconds.</li> <li><code>ReceiveMessageWaitTimeSeconds</code>
/// - returns the time for which a ReceiveMessage call will wait for a message
/// to arrive.</li> <li><code>RedrivePolicy</code> - returns the parameters for
/// dead letter queue functionality of the source queue. For more information
/// about RedrivePolicy and dead letter queues, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSDeadLetterQueue.html">Using
/// Amazon SQS Dead Letter Queues</a> in the <i>Amazon SQS Developer Guide</i>.</li>
/// </ul>
///
/// <note>Going forward, new attributes might be added. If you are writing code
/// that calls this action, we recommend that you structure your code so that it can handle
/// new attributes gracefully.</note> <note>Some API actions take lists of parameters.
/// These lists are specified using the <code>param.n</code> notation. Values of
/// <code>n</code> are integers starting from 1. For example, a parameter list with two
/// elements looks like this: </note>
/// <para>
/// <code>&Attribute.1=this</code>
/// </para>
///
/// <para>
/// <code>&Attribute.2=that</code>
/// </para>
/// </summary>
/// <param name="queueUrl">The URL of the Amazon SQS queue to take action on.</param>
/// <param name="attributeNames">A list of attributes to retrieve information for. </param>
///
/// <returns>The response from the GetQueueAttributes service method, as returned by SQS.</returns>
/// <exception cref="InvalidAttributeNameException">
/// The attribute referred to does not exist.
/// </exception>
public GetQueueAttributesResponse GetQueueAttributes(string queueUrl, List<string> attributeNames)
{
var request = new GetQueueAttributesRequest();
request.QueueUrl = queueUrl;
request.AttributeNames = attributeNames;
return GetQueueAttributes(request);
}
/// <summary>
/// Gets attributes for the specified queue. The following attributes are supported:
/// <ul> <li><code>All</code> - returns all values.</li> <li><code>ApproximateNumberOfMessages</code>
/// - returns the approximate number of visible messages in a queue. For more
/// information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ApproximateNumber.html">Resources
/// Required to Process Messages</a> in the <i>Amazon SQS Developer Guide</i>.</li>
/// <li><code>ApproximateNumberOfMessagesNotVisible</code> - returns the
/// approximate number of messages that are not timed-out and not deleted.
/// For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ApproximateNumber.html">Resources
/// Required to Process Messages</a> in the <i>Amazon SQS Developer Guide</i>.</li>
/// <li><code>VisibilityTimeout</code> - returns the visibility timeout for
/// the queue. For more information about visibility timeout, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html">Visibility
/// Timeout</a> in the <i>Amazon SQS Developer Guide</i>.</li> <li><code>CreatedTimestamp</code>
/// - returns the time when the queue was created (epoch time in seconds).</li>
/// <li><code>LastModifiedTimestamp</code> - returns the time when the queue
/// was last changed (epoch time in seconds).</li> <li><code>Policy</code>
/// - returns the queue's policy.</li> <li><code>MaximumMessageSize</code> - returns
/// the limit of how many bytes a message can contain before Amazon SQS rejects
/// it.</li> <li><code>MessageRetentionPeriod</code> - returns the number of seconds
/// Amazon SQS retains a message.</li> <li><code>QueueArn</code> - returns
/// the queue's Amazon resource name (ARN).</li> <li><code>ApproximateNumberOfMessagesDelayed</code>
/// - returns the approximate number of messages that are pending to be added
/// to the queue.</li> <li><code>DelaySeconds</code> - returns the default
/// delay on the queue in seconds.</li> <li><code>ReceiveMessageWaitTimeSeconds</code>
/// - returns the time for which a ReceiveMessage call will wait for a message
/// to arrive.</li> <li><code>RedrivePolicy</code> - returns the parameters for
/// dead letter queue functionality of the source queue. For more information
/// about RedrivePolicy and dead letter queues, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSDeadLetterQueue.html">Using
/// Amazon SQS Dead Letter Queues</a> in the <i>Amazon SQS Developer Guide</i>.</li>
/// </ul>
///
/// <note>Going forward, new attributes might be added. If you are writing code
/// that calls this action, we recommend that you structure your code so that it can handle
/// new attributes gracefully.</note> <note>Some API actions take lists of parameters.
/// These lists are specified using the <code>param.n</code> notation. Values of
/// <code>n</code> are integers starting from 1. For example, a parameter list with two
/// elements looks like this: </note>
/// <para>
/// <code>&Attribute.1=this</code>
/// </para>
///
/// <para>
/// <code>&Attribute.2=that</code>
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetQueueAttributes service method.</param>
///
/// <returns>The response from the GetQueueAttributes service method, as returned by SQS.</returns>
/// <exception cref="InvalidAttributeNameException">
/// The attribute referred to does not exist.
/// </exception>
public GetQueueAttributesResponse GetQueueAttributes(GetQueueAttributesRequest request)
{
var marshaller = new GetQueueAttributesRequestMarshaller();
var unmarshaller = GetQueueAttributesResponseUnmarshaller.Instance;
return Invoke<GetQueueAttributesRequest,GetQueueAttributesResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Gets attributes for the specified queue.
///
/// <note>
/// <para>
/// Some actions take lists of parameters. These lists are specified using the <code>param.n</code>
/// notation. Values of <code>n</code> are integers starting from 1. For example, a parameter
/// list with two elements looks like this:
/// </para>
///
/// <para>
/// <code>&Attribute.1=this</code>
/// </para>
///
/// <para>
/// <code>&Attribute.2=that</code>
/// </para>
/// </note>
/// </summary>
/// <param name="queueUrl">The URL of the Amazon SQS queue whose attribute information is retrieved. Queue URLs are case-sensitive.</param>
/// <param name="attributeNames">A list of attributes for which to retrieve information. <note> In the future, new attributes might be added. If you write code that calls this action, we recommend that you structure your code so that it can handle new attributes gracefully. </note> The following attributes are supported: <ul> <li> <code>All</code> - Returns all values. </li> <li> <code>ApproximateNumberOfMessages</code> - Returns the approximate number of visible messages in a queue. For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-resources-required-process-messages.html">Resources Required to Process Messages</a> in the <i>Amazon SQS Developer Guide</i>. </li> <li> <code>ApproximateNumberOfMessagesDelayed</code> - Returns the approximate number of messages that are waiting to be added to the queue. </li> <li> <code>ApproximateNumberOfMessagesNotVisible</code> - Returns the approximate number of messages that have not timed-out and aren't deleted. For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-resources-required-process-messages.html">Resources Required to Process Messages</a> in the <i>Amazon SQS Developer Guide</i>. </li> <li> <code>CreatedTimestamp</code> - Returns the time when the queue was created in seconds (<a href="http://en.wikipedia.org/wiki/Unix_time">epoch time</a>). </li> <li> <code>DelaySeconds</code> - Returns the default delay on the queue in seconds. </li> <li> <code>LastModifiedTimestamp</code> - Returns the time when the queue was last changed in seconds (<a href="http://en.wikipedia.org/wiki/Unix_time">epoch time</a>). </li> <li> <code>MaximumMessageSize</code> - Returns the limit of how many bytes a message can contain before Amazon SQS rejects it. </li> <li> <code>MessageRetentionPeriod</code> - Returns the number of seconds for which Amazon SQS retains a message. </li> <li> <code>Policy</code> - Returns the policy of the queue. </li> <li> <code>QueueArn</code> - Returns the Amazon resource name (ARN) of the queue. </li> <li> <code>ReceiveMessageWaitTimeSeconds</code> - Returns the number of seconds for which the <code>ReceiveMessage</code> action waits for a message to arrive. </li> <li> <code>RedrivePolicy</code> - Returns the parameters for dead letter queue functionality of the source queue. For more information about the redrive policy and dead letter queues, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html">Using Amazon SQS Dead Letter Queues</a> in the <i>Amazon SQS Developer Guide</i>. </li> <li> <code>VisibilityTimeout</code> - Returns the visibility timeout for the queue. For more information about the visibility timeout, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html">Visibility Timeout</a> in the <i>Amazon SQS Developer Guide</i>. </li> </ul> The following attributes apply only to <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO (first-in-first-out) queues</a>: <ul> <li> <code>FifoQueue</code> - Returns whether the queue is FIFO. For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html#FIFO-queues-understanding-logic">FIFO Queue Logic</a> in the <i>Amazon SQS Developer Guide</i>. </li> <li> <code>ContentBasedDeduplication</code> - Returns whether content-based deduplication is enabled for the queue. For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html#FIFO-queues-exactly-once-processing">Exactly-Once Processing</a> in the <i>Amazon SQS Developer Guide</i>. </li> </ul></param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the GetQueueAttributes service method, as returned by SQS.</returns>
/// <exception cref="Amazon.SQS.Model.InvalidAttributeNameException">
/// The attribute referred to doesn't exist.
/// </exception>
public Task<GetQueueAttributesResponse> GetQueueAttributesAsync(string queueUrl, List<string> attributeNames, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new GetQueueAttributesRequest();
request.QueueUrl = queueUrl;
request.AttributeNames = attributeNames;
return GetQueueAttributesAsync(request, cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the GetQueueAttributes operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetQueueAttributes operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<GetQueueAttributesResponse> GetQueueAttributesAsync(GetQueueAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetQueueAttributesRequestMarshaller();
var unmarshaller = GetQueueAttributesResponseUnmarshaller.Instance;
return InvokeAsync<GetQueueAttributesRequest,GetQueueAttributesResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <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);
}
}
IAsyncResult invokeGetQueueAttributes(GetQueueAttributesRequest getQueueAttributesRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new GetQueueAttributesRequestMarshaller().Marshall(getQueueAttributesRequest);
var unmarshaller = GetQueueAttributesResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
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;
}
public void Test_GetQueueAttributes_With_NonExisting_Attribute_And_Check_For_Error_Response()
{
bool hasCallbackArrived = false;
string actualValue = string.Empty;
string expectedValue = "InvalidAttributeName";
string nonExistingAttribute = "poiu";
SQSResponseEventHandler<object, ResponseEventArgs> handler = null;
handler = delegate(object sender, ResponseEventArgs args)
{
ISQSResponse result = args.Response;
//Unhook from event.
_client.OnSQSResponse -= handler;
AmazonSQSException exception = result as AmazonSQSException;
if (null != exception)
actualValue = exception.ErrorCode;
hasCallbackArrived = true;
};
//Hook to event
_client.OnSQSResponse += handler;
//Create request object.
GetQueueAttributesRequest request = new GetQueueAttributesRequest();
request.QueueUrl = string.Format("{0}/{1}", QueueURL, _queue_UnitTesting);
request.AttributeName.Add(nonExistingAttribute);
_client.GetQueueAttributes(request);
EnqueueConditional(() => hasCallbackArrived);
EnqueueCallback(() => Assert.IsTrue(expectedValue == actualValue));
EnqueueTestComplete();
}
internal GetQueueAttributesResponse GetQueueAttributes(GetQueueAttributesRequest request)
{
var task = GetQueueAttributesAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
public string GetQueueArn(Uri queueUrl)
{
// get queueArn
var attributeRequest =
new GetQueueAttributesRequest().WithQueueUrl(queueUrl.AbsoluteUri).WithAttributeName(
queueArnAttributeName);
using (var sqs = amazonSqsFactory())
{
var queueAttributes = sqs.GetQueueAttributes(attributeRequest);
return queueAttributes.GetQueueAttributesResult.Attribute[0].Value;
}
}
private static string GetQueueArn(string queueUrl)
{
var request = new GetQueueAttributesRequest(queueUrl, new List<string> { "QueueArn" });
var response = _client.GetQueueAttributes(request);
return response.QueueARN;
}
public void PopulateQueueAttributes(QueueDescription queue)
{
var req = new GetQueueAttributesRequest() {
QueueUrl = queue.Url
};
req.AttributeName.Add("ApproximateNumberOfMessages");
req.AttributeName.Add("MessageRetentionPeriod");
var response = client.GetQueueAttributes(req);
var result = new Dictionary<string, string>(10);
if (response.IsSetGetQueueAttributesResult() && response.GetQueueAttributesResult.IsSetAttribute()) {
foreach (Amazon.SQS.Model.Attribute att in response.GetQueueAttributesResult.Attribute) {
switch (att.Name) {
case "MessageRetentionPeriod":
queue.MessageRetentionPeriod = TimeSpan.FromSeconds(Double.Parse(att.Value));
break;
case "ApproximateNumberOfMessages":
queue.ApproximateNumberOfMessages = Int32.Parse(att.Value);
break;
}
}
}
}
/// <summary>
/// Returns the count of items in the SQS
/// </summary>
private int GetSQSCount()
{
try
{
var AttribRequest = new GetQueueAttributesRequest
{
QueueUrl = Config.Default.AWSSQSQueueUrl,
AttributeNames = new List<string>
{
"ApproximateNumberOfMessages"
}
};
var AttribResponse = SqsClient.GetQueueAttributes(AttribRequest);
return AttribResponse.ApproximateNumberOfMessages;
}
catch (Exception Ex)
{
CrashReporterProcessServicer.WriteException("GetSQSCount: " + Ex.ToString());
}
return 0;
}
/// <summary>
/// Initiates the asynchronous execution of the GetQueueAttributes operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetQueueAttributes operation on AmazonSQSClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetQueueAttributes
/// operation.</returns>
public IAsyncResult BeginGetQueueAttributes(GetQueueAttributesRequest request, AsyncCallback callback, object state)
{
var marshaller = new GetQueueAttributesRequestMarshaller();
var unmarshaller = GetQueueAttributesResponseUnmarshaller.Instance;
return BeginInvoke<GetQueueAttributesRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// <para>Gets attributes for the specified queue. The following attributes are supported:
/// <ul>
/// <li> <c>All</c> - returns all values.</li>
/// <li> <c>ApproximateNumberOfMessages</c> - returns the approximate number of visible messages in a queue. For more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ApproximateNumber.html">Resources Required to Process
/// Messages</a> in the <i>Amazon SQS Developer Guide</i> .</li>
/// <li> <c>ApproximateNumberOfMessagesNotVisible</c> - returns the approximate number of messages that are not timed-out and not deleted. For
/// more information, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ApproximateNumber.html">Resources
/// Required to Process Messages</a> in the <i>Amazon SQS Developer Guide</i> .</li>
/// <li> <c>VisibilityTimeout</c> - returns the visibility timeout for the queue. For more information about visibility timeout, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html">Visibility Timeout</a> in the <i>Amazon SQS
/// Developer Guide</i> .</li>
/// <li> <c>CreatedTimestamp</c> - returns the time when the queue was created (epoch time in seconds).</li>
/// <li> <c>LastModifiedTimestamp</c> - returns the time when the queue was last changed (epoch time in seconds).</li>
/// <li> <c>Policy</c> - returns the queue's policy.</li>
/// <li> <c>MaximumMessageSize</c> - returns the limit of how many bytes a message can contain before Amazon SQS rejects it.</li>
/// <li> <c>MessageRetentionPeriod</c> - returns the number of seconds Amazon SQS retains a message.</li>
/// <li> <c>QueueArn</c> - returns the queue's Amazon resource name (ARN).</li>
/// <li> <c>ApproximateNumberOfMessagesDelayed</c> - returns the approximate number of messages that are pending to be added to the queue.</li>
/// <li> <c>DelaySeconds</c> - returns the default delay on the queue in seconds.</li>
/// <li> <c>ReceiveMessageWaitTimeSeconds</c> - returns the time for which a ReceiveMessage call will wait for a message to arrive.</li>
/// <li> <c>RedrivePolicy</c> - returns the parameters for dead letter queue functionality of the source queue. For more information about
/// RedrivePolicy and dead letter queues, see <a href="http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSDeadLetterQueue.html">Using Amazon SQS Dead Letter
/// Queues</a> in the <i>Amazon SQS Developer Guide</i> .</li>
///
/// </ul>
/// </para> <para><b>NOTE:</b>Going forward, new attributes might be added. If you are writing code that calls this action, we recommend that
/// you structure your code so that it can handle new attributes gracefully.</para> <para><b>NOTE:</b>Some API actions take lists of parameters.
/// These lists are specified using the param.n notation. Values of n are integers starting from 1. For example, a parameter list with two
/// elements looks like this: </para> <para> <c>&amp;Attribute.1=this</c> </para> <para> <c>&amp;Attribute.2=that</c> </para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetQueueAttributes service method on
/// AmazonSQS.</param>
///
/// <returns>The response from the GetQueueAttributes service method, as returned by AmazonSQS.</returns>
///
/// <exception cref="T:Amazon.SQS.Model.InvalidAttributeNameException" />
public GetQueueAttributesResponse GetQueueAttributes(GetQueueAttributesRequest request)
{
var task = GetQueueAttributesAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <summary>
/// Initiates the asynchronous execution of the GetQueueAttributes operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS.GetQueueAttributes"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetQueueAttributes operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public async Task<GetQueueAttributesResponse> GetQueueAttributesAsync(GetQueueAttributesRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetQueueAttributesRequestMarshaller();
var unmarshaller = GetQueueAttributesResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, GetQueueAttributesRequest, GetQueueAttributesResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
public void Test_GetQueueAttributes_And_Check_For_Valid_Value()
{
bool hasCallbackArrived = false;
string actualValue = "-1";
string expectedValue = "3";
SQSResponseEventHandler<object, ResponseEventArgs> handler = null;
handler = delegate(object sender, ResponseEventArgs args)
{
ISQSResponse result = args.Response;
//Unhook from event.
_client.OnSQSResponse -= handler;
GetQueueAttributesResponse response = result as GetQueueAttributesResponse;
if (null != response)
{
GetQueueAttributesResult attributeResult = response.GetQueueAttributesResult;
if (null != attributeResult)
{
if (response.GetQueueAttributesResult.Attribute.Count > 0)
actualValue = response.GetQueueAttributesResult.Attribute[0].Value;
}
}
hasCallbackArrived = true;
};
//Hook to event
_client.OnSQSResponse += handler;
//Create request object.
GetQueueAttributesRequest request = new GetQueueAttributesRequest();
request.QueueUrl = string.Format("{0}/{1}", QueueURL, _queue_UnitTesting);
request.AttributeName.Add("VisibilityTimeout");
_client.GetQueueAttributes(request);
EnqueueConditional(() => hasCallbackArrived);
EnqueueCallback(() => Assert.IsTrue(expectedValue == actualValue));
EnqueueTestComplete();
}
/// <summary>
/// <para>Gets attributes for the specified queue. The following attributes are supported:
/// <ul>
/// <li> <c>All</c> - returns all values.</li>
/// <li> <c>ApproximateNumberOfMessages</c> - returns the approximate number of visible messages in a queue. For more information, see
/// Resources Required to Process Messages in the Amazon SQS Developer Guide.</li>
/// <li> <c>ApproximateNumberOfMessagesNotVisible</c> - returns the approximate number of messages that are not timed-out and not deleted. For
/// more information, see Resources Required to Process Messages in the Amazon SQS Developer Guide.</li>
/// <li> <c>VisibilityTimeout</c> - returns the visibility timeout for the queue. For more information about visibility timeout, see Visibility
/// Timeout in the Amazon SQS Developer Guide.</li>
/// <li> <c>CreatedTimestamp</c> - returns the time when the queue was created (epoch time in seconds).</li>
/// <li> <c>LastModifiedTimestamp</c> - returns the time when the queue was last changed (epoch time in seconds).</li>
/// <li> <c>Policy</c> - returns the queue's policy.</li>
/// <li> <c>MaximumMessageSize</c> - returns the limit of how many bytes a message can contain before Amazon SQS rejects it.</li>
/// <li> <c>MessageRetentionPeriod</c> - returns the number of seconds Amazon SQS retains a message.</li>
/// <li> <c>QueueArn</c> - returns the queue's Amazon resource name (ARN).</li>
/// <li> <c>ApproximateNumberOfMessagesDelayed</c> - returns the approximate number of messages that are pending to be added to the queue.</li>
/// <li> <c>DelaySeconds</c> - returns the default delay on the queue in seconds.</li>
/// <li> <c>ReceiveMessageWaitTimeSeconds</c> - returns the time for which a ReceiveMessage call will wait for a message to arrive.</li>
///
/// </ul>
/// </para>
/// </summary>
///
/// <param name="getQueueAttributesRequest">Container for the necessary parameters to execute the GetQueueAttributes service method on
/// AmazonSQS.</param>
///
/// <returns>The response from the GetQueueAttributes service method, as returned by AmazonSQS.</returns>
///
/// <exception cref="InvalidAttributeNameException"/>
public GetQueueAttributesResponse GetQueueAttributes(GetQueueAttributesRequest getQueueAttributesRequest)
{
IAsyncResult asyncResult = invokeGetQueueAttributes(getQueueAttributesRequest, null, null, true);
return EndGetQueueAttributes(asyncResult);
}
/// <summary>
/// Initiates the asynchronous execution of the GetQueueAttributes operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS.GetQueueAttributes"/>
/// </summary>
///
/// <param name="getQueueAttributesRequest">Container for the necessary parameters to execute the GetQueueAttributes operation on
/// AmazonSQS.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking
/// EndGetQueueAttributes operation.</returns>
public IAsyncResult BeginGetQueueAttributes(GetQueueAttributesRequest getQueueAttributesRequest, AsyncCallback callback, object state)
{
return invokeGetQueueAttributes(getQueueAttributesRequest, callback, state, false);
}
public void PopulateQueueAttributes(QueueDescription queue)
{
var req = new GetQueueAttributesRequest() {
QueueUrl = queue.Url
};
req.AttributeNames.Add("ApproximateNumberOfMessages");
req.AttributeNames.Add("MessageRetentionPeriod");
var response = client.GetQueueAttributes(req);
if (response.Attributes != null && response.Attributes.Any()) {
foreach (KeyValuePair<string, string> att in response.Attributes) {
switch (att.Key) {
case "MessageRetentionPeriod":
queue.MessageRetentionPeriod = TimeSpan.FromSeconds(Double.Parse(att.Value));
break;
case "ApproximateNumberOfMessages":
queue.ApproximateNumberOfMessages = Int32.Parse(att.Value);
break;
}
}
}
}
/// <summary>
/// Returns the approximate number of queued messages
/// </summary>
public int ApproximateNumberOfMessages()
{
ClearErrorInfo();
int result = 0;
try
{
GetQueueAttributesRequest attrreq = new GetQueueAttributesRequest();
attrreq.QueueUrl = queueurl.QueueUrl;
attrreq.AttributeNames.Add("ApproximateNumberOfMessages");
GetQueueAttributesResponse attrresp = queue.GetQueueAttributes(attrreq);
if (attrresp != null)
result = attrresp.ApproximateNumberOfMessages;
}
catch (Exception ex)
{
ErrorCode = e_Exception;
ErrorMessage = ex.Message;
}
return result;
}
/// <summary>
/// <para>Gets attributes for the specified queue. The following attributes are supported:
/// <ul>
/// <li> <c>All</c> - returns all values.</li>
/// <li> <c>ApproximateNumberOfMessages</c> - returns the approximate number of visible messages in a queue. For more information, see
/// Resources Required to Process Messages in the Amazon SQS Developer Guide.</li>
/// <li> <c>ApproximateNumberOfMessagesNotVisible</c> - returns the approximate number of messages that are not timed-out and not deleted. For
/// more information, see Resources Required to Process Messages in the Amazon SQS Developer Guide.</li>
/// <li> <c>VisibilityTimeout</c> - returns the visibility timeout for the queue. For more information about visibility timeout, see Visibility
/// Timeout in the Amazon SQS Developer Guide.</li>
/// <li> <c>CreatedTimestamp</c> - returns the time when the queue was created (epoch time in seconds).</li>
/// <li> <c>LastModifiedTimestamp</c> - returns the time when the queue was last changed (epoch time in seconds).</li>
/// <li> <c>Policy</c> - returns the queue's policy.</li>
/// <li> <c>MaximumMessageSize</c> - returns the limit of how many bytes a message can contain before Amazon SQS rejects it.</li>
/// <li> <c>MessageRetentionPeriod</c> - returns the number of seconds Amazon SQS retains a message.</li>
/// <li> <c>QueueArn</c> - returns the queue's Amazon resource name (ARN).</li>
/// <li> <c>ApproximateNumberOfMessagesDelayed</c> - returns the approximate number of messages that are pending to be added to the queue.</li>
/// <li> <c>DelaySeconds</c> - returns the default delay on the queue in seconds.</li>
/// <li> <c>ReceiveMessageWaitTimeSeconds</c> - returns the time for which a ReceiveMessage call will wait for a message to arrive.</li>
///
/// </ul>
/// </para>
/// </summary>
///
/// <param name="getQueueAttributesRequest">Container for the necessary parameters to execute the GetQueueAttributes service method on
/// AmazonSQS.</param>
///
/// <returns>The response from the GetQueueAttributes service method, as returned by AmazonSQS.</returns>
///
/// <exception cref="T:Amazon.SQS.Model.InvalidAttributeNameException" />
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public Task<GetQueueAttributesResponse> GetQueueAttributesAsync(GetQueueAttributesRequest getQueueAttributesRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetQueueAttributesRequestMarshaller();
var unmarshaller = GetQueueAttributesResponseUnmarshaller.GetInstance();
return Invoke<IRequest, GetQueueAttributesRequest, GetQueueAttributesResponse>(getQueueAttributesRequest, marshaller, unmarshaller, signer, cancellationToken);
}
private Amazon.SQS.Model.GetQueueAttributesResponse CallAWSServiceOperation(IAmazonSQS client, Amazon.SQS.Model.GetQueueAttributesRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Simple Queue Service (SQS)", "GetQueueAttributes");
try
{
#if DESKTOP
return(client.GetQueueAttributes(request));
#elif CORECLR
return(client.GetQueueAttributesAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}