public async void TestMultipleQueueSubscription()
{
var topicName1 = UtilityMethods.GenerateName("TestMultipleQueueSubscription");
var topic = await Client.CreateTopicAsync(topicName1);
_topicArns.Add(topic.TopicArn);
var topicName2 = UtilityMethods.GenerateName("TestMultipleQueueSubscription2");
var response = await Client.CreateTopicAsync(topicName2);
_topicArns.Add(response.TopicArn);
var queueName = UtilityMethods.GenerateName("TestMultipleQueueSubscription");
var queueUrl = (await sqsClient.CreateQueueAsync(queueName)).QueueUrl;
_queueUrl.Add(queueUrl);
ICoreAmazonSQS coreSqs = sqsClient as ICoreAmazonSQS;
var topics = await Client.SubscribeQueueToTopicsAsync(_topicArns, coreSqs, queueUrl);
var subscriptionArns = topics.Values;
Assert.Equal(2, subscriptionArns.Count);
Thread.Sleep(TimeSpan.FromSeconds(5));
var attributes = (await sqsClient.GetQueueAttributesAsync(queueUrl, new List <string> {
"All"
})).Attributes;
var policy = Policy.FromJson(attributes["Policy"]);
Assert.Equal(2, policy.Statements.Count);
}
/// <summary>
/// Subscribes an existing Amazon SQS queue to an existing Amazon SNS topic.
/// <para>
/// The policy applied to the SQS queue is similar to this:
/// <code>
/// {
/// "Version" : "2008-10-17",
/// "Statement" : [{
/// "Sid" : "topic-subscription-arn:aws:sns:us-west-2:599109622955:myTopic",
/// "Effect" : "Allow",
/// "Principal" : "*",
/// "Action" : ["sqs:SendMessage"],
/// "Resource":["arn:aws:sqs:us-west-2:599109622955:myQueue"],
/// "Condition" : {
/// "ArnLike":{
/// "aws:SourceArn":["arn:aws:sns:us-west-2:599109622955:myTopic"]
/// }
/// }
/// }]
/// }
/// </code>
/// </para>
/// <para>
/// There might be a small time period immediately after
/// subscribing the SQS queue to the SNS topic and updating the SQS queue's
/// policy, where messages are not able to be delivered to the queue. After a
/// moment, the new queue policy will propagate and the queue will be able to
/// receive messages. This delay only occurs immediately after initially
/// subscribing the queue.
/// </para>
/// </summary>
/// <param name="topicArn">The topic to subscribe to</param>
/// <param name="sqsClient">The SQS client used to get attributes and set the policy on the SQS queue.</param>
/// <param name="sqsQueueUrl">The queue to add a subscription to.</param>
/// <returns>The subscription ARN as returned by Amazon SNS when the queue is
/// successfully subscribed to the topic.</returns>
public string SubscribeQueue(string topicArn, ICoreAmazonSQS sqsClient, string sqsQueueUrl)
{
return(SubscribeQueueToTopics(new List <string>()
{
topicArn
}, sqsClient, sqsQueueUrl).Values.First());
}
/// <summary>
///
/// </summary>
/// <param name="topicArn"></param>
/// <param name="sqsClient"></param>
/// <param name="sqsQueueUrl"></param>
public async Task SubscribeSQS(string topicArn, ICoreAmazonSQS sqsClient, string sqsQueueUrl)
{
using (var client = new AmazonSimpleNotificationServiceClient(accessKey, secretKey, region))
{
var subscriptionArn = await client.SubscribeQueueAsync(topicArn, sqsClient, sqsQueueUrl);
await client.SetSubscriptionAttributesAsync(subscriptionArn, "RawMessageDelivery", "true");
}
}
private async Task <string> SubscribeQueue(string topicArn, string queueUrl)
{
ICoreAmazonSQS coreSqs = sqsClient as ICoreAmazonSQS;
var subscriptionARN = await Client.SubscribeQueueAsync(topicArn, coreSqs, queueUrl);
// Sleep to wait for the subscribe to complete.
Thread.Sleep(TimeSpan.FromSeconds(5));
return(subscriptionARN);
}
public async Task SubscribeQueueToSnsTopic(string topicArn, ICoreAmazonSQS sqsClient, string sqsUrl)
{
if (string.IsNullOrWhiteSpace(topicArn))
{
throw new ArgumentNullException(nameof(topicArn));
}
if (sqsClient == null)
{
throw new ArgumentNullException(nameof(sqsClient));
}
if (string.IsNullOrWhiteSpace(sqsUrl))
{
throw new ArgumentNullException(nameof(sqsUrl));
}
this._logger?.LogInformation($"subscribe queue to SNS topic {topicArn} with queue {sqsUrl}");
await this._snsClient.SubscribeQueueAsync(topicArn, sqsClient, sqsUrl);
this._logger?.LogInformation($"subscribe queue to SNS topic {topicArn} with queue {sqsUrl} completed");
}
/// <summary>
/// Subscribes an existing Amazon SQS queue to existing Amazon SNS topics.
/// <para>
/// The policy applied to the SQS queue is similar to this:
/// <code>
/// {
/// "Version" : "2008-10-17",
/// "Statement" : [{
/// "Sid" : "topic-subscription-arn:aws:sns:us-west-2:599109622955:myTopic",
/// "Effect" : "Allow",
/// "Principal" : "*",
/// "Action" : ["sqs:SendMessage"],
/// "Resource":["arn:aws:sqs:us-west-2:599109622955:myQueue"],
/// "Condition" : {
/// "ArnLike":{
/// "aws:SourceArn":["arn:aws:sns:us-west-2:599109622955:myTopic"]
/// }
/// }
/// }]
/// }
/// </code>
/// </para>
/// <para>
/// There might be a small time period immediately after
/// subscribing the SQS queue to the SNS topic and updating the SQS queue's
/// policy, where messages are not able to be delivered to the queue. After a
/// moment, the new queue policy will propagate and the queue will be able to
/// receive messages. This delay only occurs immediately after initially
/// subscribing the queue.
/// </para>
/// </summary>
/// <param name="topicArns">The topics to subscribe to</param>
/// <param name="sqsClient">The SQS client used to get attributes and set the policy on the SQS queue.</param>
/// <param name="sqsQueueUrl">The queue to add a subscription to.</param>
/// <returns>The mapping of topic ARNs to subscription ARNs as returned by Amazon SNS when the queue is
/// successfully subscribed to each topic.</returns>
public IDictionary <string, string> SubscribeQueueToTopics(IList <string> topicArns, ICoreAmazonSQS sqsClient, string sqsQueueUrl)
{
// Get the queue's existing policy and ARN
var queueAttributes = sqsClient.GetAttributes(sqsQueueUrl);
string sqsQueueArn = queueAttributes["QueueArn"];
Policy policy;
string policyStr = null;
if (queueAttributes.ContainsKey("Policy"))
{
policyStr = queueAttributes["Policy"];
}
if (string.IsNullOrEmpty(policyStr))
{
policy = new Policy();
}
else
{
policy = Policy.FromJson(policyStr);
}
var subscriptionArns = new Dictionary <string, string>();
foreach (var topicArn in topicArns)
{
if (!HasSQSPermission(policy, topicArn, sqsQueueArn))
{
AddSQSPermission(policy, topicArn, sqsQueueArn);
}
var arn = this.Subscribe(new SubscribeRequest
{
TopicArn = topicArn,
Protocol = "sqs",
Endpoint = sqsQueueArn
}).SubscriptionArn;
subscriptionArns.Add(topicArn, arn);
}
var setAttributes = new Dictionary <string, string> {
{ "Policy", policy.ToJson() }
};
sqsClient.SetAttributes(sqsQueueUrl, setAttributes);
return(subscriptionArns);
}
/// <summary>
/// Subscribes an existing Amazon SQS queue to an existing Amazon SNS topic asynchronously.
/// <para>
/// The policy applied to the SQS queue is similar to this:
/// <code>
/// {
/// "Version" : "2008-10-17",
/// "Statement" : [{
/// "Sid" : "topic-subscription-arn:aws:sns:us-west-2:599109622955:myTopic",
/// "Effect" : "Allow",
/// "Principal" : "*",
/// "Action" : ["sqs:SendMessage"],
/// "Resource":["arn:aws:sqs:us-west-2:599109622955:myQueue"],
/// "Condition" : {
/// "ArnLike":{
/// "aws:SourceArn":["arn:aws:sns:us-west-2:599109622955:myTopic"]
/// }
/// }
/// }]
/// }
/// </code>
/// </para>
/// <para>
/// There might be a small time period immediately after
/// subscribing the SQS queue to the SNS topic and updating the SQS queue's
/// policy, where messages are not able to be delivered to the queue. After a
/// moment, the new queue policy will propagate and the queue will be able to
/// receive messages. This delay only occurs immediately after initially
/// subscribing the queue.
/// </para>
/// </summary>
/// <param name="topicArn">The topic to subscribe to</param>
/// <param name="sqsClient">The SQS client used to get attributes and set the policy on the SQS queue.</param>
/// <param name="sqsQueueUrl">The queue to add a subscription to.</param>
/// <returns>The subscription ARN as returned by Amazon SNS when the queue is
/// successfully subscribed to the topic.</returns>
public async Task <string> SubscribeQueueAsync(string topicArn, ICoreAmazonSQS sqsClient, string sqsQueueUrl)
{
var topics = await SubscribeQueueToTopicsAsync(new List <string>() { topicArn }, sqsClient, sqsQueueUrl).ConfigureAwait(false);
return(topics.Values.First());
}
public async void TestQueueSubscription()
{
// create new topic
var topicName = UtilityMethods.GenerateName("TestQueueSubscription");
var createTopicRequest = new CreateTopicRequest
{
Name = topicName
};
var createTopicResult = await Client.CreateTopicAsync(createTopicRequest);
var topicArn = createTopicResult.TopicArn;
_topicArns.Add(topicArn);
var queueName = UtilityMethods.GenerateName("TestQueueSubscription");
var queueUrl = (await sqsClient.CreateQueueAsync(new CreateQueueRequest
{
QueueName = queueName
})).QueueUrl;
_queueUrl.Add(queueUrl);
ICoreAmazonSQS coreSqs = sqsClient as ICoreAmazonSQS;
var subscriptionARN = await Client.SubscribeQueueAsync(topicArn, coreSqs, queueUrl);
// Sleep to wait for the subscribe to complete.
Thread.Sleep(TimeSpan.FromSeconds(5));
var publishRequest = new PublishRequest
{
TopicArn = topicArn,
Subject = "Test Subject",
Message = "Test Message",
MessageAttributes = new Dictionary <string, SNSMessageAttributeValue>
{
{ "Color", new SNSMessageAttributeValue {
StringValue = "Red", DataType = "String"
} },
{ "Binary", new SNSMessageAttributeValue {
DataType = "Binary", BinaryValue = new MemoryStream(Encoding.UTF8.GetBytes("Yes please"))
} },
{ "Prime", new SNSMessageAttributeValue {
StringValue = "31", DataType = "Number"
} },
}
};
await Client.PublishAsync(publishRequest);
var messages = (await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest
{
QueueUrl = queueUrl,
WaitTimeSeconds = 20
})).Messages;
Assert.Equal(1, messages.Count);
var message = messages[0];
string bodyJson;
// Handle some accounts returning message body as base 64 encoded.
if (message.Body.Trim()[0] == '{')
{
bodyJson = message.Body;
}
else
{
bodyJson = Encoding.UTF8.GetString(Convert.FromBase64String(message.Body));
}
var json = ThirdParty.Json.LitJson.JsonMapper.ToObject(bodyJson);
var messageText = json["Message"];
var messageSubject = json["Subject"];
Assert.Equal(publishRequest.Message, messageText.ToString());
Assert.Equal(publishRequest.Subject, messageSubject.ToString());
var messageAttributes = json["MessageAttributes"];
Assert.Equal(publishRequest.MessageAttributes.Count, messageAttributes.Count);
foreach (var ma in publishRequest.MessageAttributes)
{
var name = ma.Key;
var value = ma.Value;
Assert.True(messageAttributes.PropertyNames.Contains(name, StringComparer.Ordinal));
var jsonAttribute = messageAttributes[name];
var jsonType = jsonAttribute["Type"].ToString();
var jsonValue = jsonAttribute["Value"].ToString();
Assert.NotNull(jsonType);
Assert.NotNull(jsonValue);
Assert.Equal(value.DataType, jsonType);
Assert.Equal(value.DataType != "Binary"
? value.StringValue
: Convert.ToBase64String(value.BinaryValue.ToArray()), jsonValue);
}
await sqsClient.DeleteMessageAsync(new DeleteMessageRequest
{
QueueUrl = queueUrl,
ReceiptHandle = messages[0].ReceiptHandle
});
// This will unsubscribe but leave the policy in place.
await Client.UnsubscribeAsync(new UnsubscribeRequest
{
SubscriptionArn = subscriptionARN
});
// Subscribe again to see if this affects the policy.
await Client.SubscribeQueueAsync(topicArn, coreSqs, queueUrl);
await Client.PublishAsync(new PublishRequest
{
TopicArn = topicArn,
Message = "Test Message again"
});
messages = (await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest
{
QueueUrl = queueUrl,
WaitTimeSeconds = 20
})).Messages;
Assert.Equal(1, messages.Count);
var response = WaitUtils.WaitForComplete(
() => {
return(sqsClient.GetQueueAttributesAsync(new GetQueueAttributesRequest
{
AttributeNames = new List <string> {
"All"
},
QueueUrl = queueUrl
}).Result);
},
(r) =>
{
return(!string.IsNullOrEmpty(r.Policy));
});
var policy = Policy.FromJson(response.Policy);
Assert.Equal(1, policy.Statements.Count);
}
/// <summary>
/// Subscribes an existing Amazon SQS queue to an existing Amazon SNS topic asynchronously.
/// <para>
/// The policy applied to the SQS queue is similar to this:
/// <code>
/// {
/// "Version" : "2008-10-17",
/// "Statement" : [{
/// "Sid" : "topic-subscription-arn:aws:sns:us-west-2:599109622955:myTopic",
/// "Effect" : "Allow",
/// "Principal" : "*",
/// "Action" : ["sqs:SendMessage"],
/// "Resource":["arn:aws:sqs:us-west-2:599109622955:myQueue"],
/// "Condition" : {
/// "ArnLike":{
/// "aws:SourceArn":["arn:aws:sns:us-west-2:599109622955:myTopic"]
/// }
/// }
/// }]
/// }
/// </code>
/// </para>
/// <para>
/// There might be a small time period immediately after
/// subscribing the SQS queue to the SNS topic and updating the SQS queue's
/// policy, where messages are not able to be delivered to the queue. After a
/// moment, the new queue policy will propagate and the queue will be able to
/// receive messages. This delay only occurs immediately after initially
/// subscribing the queue.
/// </para>
/// </summary>
/// <param name="topicArn">The topic to subscribe to</param>
/// <param name="sqsClient">The SQS client used to get attributes and set the policy on the SQS queue.</param>
/// <param name="sqsQueueUrl">The queue to add a subscription to.</param>
/// <returns>The subscription ARN as returned by Amazon SNS when the queue is
/// successfully subscribed to the topic.</returns>
public async Task<string> SubscribeQueueAsync(string topicArn, ICoreAmazonSQS sqsClient, string sqsQueueUrl)
{
var topics = await SubscribeQueueToTopicsAsync(new List<string>() { topicArn }, sqsClient, sqsQueueUrl).ConfigureAwait(false);
return topics.Values.First();
}
/// <summary>
/// Subscribes an existing Amazon SQS queue to existing Amazon SNS topics asynchronously.
/// <para>
/// The policy applied to the SQS queue is similar to this:
/// <code>
/// {
/// "Version" : "2008-10-17",
/// "Statement" : [{
/// "Sid" : "topic-subscription-arn:aws:sns:us-west-2:599109622955:myTopic",
/// "Effect" : "Allow",
/// "Principal" : "*",
/// "Action" : ["sqs:SendMessage"],
/// "Resource":["arn:aws:sqs:us-west-2:599109622955:myQueue"],
/// "Condition" : {
/// "ArnLike":{
/// "aws:SourceArn":["arn:aws:sns:us-west-2:599109622955:myTopic"]
/// }
/// }
/// }]
/// }
/// </code>
/// </para>
/// <para>
/// There might be a small time period immediately after
/// subscribing the SQS queue to the SNS topic and updating the SQS queue's
/// policy, where messages are not able to be delivered to the queue. After a
/// moment, the new queue policy will propagate and the queue will be able to
/// receive messages. This delay only occurs immediately after initially
/// subscribing the queue.
/// </para>
/// </summary>
/// <param name="topicArns">The topics to subscribe to</param>
/// <param name="sqsClient">The SQS client used to get attributes and set the policy on the SQS queue.</param>
/// <param name="sqsQueueUrl">The queue to add a subscription to.</param>
/// <returns>The mapping of topic ARNs to subscription ARNs as returned by Amazon SNS when the queue is
/// successfully subscribed to each topic.</returns>
public async Task<IDictionary<string, string>> SubscribeQueueToTopicsAsync(IList<string> topicArns, ICoreAmazonSQS sqsClient, string sqsQueueUrl)
{
// Get the queue's existing policy and ARN
var queueAttributes = await sqsClient.GetAttributesAsync(sqsQueueUrl).ConfigureAwait(false);
string sqsQueueArn = queueAttributes["QueueArn"];
Policy policy;
string policyStr = null;
if(queueAttributes.ContainsKey("Policy"))
policyStr = queueAttributes["Policy"];
if (string.IsNullOrEmpty(policyStr))
policy = new Policy();
else
policy = Policy.FromJson(policyStr);
var subscriptionArns = new Dictionary<string,string>();
foreach (var topicArn in topicArns)
{
if (!HasSQSPermission(policy, topicArn, sqsQueueArn))
AddSQSPermission(policy, topicArn, sqsQueueArn);
SubscribeResponse response = await this.SubscribeAsync(new SubscribeRequest
{
TopicArn = topicArn,
Protocol = "sqs",
Endpoint = sqsQueueArn,
}).ConfigureAwait(false);
subscriptionArns.Add(topicArn, response.SubscriptionArn);
}
var setAttributes = new Dictionary<string, string> { { "Policy", policy.ToJson() } };
await sqsClient.SetAttributesAsync(sqsQueueUrl, setAttributes).ConfigureAwait(false);
return subscriptionArns;
}
/// <summary>
/// Subscribes an existing Amazon SQS queue to an existing Amazon SNS topic.
/// <para>
/// The policy applied to the SQS queue is similar to this:
/// <code>
/// {
/// "Version" : "2008-10-17",
/// "Statement" : [{
/// "Sid" : "topic-subscription-arn:aws:sns:us-west-2:599109622955:myTopic",
/// "Effect" : "Allow",
/// "Principal" : "*",
/// "Action" : ["sqs:SendMessage"],
/// "Resource":["arn:aws:sqs:us-west-2:599109622955:myQueue"],
/// "Condition" : {
/// "ArnLike":{
/// "aws:SourceArn":["arn:aws:sns:us-west-2:599109622955:myTopic"]
/// }
/// }
/// }]
/// }
/// </code>
/// </para>
/// <para>
/// There might be a small time period immediately after
/// subscribing the SQS queue to the SNS topic and updating the SQS queue's
/// policy, where messages are not able to be delivered to the queue. After a
/// moment, the new queue policy will propagate and the queue will be able to
/// receive messages. This delay only occurs immediately after initially
/// subscribing the queue.
/// </para>
/// </summary>
/// <param name="topicArn">The topic to subscribe to</param>
/// <param name="sqsClient">The SQS client used to get attributes and set the policy on the SQS queue.</param>
/// <param name="sqsQueueUrl">The queue to add a subscription to.</param>
/// <returns>The subscription ARN as returned by Amazon SNS when the queue is
/// successfully subscribed to the topic.</returns>
public string SubscribeQueue(string topicArn, ICoreAmazonSQS sqsClient, string sqsQueueUrl)
{
return SubscribeQueueToTopics(new List<string>() { topicArn }, sqsClient, sqsQueueUrl).Values.First();
}
public Task <IDictionary <string, string> > SubscribeQueueToTopicsAsync(IList <string> topicArns, ICoreAmazonSQS sqsClient, string sqsQueueUrl)
{
throw new System.NotImplementedException();
}
public Task <string> SubscribeQueueAsync(string topicArn, ICoreAmazonSQS sqsClient, string sqsQueueUrl)
{
throw new System.NotImplementedException();
}
public IDictionary <string, string> SubscribeQueueToTopics(IList <string> topicArns, ICoreAmazonSQS sqsClient, string sqsQueueUrl)
{
throw new NotImplementedException();
}
public string SubscribeQueue(string topicArn, ICoreAmazonSQS sqsClient, string sqsQueueUrl)
{
throw new NotImplementedException();
}
