internal ListSubscriptionsByTopicResponse ListSubscriptionsByTopic(ListSubscriptionsByTopicRequest request)
{
var marshaller = new ListSubscriptionsByTopicRequestMarshaller();
var unmarshaller = ListSubscriptionsByTopicResponseUnmarshaller.Instance;
return(Invoke <ListSubscriptionsByTopicRequest, ListSubscriptionsByTopicResponse>(request, marshaller, unmarshaller));
}
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems)
{
AmazonSimpleNotificationServiceConfig config = new AmazonSimpleNotificationServiceConfig();
config.RegionEndpoint = region;
ConfigureClient(config);
AmazonSimpleNotificationServiceClient client = new AmazonSimpleNotificationServiceClient(creds, config);
ListSubscriptionsByTopicResponse resp = new ListSubscriptionsByTopicResponse();
do
{
ListSubscriptionsByTopicRequest req = new ListSubscriptionsByTopicRequest
{
NextToken = resp.NextToken
};
resp = client.ListSubscriptionsByTopic(req);
CheckError(resp.HttpStatusCode, "200");
foreach (var obj in resp.Subscriptions)
{
AddObject(obj);
}
}while (!string.IsNullOrEmpty(resp.NextToken));
}
/// <summary>
/// Initiates the asynchronous execution of the ListSubscriptionsByTopic operation.
/// <seealso cref="Amazon.SimpleNotificationService.IAmazonSimpleNotificationService"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListSubscriptionsByTopic 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 <ListSubscriptionsByTopicResponse> ListSubscriptionsByTopicAsync(ListSubscriptionsByTopicRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new ListSubscriptionsByTopicRequestMarshaller();
var unmarshaller = ListSubscriptionsByTopicResponseUnmarshaller.Instance;
return(Invoke <IRequest, ListSubscriptionsByTopicRequest, ListSubscriptionsByTopicResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
static SmsController()
{
Client = new AmazonSimpleNotificationServiceClient(new BasicAWSCredentials("AKIAJOMZAEESGAYK6EKA", "L6qF0b2Rtgzk3lhLJrh976hqAlz+MWyy8g1ACQ2e"), RegionEndpoint.EUWest1);
var request = new ListSubscriptionsByTopicRequest(TopicArn);
var response = Client.ListSubscriptionsByTopic(request);
NumberToArn = response.Subscriptions.ToDictionary(x => x.Endpoint, x => x.SubscriptionArn);
}
public static IEnumerable <Subscription> ListSubscriptions(string topicArn)
{
using (var client = new AmazonSimpleNotificationServiceClient(Settings.AccessKey, Settings.Secret))
{
var request = new ListSubscriptionsByTopicRequest(topicArn);
return(client.ListSubscriptionsByTopic(request).Subscriptions);
}
}
public static async Task <List <Subscription> > GetSubscriptionsListAsync(IAmazonSimpleNotificationService client)
{
var request = new ListSubscriptionsByTopicRequest
{
TopicArn = TopicArn,
};
var response = await client.ListSubscriptionsByTopicAsync(request);
return(response.Subscriptions);
}
/// <summary>
/// Method created to connect and process the Topic/Subscription in the AWS.
/// </summary>
/// <returns></returns>
public void ProcessSubscription()
{
try
{
foreach (var topic in _topics)
{
SqsSnsConfiguration config = GetConnection(topic);
MethodInfo method = GetMethod(topic);
string topicName = topic.Value.TopicName;
string subscriptName = topic.Value.Subscription;
//Register Trace on the telemetry
WorkBench.Telemetry.TrackTrace($"Topic {topicName} registered");
AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(config.AwsAccessKeyId, config.AwsSecretAccessKey);
var topicRequest = new CreateTopicRequest
{
Name = topicName
};
var topicResponse = snsClient.CreateTopicAsync(topicRequest).Result;
var subsRequest = new ListSubscriptionsByTopicRequest
{
TopicArn = topicResponse.TopicArn
};
var subs = snsClient.ListSubscriptionsByTopicAsync(subsRequest).Result.Subscriptions;
foreach (Subscription subscription in subs)
{
try
{
WorkBench.Telemetry.TrackEvent("Method invoked");
//Use of the Metrics to monitoring the queue's processes, start the metric
WorkBench.Telemetry.BeginMetricComputation("MessageProcessed");
//Processing the method defined with queue
InvokeProcess(method, Encoding.UTF8.GetBytes(subscription.SubscriptionArn));
WorkBench.Telemetry.ComputeMetric("MessageProcessed", 1);
//Finish the monitoring the queue's processes
WorkBench.Telemetry.EndMetricComputation("MessageProcessed");
WorkBench.Telemetry.TrackEvent("Method terminated");
WorkBench.Telemetry.TrackEvent("Queue's message completed");
}
catch (Exception exRegister)
{
//Use the class instead of interface because tracking exceptions directly is not supposed to be done outside AMAW (i.e. by the business code)
((LightTelemetry)WorkBench.Telemetry).TrackException(exRegister);
}
}
}
}
catch (Exception exception)
{
//Use the class instead of interface because tracking exceptions directly is not supposed to be done outside AMAW (i.e. by the business code)
((LightTelemetry)WorkBench.Telemetry).TrackException(exception);
}
}
public static async Task <IEnumerable <Subscription> > ListSubscriptions(string topicArn)
{
using (var client = new AmazonSimpleNotificationServiceClient(ConfigManager.ConfigSettings.AccessKey, ConfigManager.ConfigSettings.Secret, Amazon.RegionEndpoint.USWest2))
{
var request = new ListSubscriptionsByTopicRequest(topicArn);
var response = await client.ListSubscriptionsByTopicAsync(request);
return(response.Subscriptions);
}
}
internal ListSubscriptionsByTopicResponse ListSubscriptionsByTopic(ListSubscriptionsByTopicRequest request)
{
var task = ListSubscriptionsByTopicAsync(request);
try
{
return(task.Result);
}
catch (AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return(null);
}
}
/**
* Convert ListSubscriptionsByTopicRequest to name value pairs
*/
private static IDictionary<string, string> ConvertListSubscriptionsByTopic(ListSubscriptionsByTopicRequest request)
{
IDictionary<string, string> parameters = new Dictionary<string, string>();
parameters["Action"] = "ListSubscriptionsByTopic";
if (request.IsSetTopicArn())
{
parameters["TopicArn"] = request.TopicArn;
}
if (request.IsSetNextToken())
{
parameters["NextToken"] = request.NextToken;
}
return parameters;
}
private static IDictionary <string, string> ConvertListSubscriptionsByTopic(ListSubscriptionsByTopicRequest request)
{
IDictionary <string, string> dictionary = new Dictionary <string, string>();
dictionary["Action"] = "ListSubscriptionsByTopic";
if (request.IsSetTopicArn())
{
dictionary["TopicArn"] = request.TopicArn;
}
if (request.IsSetNextToken())
{
dictionary["NextToken"] = request.NextToken;
}
return(dictionary);
}
public void ListSubscriptions()
{
ListSubscriptionsByTopicRequest request = new ListSubscriptionsByTopicRequest {
TopicArn = TopicARN
};
var response = client.ListSubscriptionsByTopic(request);
if (response.HttpStatusCode.IsSuccess())
{
foreach (var subscription in response.Subscriptions)
{
Console.WriteLine(subscription.Owner);
Console.WriteLine(subscription.Protocol);
Console.WriteLine(subscription.SubscriptionArn);
Console.WriteLine(subscription.Endpoint);
}
}
}
private bool SubscriptionExists()
{
var exists = false;
var request = new ListSubscriptionsByTopicRequest
{
TopicArn = TopicArn
};
var response = _snsClient.ListSubscriptionsByTopic(request);
var matchString = string.Format(":{0}", SubscriptionName);
var matches = response.Subscriptions.Where(x => x.Endpoint.EndsWith(matchString));
if (matches.Count() == 1)
{
exists = true;
_subscriptionArn = matches.ElementAt(0).SubscriptionArn;
}
return(exists);
}
public Task <IReadOnlyList <Subscription> > ListSubscriptionsByTopicAsync(string topicName)
{
if (string.IsNullOrWhiteSpace(topicName))
{
throw new ArgumentException($"A non-null/empty '{topicName}' is required.", nameof(topicName));
}
return(listSubscriptionsAsync());
async Task <IReadOnlyList <Subscription> > listSubscriptionsAsync()
{
var topic = await _sns.FindTopicAsync(topicName);
if (topic == null)
{
throw new ArgumentException($"The topic '{topicName}' does not exist.");
}
var request = new ListSubscriptionsByTopicRequest
{
TopicArn = topic.TopicArn
};
var subscriptions = new List <Subscription>();
ListSubscriptionsByTopicResponse response;
do
{
response = await _sns.ListSubscriptionsByTopicAsync(request);
if (response.HttpStatusCode != HttpStatusCode.OK)
{
throw new InvalidOperationException($"Unable to list subscriptions for topic '{topicName}'");
}
subscriptions.AddRange(response.Subscriptions);
request.NextToken = response.NextToken;
} while (response.NextToken != null);
return(subscriptions);
}
}
public void ListSubscriptions()
{
ListSubscriptionsByTopicRequest request = new ListSubscriptionsByTopicRequest {
TopicArn = topicARN
};
var response = client.ListSubscriptionsByTopic(request);
if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
foreach (var sub in response.Subscriptions)
{
Console.WriteLine(sub.Owner);
Console.WriteLine(sub.Protocol);
Console.WriteLine(sub.SubscriptionArn);
Console.WriteLine(sub.Endpoint);
}
}
Console.ReadLine();
}
//public bool CheckIfTopicExists(string topicName)
//{
// var listTopicsRequest = new ListTopicsRequest();
// ListTopicsResponse listTopicsResponse;
// do
// {
// listTopicsResponse = sns.ListTopics(listTopicsRequest);
// foreach (var topic in listTopicsResponse.Topics)
// {
// Console.WriteLine(" Topic: {0}", topic.TopicArn);
// // Get topic attributes
// var topicAttributes = sns.GetTopicAttributes(new GetTopicAttributesRequest
// {
// TopicArn = topic.TopicArn
// }).Attributes;
// if (topicAttributes.Count > 0)
// {
// Console.WriteLine(" Topic attributes");
// foreach (var topicAttribute in topicAttributes)
// {
// Console.WriteLine(" -{0} : {1}", topicAttribute.Key, topicAttribute.Value);
// }
// }
// Console.WriteLine();
// }
// listTopicsRequest.NextToken = listTopicsResponse.NextToken;
// } while (listTopicsResponse.NextToken != null);
//}
public bool CheckIfSubscriptionExistsForTopic(string topicArn, string protocol, string endpoint)
{
var listSubscriptionsByTopicRequest = new ListSubscriptionsByTopicRequest(topicArn);
ListSubscriptionsByTopicResponse response;
do
{
response = sns.ListSubscriptionsByTopic(listSubscriptionsByTopicRequest);
foreach (var subscription in response.Subscriptions)
{
if (string.Equals(subscription.Endpoint, endpoint, StringComparison.OrdinalIgnoreCase) &&
string.Equals(subscription.Protocol, protocol, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
}
listSubscriptionsByTopicRequest.NextToken = response.NextToken;
}while (response.NextToken != null);
return(false);
}
public virtual void DeleteSubscriptions(AmazonSimpleNotificationServiceClient snsClient, string topicArn)
{
var listSubscriptionsByTopicRequest = new ListSubscriptionsByTopicRequest
{
TopicArn = topicArn
};
ListSubscriptionsByTopicResponse listSubscriptionsByTopicResponse =
snsClient.ListSubscriptionsByTopic(listSubscriptionsByTopicRequest);
foreach (
Subscription subscription in
listSubscriptionsByTopicResponse.Subscriptions)
{
var unsubscribeRequest = new UnsubscribeRequest
{
SubscriptionArn = subscription.SubscriptionArn
};
snsClient.Unsubscribe(unsubscribeRequest);
}
}
public void ListSubscriptionsByTopicRequest()
{
ListSubscriptionsByTopicRequest request = new ListSubscriptionsByTopicRequest
{
TopicArn = "arn:aws:sns:us-west-1:491483104165:TopicApp",
};
var response = client.ListSubscriptionsByTopic(request);
if (response.HttpStatusCode.IsSuccess())
{
foreach (var item in response.Subscriptions)
{
Console.WriteLine($"\n\n---------- Subscription ----------\n");
Console.WriteLine($"{item.Owner}");
Console.WriteLine($"{item.Protocol}");
Console.WriteLine($"{item.SubscriptionArn}");
Console.WriteLine($"{item.Endpoint}");
}
}
}
public static void SNSListSubscriptionsByTopic()
{
#region SNSListSubscriptionsByTopic
var snsClient = new AmazonSimpleNotificationServiceClient();
var request = new ListSubscriptionsByTopicRequest();
var response = new ListSubscriptionsByTopicResponse();
request.TopicArn = "arn:aws:sns:us-east-1:80398EXAMPLE:CodingTestResults";
do
{
response = snsClient.ListSubscriptionsByTopic(request);
foreach (var sub in response.Subscriptions)
{
Console.WriteLine("Subscription: {0}", sub.SubscriptionArn);
var subAttrs = snsClient.GetSubscriptionAttributes(
new GetSubscriptionAttributesRequest
{
SubscriptionArn = sub.SubscriptionArn
}).Attributes;
if (subAttrs.Count > 0)
{
foreach (var subAttr in subAttrs)
{
Console.WriteLine(" -{0} : {1}", subAttr.Key, subAttr.Value);
}
}
Console.WriteLine();
}
request.NextToken = response.NextToken;
} while (!string.IsNullOrEmpty(response.NextToken));
#endregion
Console.ReadLine();
}
public static async Task <string> GetSubArn(IAmazonSimpleNotificationService client, string email)
{
var request = new ListSubscriptionsByTopicRequest();
request.TopicArn = TopicArn;
var subArn = string.Empty;
var response = await client.ListSubscriptionsByTopicAsync(request);
List <Subscription> allSubs = response.Subscriptions;
// Get the ARN Value for this subscription.
foreach (Subscription sub in allSubs)
{
if (sub.Endpoint.Equals(email))
{
subArn = sub.SubscriptionArn;
return(subArn);
}
}
return(string.Empty);
}
/// <summary>
/// 分页获取特定主题的订阅列表
/// </summary>
public void ListSubscriptionsByTopic()
{
// 设置请求对象
ListSubscriptionsByTopicRequest request = new ListSubscriptionsByTopicRequest
{
Limit = 5,
Offset = 0,
TopicUrn = "urn:smn:cn-north-1:cffe4fc4c9a54219b60dbaf7b586e132:SmnApi"
};
try
{
// 发送请求并返回响应
ListSubscriptionsByTopicResponse response = smnClient.SendRequest(request);
int result = response.SubscriptionCount;
Console.WriteLine("{0}", result);
Console.ReadLine();
}
catch (Exception e)
{
// 处理异常
Console.WriteLine("{0}", e.Message);
}
}
public void ReloadExistingSubscriptions()
{
var subscriptions = new List <SubscriptionInfo>();
using (var client = new AmazonSimpleNotificationServiceClient(this.AwsCredentials, this.AwsRegion)) {
var request = new ListTopicsRequest();
ListTopicsResponse response;
Task <ListTopicsResponse> ltt;
do
{
ltt = client.ListTopicsAsync(request);
ltt.Wait();
response = ltt.Result;
foreach (var topic in response.Topics)
{
var lsRequest = new ListSubscriptionsByTopicRequest()
{
TopicArn = topic.TopicArn
};
ListSubscriptionsByTopicResponse lsResponse;
Task <ListSubscriptionsByTopicResponse> lst;
do
{
lst = client.ListSubscriptionsByTopicAsync(lsRequest);
lst.Wait();
lsResponse = lst.Result;
//íterate all subscriptions which are bound to our SubscriptionCallbackUrl...
foreach (var subscription in lsResponse.Subscriptions.Where(s => string.Equals(s.Endpoint, this.SubscriptionCallbackUrl, StringComparison.InvariantCultureIgnoreCase)))
{
//skip pending subscriptions...
if (!subscription.SubscriptionArn.Equals(AwsMagicArnForPendingSubscription))
{
subscriptions.Add(new SubscriptionInfo(this, subscription.TopicArn, subscription.SubscriptionArn, false));
}
}
lsRequest.NextToken = lsResponse.NextToken;
} while (!string.IsNullOrEmpty(lsResponse.NextToken));
}
request.NextToken = response.NextToken;
} while (!string.IsNullOrEmpty(response.NextToken));
lock (_ConfirmedSubscriptions) {
_ConfirmedSubscriptions = subscriptions;
}
lock (_LocalPendingSubscriptions) {
foreach (var lps in _LocalPendingSubscriptions.ToArray())
{
if (subscriptions.Where(s => (s.TopicArn ?? "") == (lps.TopicArn ?? "")).Any())
{
_LocalPendingSubscriptions.Remove(lps);
}
}
}
}
}
/// <summary>
/// List Subscriptions By Topic
/// </summary>
/// <param name="request">List Subscriptions By Topic request</param>
/// <returns>List Subscriptions By Topic Response from the service</returns>
/// <remarks>
/// The ListSubscriptionsByTopic action returns a list of the subscriptions to a specific topic. Each call returns
/// a limited list of subscriptions. If there are more subscriptions, a NextToken is also returned. Use the NextToken
/// parameter in a new ListSubscriptionsByTopic call to get further results.
/// </remarks>
public ListSubscriptionsByTopicResponse ListSubscriptionsByTopic(ListSubscriptionsByTopicRequest request)
{
return(Invoke <ListSubscriptionsByTopicResponse>(ConvertListSubscriptionsByTopic(request)));
}
public void SubscribeTopic()
{
const string emailAddress = "*****@*****.**";
var subscriptionWaitDelay = TimeSpan.FromMinutes(2);
// create new topic
var name = "dotnetsdk" + DateTime.Now.Ticks;
var createTopicRequest = new CreateTopicRequest
{
Name = name
};
var createTopicResult = Client.CreateTopic(createTopicRequest);
var topicArn = createTopicResult.TopicArn;
try
{
// subscribe an email address to the topic
var subscribeRequest = new SubscribeRequest
{
Protocol = "email",
Endpoint = emailAddress,
TopicArn = topicArn
};
Client.Subscribe(subscribeRequest);
// wait until subscription has been confirmed, maximum wait time of two minutes
// by default
string subArn = null;
var latest = DateTime.Now + subscriptionWaitDelay;
while (DateTime.Now < latest)
{
// get subscriptions for topic
var listSubscriptionsRequest = new ListSubscriptionsByTopicRequest
{
TopicArn = topicArn
};
var subs = Client.ListSubscriptionsByTopic(listSubscriptionsRequest).Subscriptions;
Assert.AreEqual(1, subs.Count);
// test whether the subscription has been confirmed
var subscription = subs[0];
if (!string.Equals(subscription.SubscriptionArn, "PendingConfirmation", StringComparison.Ordinal))
{
subArn = subscription.SubscriptionArn;
break;
}
// wait
Thread.Sleep(TimeSpan.FromSeconds(15));
}
// verify that the subscription was confirmed and the arn has been set
Assert.IsNotNull(subArn);
// publish a message to the topic
Client.Publish(new PublishRequest
{
TopicArn = topicArn,
Subject = "Test subject",
Message = "Test message"
});
// delete the subscription
Client.Unsubscribe(new UnsubscribeRequest
{
SubscriptionArn = subArn
});
}
finally
{
// delete the topic
var deleteTopicRequest = new DeleteTopicRequest
{
TopicArn = topicArn
};
Client.DeleteTopic(deleteTopicRequest);
}
}
public ListSubscriptionsByTopicResponse ListSubscriptionsByTopic(ListSubscriptionsByTopicRequest request)
{
throw new System.NotImplementedException();
}
public Task <ListSubscriptionsByTopicResponse> ListSubscriptionsByTopicAsync(ListSubscriptionsByTopicRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
throw new System.NotImplementedException();
}
public static void SNSCreateSubscribePublish()
{
#region SNSCreateSubscribePublish
var snsClient = new AmazonSimpleNotificationServiceClient();
var topicRequest = new CreateTopicRequest
{
Name = "CodingTestResults"
};
var topicResponse = snsClient.CreateTopic(topicRequest);
var topicAttrRequest = new SetTopicAttributesRequest
{
TopicArn = topicResponse.TopicArn,
AttributeName = "DisplayName",
AttributeValue = "Coding Test Results"
};
snsClient.SetTopicAttributes(topicAttrRequest);
snsClient.Subscribe(new SubscribeRequest
{
Endpoint = "*****@*****.**",
Protocol = "email",
TopicArn = topicResponse.TopicArn
});
// Wait for up to 2 minutes for the user to confirm the subscription.
DateTime latest = DateTime.Now + TimeSpan.FromMinutes(2);
while (DateTime.Now < latest)
{
var subsRequest = new ListSubscriptionsByTopicRequest
{
TopicArn = topicResponse.TopicArn
};
var subs = snsClient.ListSubscriptionsByTopic(subsRequest).Subscriptions;
var sub = subs[0];
if (!string.Equals(sub.SubscriptionArn,
"PendingConfirmation", StringComparison.Ordinal))
{
break;
}
// Wait 15 seconds before trying again.
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(15));
}
snsClient.Publish(new PublishRequest
{
Subject = "Coding Test Results for " +
DateTime.Today.ToShortDateString(),
Message = "All of today's coding tests passed.",
TopicArn = topicResponse.TopicArn
});
#endregion
}
public string Remove(Notification input, ILambdaContext context)
{
var region = RegionEndpoint.APSoutheast1;
var topicId = input.TopicId;
//Get item from DynamoDB
var key = new Dictionary <string, AttributeValue>();
key.Add("id", new AttributeValue()
{
S = topicId
});
var dynamoDBClient = new AmazonDynamoDBClient(region);
var getItemResponse = dynamoDBClient.GetItemAsync("Topics", key).Result;
if (getItemResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new TestDonkeyException("Can't find item");
}
var item = getItemResponse.Item;
var topicArn = item.GetValueOrDefault("arn").S;
//Remove permission to accept CloudWatch Events trigger for Lambda
var lambdaClient = new AmazonLambdaClient(region);
var removePermissionRequest = new Amazon.Lambda.Model.RemovePermissionRequest();
removePermissionRequest.FunctionName = "TestDonkeyLambda";
removePermissionRequest.StatementId = $"testdonkey-lambda-{ topicId }";
var removePermissionResponse = lambdaClient.RemovePermissionAsync(removePermissionRequest).Result;
if (removePermissionResponse.HttpStatusCode != HttpStatusCode.NoContent)
{
throw new TestDonkeyException("Can't remove permission");
}
//Remove target for CloudWatch Events
var cloudWatchEventClient = new AmazonCloudWatchEventsClient(region);
var removeTargetsRequest = new RemoveTargetsRequest();
removeTargetsRequest.Ids = new List <string> {
$"testdonkey-target-{ topicId }"
};
removeTargetsRequest.Rule = $"testdonkey-rule-{ topicId }";
var removeTargetsResponse = cloudWatchEventClient.RemoveTargetsAsync(removeTargetsRequest).Result;
if (removeTargetsResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new TestDonkeyException("Can't remove target");
}
//Delete rule in CloudWatch Events
var deleteRuleRequest = new DeleteRuleRequest();
deleteRuleRequest.Name = removeTargetsRequest.Rule;
var deleteRuleResponse = cloudWatchEventClient.DeleteRuleAsync(deleteRuleRequest).Result;
if (deleteRuleResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new TestDonkeyException("Can't delete rule");
}
//Remove subscribers from SNS
var snsClient = new AmazonSimpleNotificationServiceClient(region);
var listSubscriptionsByTopicRequest = new ListSubscriptionsByTopicRequest();
listSubscriptionsByTopicRequest.TopicArn = topicArn;
ListSubscriptionsByTopicResponse listSubscriptionsByTopicResponse = null;
do
{
listSubscriptionsByTopicResponse = snsClient.ListSubscriptionsByTopicAsync(listSubscriptionsByTopicRequest).Result;
if (listSubscriptionsByTopicResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new TestDonkeyException("Can't list subscriptions");
}
if (listSubscriptionsByTopicResponse.Subscriptions != null && listSubscriptionsByTopicResponse.Subscriptions.Count > 0)
{
foreach (var subscription in listSubscriptionsByTopicResponse.Subscriptions)
{
if (!subscription.SubscriptionArn.Equals("pendingconfirmation", StringComparison.OrdinalIgnoreCase))
{
snsClient.UnsubscribeAsync(subscription.SubscriptionArn).GetAwaiter().GetResult();
}
}
}
listSubscriptionsByTopicRequest.NextToken = listSubscriptionsByTopicResponse.NextToken;
Thread.Sleep(1_000); //Wait for 1 second. Throttle: 100 transactions per second (TPS)
} while (!string.IsNullOrWhiteSpace(listSubscriptionsByTopicResponse.NextToken));
//Delete topic from SNS
var deleteTopicResponse = snsClient.DeleteTopicAsync(topicArn).Result;
if (deleteTopicResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new TestDonkeyException("Can't delete topic");
}
//Delete item from DynamoDB
var dynamoDBDeleteItemResponse = dynamoDBClient.DeleteItemAsync("Topics", key).Result;
if (dynamoDBDeleteItemResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new TestDonkeyException("Can't delete item");
}
return("success");
}
public async Task SubscribeTopic()
{
const string emailAddress = "*****@*****.**";
var subscriptionWaitDelay = TimeSpan.FromMinutes(2);
// create new topic
var name = UtilityMethods.GenerateName("SubscribeTopic");
var createTopicRequest = new CreateTopicRequest
{
Name = name
};
var createTopicResult = await Client.CreateTopicAsync(createTopicRequest);
var topicArn = createTopicResult.TopicArn;
_topicArns.Add(topicArn);
// subscribe an email address to the topic
var subscribeRequest = new SubscribeRequest
{
Protocol = "email",
Endpoint = emailAddress,
TopicArn = topicArn
};
await Client.SubscribeAsync(subscribeRequest);
// wait until subscription has been confirmed, maximum wait time of two minutes
// by default
string subArn = null;
var latest = DateTime.Now + subscriptionWaitDelay;
while (DateTime.Now < latest)
{
// get subscriptions for topic
var listSubscriptionsRequest = new ListSubscriptionsByTopicRequest
{
TopicArn = topicArn
};
var subs = (await Client.ListSubscriptionsByTopicAsync(listSubscriptionsRequest)).Subscriptions;
Assert.Equal(1, subs.Count);
// test whether the subscription has been confirmed
var subscription = subs[0];
if (!string.Equals(subscription.SubscriptionArn, "PendingConfirmation", StringComparison.Ordinal))
{
subArn = subscription.SubscriptionArn;
break;
}
// wait
UtilityMethods.Sleep(TimeSpan.FromSeconds(15));
}
// verify that the subscription was confirmed and the arn has been set
Assert.NotNull(subArn);
// publish a message to the topic
await Client.PublishAsync(new PublishRequest
{
TopicArn = topicArn,
Subject = "Test subject",
Message = "Test message"
});
// delete the subscription
await Client.UnsubscribeAsync(new UnsubscribeRequest
{
SubscriptionArn = subArn
});
}
public async Task <IActionResult> SNS()
{
var results = new List <string>();
var topicRequest = new CreateTopicRequest {
Name = "borislav-topic-1"
};
var topicResponse = await _snsClient.CreateTopicAsync(topicRequest);
results.Add($"Topic '{topicRequest.Name}' created with status {topicResponse.HttpStatusCode}");
var topicAttrRequest = new SetTopicAttributesRequest
{
TopicArn = topicResponse.TopicArn,
AttributeName = "DisplayName",
AttributeValue = "Coding Test Results"
};
await _snsClient.SetTopicAttributesAsync(topicAttrRequest);
var subscribeRequest = new SubscribeRequest
{
Endpoint = "*****@*****.**",
Protocol = "email",
TopicArn = topicResponse.TopicArn
};
SubscribeResponse subscribeResponse = await _snsClient.SubscribeAsync(subscribeRequest);
results.Add($"Invitation sent by email with status {subscribeResponse.HttpStatusCode}");
results.Add("Wait for up to 2 min for the user to confirm the subscription");
// Wait for up to 2 minutes for the user to confirm the subscription.
DateTime latest = DateTime.Now + TimeSpan.FromMinutes(2);
while (DateTime.Now < latest)
{
var subsRequest = new ListSubscriptionsByTopicRequest
{
TopicArn = topicResponse.TopicArn
};
var subs = _snsClient.ListSubscriptionsByTopicAsync(subsRequest).Result.Subscriptions;
if (!string.Equals(subs[0].SubscriptionArn, "PendingConfirmation", StringComparison.Ordinal))
{
break;
}
// Wait 15 seconds before trying again.
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(15));
}
var publishRequest = new PublishRequest
{
Subject = "Coding Test Results for " + DateTime.Today.ToShortDateString(),
Message = "All of today's coding tests passed",
TopicArn = topicResponse.TopicArn
};
PublishResponse publishResponse = await _snsClient.PublishAsync(publishRequest);
results.Add($"Message '{publishRequest.Message}' published with status {topicResponse.HttpStatusCode}");
ViewBag.Results = new List <string>();
ViewBag.Results.AddRange(results);
return(View());
}
