internal void AllowSnsToSendMessages(TopicClient topicClient)
{
var policyFormat = @"{
""Statement"": [
{
""Sid"": ""MySQSPolicy001"",
""Effect"": ""Allow"",
""Principal"": {
""AWS"": ""*""
},
""Action"": ""sqs:SendMessage"",
""Resource"": ""%QueueArn%"",
""Condition"": {
""ArnEquals"": {
""aws:SourceArn"": ""%TopicArn%""
}
}
}
]
}";
var policy = policyFormat.Replace("%QueueArn%", QueueArn).Replace("%TopicArn%", topicClient.TopicArn);
var request = new SetQueueAttributesRequest();
request.Attributes.Add("Policy", policy);
request.QueueUrl = QueueUrl;
var response = _sqsClient.SetQueueAttributes(request);
}
/// <inheritdoc/>
public SetQueueAttributesResponse SetAttributes(SetQueueAttributesRequest request)
{
return(AggregateExceptionExtract.Extract(() =>
{
return SetAttributesAsync(request).Result;
}));
}
internal SetQueueAttributesResponse SetQueueAttributes(SetQueueAttributesRequest request)
{
var marshaller = new SetQueueAttributesRequestMarshaller();
var unmarshaller = SetQueueAttributesResponseUnmarshaller.Instance;
return(Invoke <SetQueueAttributesRequest, SetQueueAttributesResponse>(request, marshaller, unmarshaller));
}
public virtual void GrantNotificationPermission(AmazonSQSClient sqsClient, string queueArn, string queueUrl,
string topicArn)
{
// Create a policy to allow the queue to receive notifications from the SNS topic
var policy = new Policy("SubscriptionPermission")
{
Statements =
{
new Statement(Statement.StatementEffect.Allow)
{
Actions = { SQSActionIdentifiers.SendMessage },
Principals ={ new Principal("*") },
Conditions ={ ConditionFactory.NewSourceArnCondition(topicArn) },
Resources = { new Resource(queueArn) }
}
}
};
var attributes = new Dictionary <string, string>();
attributes.Add("Policy", policy.ToJson());
// Create the request to set the queue attributes for policy
var setQueueAttributesRequest = new SetQueueAttributesRequest
{
QueueUrl = queueUrl,
Attributes = attributes
};
// Set the queue policy
sqsClient.SetQueueAttributes(setQueueAttributesRequest);
}
/// <summary>
/// Initiates the asynchronous execution of the SetQueueAttributes operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SetQueueAttributes 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 <SetQueueAttributesResponse> SetQueueAttributesAsync(SetQueueAttributesRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SetQueueAttributesRequestMarshaller();
var unmarshaller = SetQueueAttributesResponseUnmarshaller.Instance;
return(Invoke <IRequest, SetQueueAttributesRequest, SetQueueAttributesResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
private static IDictionary <string, string> ConvertSetQueueAttributes(SetQueueAttributesRequest request)
{
IDictionary <string, string> dictionary = new Dictionary <string, string>();
dictionary["Action"] = "SetQueueAttributes";
if (request.IsSetQueueUrl())
{
dictionary["QueueUrl"] = request.QueueUrl;
}
List <Amazon.SQS.Model.Attribute> list = request.Attribute;
int num = 1;
foreach (Amazon.SQS.Model.Attribute attribute in list)
{
if (attribute.IsSetName())
{
dictionary[string.Concat(new object[] { "Attribute", ".", num, ".", "Name" })] = attribute.Name;
}
if (attribute.IsSetValue())
{
dictionary[string.Concat(new object[] { "Attribute", ".", num, ".", "Value" })] = attribute.Value;
}
num++;
}
return(dictionary);
}
public virtual async Task UpdateQueueAttributeAsync(SqsBasicConfiguration queueConfig)
{
if (QueueNeedsUpdating(queueConfig))
{
var request = new SetQueueAttributesRequest
{
QueueUrl = Url,
Attributes = new Dictionary <string, string>
{
{ JustSayingConstants.ATTRIBUTE_RETENTION_PERIOD, queueConfig.MessageRetentionSeconds.ToString() },
{
JustSayingConstants.ATTRIBUTE_VISIBILITY_TIMEOUT,
queueConfig.VisibilityTimeoutSeconds.ToString()
},
{ JustSayingConstants.ATTRIBUTE_DELIVERY_DELAY, queueConfig.DeliveryDelaySeconds.ToString() }
}
};
var response = await Client.SetQueueAttributesAsync(request).ConfigureAwait(false);
if (response.HttpStatusCode == HttpStatusCode.OK)
{
MessageRetentionPeriod = queueConfig.MessageRetentionSeconds;
VisibilityTimeout = queueConfig.VisibilityTimeoutSeconds;
DeliveryDelay = queueConfig.DeliveryDelaySeconds;
}
}
}
/**
* Convert SetQueueAttributesRequest to name value pairs
*/
private IDictionary <String, String> ConvertSetQueueAttributes(SetQueueAttributesRequest request)
{
IDictionary <String, String> parameters = new Dictionary <String, String>();
parameters.Add("Action", "SetQueueAttributes");
if (request.IsSetQueueUrl())
{
parameters.Add("QueueUrl", request.QueueUrl);
}
List <Attribute> setQueueAttributesRequestAttributeList = request.Attribute;
int setQueueAttributesRequestAttributeListIndex = 1;
foreach (Attribute setQueueAttributesRequestAttribute in setQueueAttributesRequestAttributeList)
{
if (setQueueAttributesRequestAttribute.IsSetName())
{
parameters.Add("Attribute" + "." + setQueueAttributesRequestAttributeListIndex + "." + "Name", setQueueAttributesRequestAttribute.Name);
}
if (setQueueAttributesRequestAttribute.IsSetValue())
{
parameters.Add("Attribute" + "." + setQueueAttributesRequestAttributeListIndex + "." + "Value", setQueueAttributesRequestAttribute.Value);
}
setQueueAttributesRequestAttributeListIndex++;
}
return(parameters);
}
public static async Task <string> CreateDelayDelivery(IAmazonSQS sqs, string prefix, string endpointName, double delayInSeconds, double retentionPeriodInSeconds, string suffix)
{
var delayedDeliveryQueueName = $"{prefix}{endpointName}{suffix}";
var sqsRequest = new CreateQueueRequest
{
QueueName = delayedDeliveryQueueName,
Attributes = new Dictionary <string, string> {
{ "FifoQueue", "true" }
}
};
await Console.Out.WriteLineAsync($"Creating SQS delayed delivery queue with name '{sqsRequest.QueueName}' for endpoint '{endpointName}'.");
var createQueueResponse = await sqs.CreateQueueAsync(sqsRequest).ConfigureAwait(false);
var sqsAttributesRequest = new SetQueueAttributesRequest {
QueueUrl = createQueueResponse.QueueUrl
};
sqsAttributesRequest.Attributes.Add(QueueAttributeName.MessageRetentionPeriod, retentionPeriodInSeconds.ToString(CultureInfo.InvariantCulture));
sqsAttributesRequest.Attributes.Add(QueueAttributeName.DelaySeconds, delayInSeconds.ToString(CultureInfo.InvariantCulture));
await sqs.SetQueueAttributesAsync(sqsAttributesRequest).ConfigureAwait(false);
await Console.Out.WriteLineAsync($"Created SQS delayed delivery queue with name '{sqsRequest.QueueName}' for endpoint '{endpointName}'.");
return(createQueueResponse.QueueUrl);
}
public string SetSqsPolicyForSnsPublish(Uri queueUrl, string queueArn, string mytopicArn)
{
queueUrl.Requires("queueUrl").IsNotNull();
queueArn.Requires("queueArn").IsNotNullOrWhiteSpace();
mytopicArn.Requires("mytopicArn").IsNotNullOrWhiteSpace();
var sqsPolicy = new Policy().WithStatements(
new Statement(Statement.StatementEffect.Allow)
.WithResources(new Resource(queueArn))
.WithPrincipals(Principal.AllUsers)
.WithActionIdentifiers(SQSActionIdentifiers.SendMessage)
.WithConditions(ConditionFactory.NewCondition(ConditionFactory.ArnComparisonType.ArnEquals,
ConditionSourceArn, mytopicArn)));
var attributes = new Dictionary <string, string>
{
{ QueueAttributeName.Policy, sqsPolicy.ToJson() }
};
var setQueueAttributesRequest = new SetQueueAttributesRequest(queueUrl.AbsoluteUri, attributes);
using (var sqs = amazonSqsFactory())
{
var response = sqs.SetQueueAttributes(setQueueAttributesRequest);
return(response.ResponseMetadata.RequestId);
}
}
public static void SQSSetQueueAttributes()
{
#region SQSSetQueueAttributes
var client = new AmazonSQSClient();
var attrs = new Dictionary <string, string>();
// Maximum message size of 128 KiB (1,024 bytes * 128 KiB = 131,072 bytes).
int maxMessage = 128 * 1024;
attrs.Add(QueueAttributeName.DelaySeconds,
TimeSpan.FromSeconds(5).TotalSeconds.ToString());
attrs.Add(QueueAttributeName.MaximumMessageSize, maxMessage.ToString());
attrs.Add(QueueAttributeName.MessageRetentionPeriod,
TimeSpan.FromDays(1).TotalSeconds.ToString());
attrs.Add(QueueAttributeName.ReceiveMessageWaitTimeSeconds,
TimeSpan.FromSeconds(5).TotalSeconds.ToString());
attrs.Add(QueueAttributeName.VisibilityTimeout,
TimeSpan.FromHours(1).TotalSeconds.ToString());
// Dead-letter queue attributes.
attrs.Add(QueueAttributeName.RedrivePolicy,
"{\"maxReceiveCount\":" +
"\"5\"," +
"\"deadLetterTargetArn\":" +
"\"arn:aws:sqs:us-east-1:80398EXAMPLE:MyTestDeadLetterQueue\"}");
var request = new SetQueueAttributesRequest
{
Attributes = attrs,
QueueUrl = "https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyTestQueue"
};
client.SetQueueAttributes(request);
#endregion
}
/**
* Convert SetQueueAttributesRequest to name value pairs
*/
private static IDictionary <string, string> ConvertSetQueueAttributes(SetQueueAttributesRequest request)
{
IDictionary <string, string> parameters = new Dictionary <string, string>();
parameters["Action"] = "SetQueueAttributes";
if (request.IsSetQueueUrl())
{
parameters["QueueUrl"] = request.QueueUrl;
}
List <Attribute> setQueueAttributesRequestAttributeList = request.Attribute;
int setQueueAttributesRequestAttributeListIndex = 1;
foreach (Attribute setQueueAttributesRequestAttribute in setQueueAttributesRequestAttributeList)
{
if (setQueueAttributesRequestAttribute.IsSetName())
{
parameters[String.Concat("Attribute", ".", setQueueAttributesRequestAttributeListIndex, ".", "Name")] = setQueueAttributesRequestAttribute.Name;
}
if (setQueueAttributesRequestAttribute.IsSetValue())
{
parameters[String.Concat("Attribute", ".", setQueueAttributesRequestAttributeListIndex, ".", "Value")] = setQueueAttributesRequestAttribute.Value;
}
setQueueAttributesRequestAttributeListIndex++;
}
return(parameters);
}
public override async Task UpdateQueueAttributeAsync(SqsBasicConfiguration queueConfig)
{
if (!QueueNeedsUpdating(queueConfig))
{
return;
}
var request = new SetQueueAttributesRequest
{
QueueUrl = Url,
Attributes = new Dictionary <string, string>
{
{
JustSayingConstants.ATTRIBUTE_RETENTION_PERIOD,
queueConfig.ErrorQueueRetentionPeriodSeconds.ToString()
}
}
};
var response = await Client.SetQueueAttributesAsync(request);
if (response.HttpStatusCode == HttpStatusCode.OK)
{
MessageRetentionPeriod = queueConfig.ErrorQueueRetentionPeriodSeconds;
}
}
internal static async Task SaveAsync(SqsPolicyDetails policyDetails, IAmazonSQS client)
{
var topicArnWildcard = CreateTopicArnWildcard(policyDetails.SourceArn);
var policyJson = $@"{{
""Version"" : ""2012-10-17"",
""Statement"" : [
{{
""Sid"" : ""{Guid.NewGuid().ToString().Replace("-", "")}"",
""Effect"" : ""Allow"",
""Principal"" : {{
""AWS"" : ""*""
}},
""Action"" : ""sqs:SendMessage"",
""Resource"" : ""{policyDetails.QueueArn}"",
""Condition"" : {{
""ArnLike"" : {{
""aws:SourceArn"" : ""{topicArnWildcard}""
}}
}}
}}
]
}}";
var setQueueAttributesRequest = new SetQueueAttributesRequest
{
QueueUrl = policyDetails.QueueUri.AbsoluteUri,
Attributes =
{
["Policy"] = policyJson
}
};
await client.SetQueueAttributesAsync(setQueueAttributesRequest).ConfigureAwait(false);
}
static async Task MainAsync(IConfigurationRoot configuration)
{
var serviceUrl = configuration.GetConnectionString("");
var queueName = configuration.GetSection("").Value;
var sqsConfig = new AmazonSQSConfig {
ServiceURL = serviceUrl
};
AmazonSQSClient sqsClient = new AmazonSQSClient(sqsConfig);
var request = new CreateQueueRequest
{
QueueName = queueName,
Attributes = new Dictionary <string, string>
{
{ "ReceiveMessageWaitTimeSeconds", "20" },
}
};
var createQueueResponse = await sqsClient.CreateQueueAsync(request);
if (createQueueResponse.HttpStatusCode == HttpStatusCode.OK)
{
var setQueueAttributeRequest = new SetQueueAttributesRequest
{
Attributes = new Dictionary <string, string>
{
{
"RedrivePolicy",
@"{ ""deadLetterTargetArn"" : ""DEAD_LETTER_QUEUE_ARN"", ""maxReceiveCount"" : ""10""}"
}
},
QueueUrl = createQueueResponse.QueueUrl
};
await sqsClient.SetQueueAttributesAsync(setQueueAttributeRequest);
await ConsumeQueue(sqsClient, createQueueResponse.QueueUrl);
}
}
protected override bool Execute(AmazonSQS client)
{
Log.LogMessage(MessageImportance.Normal, "Granting SendMessage rights to SQS Queue at {0}", QueueUrl);
string queueArn = GetQueueArn(client, QueueUrl);
Log.LogMessage(MessageImportance.Low, "Queue {0} Arn: {1}", QueueUrl, queueArn);
var request = new SetQueueAttributesRequest {
QueueUrl = QueueUrl
};
var attribute = new Attribute {
Name = "Policy", Value = ConstructPolicy(queueArn, SourceArn)
};
request.Attribute = new List <Attribute> {
attribute
};
client.SetQueueAttributes(request);
Logger.LogMessage(MessageImportance.Normal, "Granted rights for source {0} to SendMessage to SQS at {1}", SourceArn, QueueUrl);
return(true);
}
public override async Task UpdateQueueAttributeAsync(SqsBasicConfiguration queueConfig)
{
if (!QueueNeedsUpdating(queueConfig))
{
return;
}
var request = new SetQueueAttributesRequest
{
QueueUrl = Uri.AbsoluteUri,
Attributes = new Dictionary <string, string>
{
{
JustSayingConstants.AttributeRetentionPeriod,
queueConfig.ErrorQueueRetentionPeriodSeconds.ToString(CultureInfo.InvariantCulture)
}
}
};
var response = await Client.SetQueueAttributesAsync(request).ConfigureAwait(false);
if (response.HttpStatusCode == HttpStatusCode.OK)
{
MessageRetentionPeriod = queueConfig.ErrorQueueRetentionPeriodSeconds;
}
}
/// <inheritdoc/>
public SetQueueAttributesResponse SetAttributes(QueueAttributes attributes)
{
var request = new SetQueueAttributesRequest {
Attributes = attributes
};
return(SetAttributes(request));
}
public async Task <SetQueueAttributesResponse> SetAttributesAsync(QueueAttributes attributes)
{
var request = new SetQueueAttributesRequest {
Attributes = attributes
};
return(await SetAttributesAsync(request).ConfigureAwait(false));
}
private void setMaximumMessageSize(String queueUrl)
{
Amazon.SQS.Model.Attribute[] attrs = new Amazon.SQS.Model.Attribute[1];
attrs[0] = new Amazon.SQS.Model.Attribute().WithName("MaximumMessageSize").WithValue("65536");
SetQueueAttributesRequest request = new SetQueueAttributesRequest().WithQueueUrl(queueUrl).WithAttribute(attrs);
sqs.SetQueueAttributes(request);
}
/// <inheritdoc/>
public SetQueueAttributesResponse SetAttributes(SetQueueAttributesRequest request)
{
request.QueueName = this.QueueName;
var marshaller = new SetQueueAttributesRequestMarshaller();
var unmarshaller = SetQueueAttributesResponseUnmarshaller.Instance;
return(_serviceClient.Invoke <SetQueueAttributesRequest, SetQueueAttributesResponse>(request, marshaller, unmarshaller));
}
public async Task <SetQueueAttributesResponse> SetAttributesAsync(SetQueueAttributesRequest request)
{
request.QueueName = this.QueueName;
var marshaller = new SetQueueAttributesRequestMarshaller();
var unmarshaller = SetQueueAttributesResponseUnmarshaller.Instance;
return(await _serviceClient.InvokeAsync <SetQueueAttributesRequest, SetQueueAttributesResponse>(request, marshaller, unmarshaller).ConfigureAwait(false));
}
private void SetPermissions()
{
var setQueueAttributeRequest = new SetQueueAttributesRequest()
.WithQueueUrl(_config.SqsQueueUrl)
.WithAttribute(new Attribute {
Name = "Policy", Value = AllowSnsAttribute()
});
_client.SetQueueAttributes(setQueueAttributeRequest);
}
/// <inheritdoc/>
public IAsyncResult BeginSetAttributes(SetQueueAttributesRequest request, AsyncCallback callback, object state)
{
request.QueueName = this.QueueName;
var marshaller = new SetQueueAttributesRequestMarshaller();
var unmarshaller = SetQueueAttributesResponseUnmarshaller.Instance;
return(_serviceClient.BeginInvoke <SetQueueAttributesRequest>(request, marshaller, unmarshaller,
callback, state));
}
public async void ReceiveMessage(string queueUrl)
{
var receiveReq = new SetQueueAttributesRequest
{
Attributes = new Dictionary <string, string>
{
{ "ReceiveMessageWaitTimeSeconds", "20" }
},
QueueUrl = queueUrl
};
var res = await sqs.SetQueueAttributesAsync(receiveReq);
}
internal SetQueueAttributesResponse SetQueueAttributes(SetQueueAttributesRequest request)
{
var task = SetQueueAttributesAsync(request);
try
{
return(task.Result);
}
catch (AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return(null);
}
}
private void SetQueueVisibilityTimeoutAttribute(int visibilityTimeOutInMinutes)
{
Dictionary <string, string> queueAttributes = new Dictionary <string, string>();
queueAttributes.Add("VisibilityTimeout", (visibilityTimeOutInMinutes * 60).ToString());
SetQueueAttributesRequest setQueueAttributesRequest = new SetQueueAttributesRequest(this.queueUrl, queueAttributes);
SetQueueAttributesResponse setQueueAttributesResponse = this.sqsClient.SetQueueAttributes(setQueueAttributesRequest);
if (setQueueAttributesResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new InvalidOperationException("Queue was created if not existed but unable to set visibility time out!");
}
}
public void ReceiveMessageMultipleTimes_UsingDeadLetterQueue_MessageShouldBePlacedInDeadLetterQueue()
{
const string sourceQueueName = "SourceQueue_RedrivePolicy_StandardQueue";
const string deadLetterQueueName = "DeadLetterQueue_StandardQueue";
var message = new SqsMessage("Test");
var createQueueResponse = _sqs.CreateQueue(sourceQueueName);
var deadLetterQueueResponse = _sqs.CreateQueue(deadLetterQueueName);
var queueAttrs = _sqs.GetQueueAttributes(new GetQueueAttributesRequest(deadLetterQueueResponse.QueueUrl, new List <string> {
"QueueArn"
}));
var sqsRequest = new SetQueueAttributesRequest()
{
Attributes = new Dictionary <string, string>()
{
{ QueueAttributeName.RedrivePolicy, "{\"maxReceiveCount\":\"5\", \"deadLetterTargetArn\":\"" + queueAttrs.QueueARN + "\"}" }
},
QueueUrl = createQueueResponse.QueueUrl
};
_sqs.SetQueueAttributes(sqsRequest);
_queueUrl = createQueueResponse.QueueUrl;
// Send a message for the source queue
var response = _sqs.SendMessage(new SendMessageRequest(_queueUrl, message.Body));
var receiveMessageRequest = new ReceiveMessageRequest()
{
QueueUrl = _queueUrl
};
// Read from the source queue multiple times
for (int i = 0; i < 6; i++)
{
var receiveMessageResponse = _sqs.ReceiveMessage(receiveMessageRequest);
}
var deadLetterQueueMessageResponse = _sqs.ReceiveMessage(deadLetterQueueResponse.QueueUrl);
// Verify that the message has moved to the dead-letter queue
Assert.Equal(message.Body, deadLetterQueueMessageResponse.Messages.First().Body);
// Cleanup
SqsQueueUtils.DeleteQueue(deadLetterQueueResponse.QueueUrl, _sqs);
}
public void DeadLetterQueueExample()
{
AmazonSQSClient client = new AmazonSQSClient();
var setQueueAttributeRequest = new SetQueueAttributesRequest
{
Attributes = new Dictionary <string, string>
{
{ "RedrivePolicy", @"{ ""deadLetterTargetArn"" : ""DEAD_LETTER_QUEUE_ARN"", ""maxReceiveCount"" : ""10""}" }
},
QueueUrl = "SOURCE_QUEUE_URL"
};
client.SetQueueAttributes(setQueueAttributeRequest);
}
public void OnExistingQueue()
{
AmazonSQSClient client = new AmazonSQSClient();
var request = new SetQueueAttributesRequest
{
Attributes = new Dictionary <string, string>
{
{ "ReceiveMessageWaitTimeSeconds", "20" }
},
QueueUrl = "SQS_QUEUE_URL"
};
var response = client.SetQueueAttributes(request);
}
