public void UnmonitorEmail(string emailaddr)
{
if (monitors.ContainsKey(emailaddr))
{
var monitor = monitors[emailaddr];
try
{
var unsubresponse = snsclient.UnsubscribeAsync(new UnsubscribeRequest
{
SubscriptionArn = monitor.subscription_arn
});
var unsubresult = unsubresponse.Result;
}
catch (AmazonSimpleNotificationServiceException e)
{
Console.WriteLine("Unable to unsubscripe topic for {0}: {1}", emailaddr, e.Message);
}
try
{
var sqsresponse = sqsclient.DeleteQueueAsync(new DeleteQueueRequest
{
QueueUrl = monitor.sqsqueue_url
});
DeleteQueueResponse sqsresult = sqsresponse.Result;
}
catch (AmazonSQSException e)
{
Console.WriteLine("Unable to delete queue for {0}: {1}", emailaddr, e.Message);
}
}
}
public static async Task UnsubscribeQueue(string subscriptionArn)
{
using var sqs = new AmazonSQSClient(Credentials);
using var sns = new AmazonSimpleNotificationServiceClient(Credentials);
await sns.UnsubscribeAsync(subscriptionArn);
}
public async Task <IActionResult> Unsubscribe(string arn)
{
var clientSNS = new AmazonSimpleNotificationServiceClient(_awsAccessKeySNS, _awsSecretKeySNS, Amazon.RegionEndpoint.USEast1);
var unsubscribeResponse = await clientSNS.UnsubscribeAsync(new UnsubscribeRequest(arn));
if (unsubscribeResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
throw new Exception("Topic unsubscription falied");
}
return(Ok());
}
public async System.Threading.Tasks.Task <UnsubscribeResponse> Unsubcribe(string subscriptionArn)
{
UnsubscribeResponse unsubscribeResponse = new UnsubscribeResponse();
using (AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(credentials, Amazon.RegionEndpoint.USEast2))
{
UnsubscribeRequest unsubscribeRequest = new UnsubscribeRequest(subscriptionArn);
unsubscribeResponse = await snsClient.UnsubscribeAsync(unsubscribeRequest);
}
return(unsubscribeResponse);
}
private static async Task Cleanup(AmazonSQSClient sqsClient, AmazonSimpleNotificationServiceClient snsClient, List <Task <string> > subscribeTask, string topic1Arn, string topic2Arn, string queueUrl)
{
foreach (var task in subscribeTask)
{
await snsClient.UnsubscribeAsync(task.Result);
}
await snsClient.DeleteTopicAsync(topic1Arn);
await snsClient.DeleteTopicAsync(topic2Arn);
await sqsClient.DeleteQueueAsync(queueUrl);
}
public async System.Threading.Tasks.Task UnsubscribeAsync()
{
AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(RegionEndpoint.APSoutheast1);
string topicArn = "";
// Delete an Amazon SNS topic.
UnsubscribeRequest unsubscribeRequest = new UnsubscribeRequest(topicArn);
UnsubscribeResponse unsubscribeResponse = await snsClient.UnsubscribeAsync(unsubscribeRequest);
// Print the request ID for the DeleteTopicRequest action.
Console.WriteLine("UnsubscribeRequest: " + unsubscribeResponse.ResponseMetadata.RequestId);
}
static async Task <Func <Task> > Subscribe(AmazonSimpleNotificationServiceClient snsClient,
string functionArn,
string topicArn,
CancellationToken cancellationToken)
{
var subscription = await snsClient.SubscribeAsync(new SubscribeRequest
{
Endpoint = functionArn,
Protocol = "lambda",
TopicArn = topicArn
}, cancellationToken);
return(async() => await snsClient.UnsubscribeAsync(subscription.SubscriptionArn));
}
private void UnsubscribeFromTopic(AmazonSimpleNotificationServiceClient snsClient)
{
ListSubscriptionsByTopicResponse response;
do
{
response = snsClient.ListSubscriptionsByTopicAsync(new ListSubscriptionsByTopicRequest {
TopicArn = _channelTopicArn
}).GetAwaiter().GetResult();
foreach (var sub in response.Subscriptions)
{
var unsubscribe = snsClient.UnsubscribeAsync(new UnsubscribeRequest {
SubscriptionArn = sub.SubscriptionArn
}).GetAwaiter().GetResult();
if (unsubscribe.HttpStatusCode != HttpStatusCode.OK)
{
s_logger.LogError("Error unsubscribing from {TopicResourceName} for sub {ChannelResourceName}", _channelTopicArn, sub.SubscriptionArn);
}
}
} while (response.NextToken != null);
}
public void DeleteTopic()
{
if (_connection == null)
{
return;
}
using (var snsClient = new AmazonSimpleNotificationServiceClient(_awsConnection.Credentials, _awsConnection.Region))
{
//TODO: could be a seperate method
var exists = snsClient.ListTopicsAsync().Result.Topics.SingleOrDefault(topic => topic.TopicArn == _channelTopicARN);
if (exists != null)
{
try
{
var response = snsClient.ListSubscriptionsByTopicAsync(new ListSubscriptionsByTopicRequest {
TopicArn = _channelTopicARN
}).Result;
foreach (var sub in response.Subscriptions)
{
var unsubscribe = snsClient.UnsubscribeAsync(new UnsubscribeRequest {
SubscriptionArn = sub.SubscriptionArn
}).Result;
if (unsubscribe.HttpStatusCode != HttpStatusCode.OK)
{
_logger.Value.Error($"Error unsubscribing from {_channelTopicARN} for sub {sub.SubscriptionArn}");
}
}
snsClient.DeleteTopicAsync(_channelTopicARN).Wait();
}
catch (Exception)
{
//don't break on an exception here, if we can't delete, just exit
_logger.Value.Error($"Could not delete topic {_channelTopicARN}");
}
}
}
}
public void DeleteAllTopics()
{
AmazonSimpleNotificationServiceClient clientSNS = AwsFactory.CreateClient <AmazonSimpleNotificationServiceClient>();
AmazonSQSClient clientSQS = AwsFactory.CreateClient <AmazonSQSClient>();
AmazonLambdaClient lambdaClient = AwsFactory.CreateClient <AmazonLambdaClient>();
var topics = clientSNS.ListTopicsAsync();
// var subs = clientSNS.ListSubscriptionsAsync(new ListSubscriptionsRequest());
var filas = clientSQS.ListQueuesAsync("subs");
filas.Result.QueueUrls.ForEach(i =>
{
var deleted = clientSQS.DeleteQueueAsync(i);
if (deleted.Result.HttpStatusCode != HttpStatusCode.OK)
{
int x = 0;
}
});
string nextToken = "";
do
{
var subs = clientSNS.ListSubscriptionsAsync(new ListSubscriptionsRequest(nextToken));
subs.Result.Subscriptions.ForEach(i =>
{
var deleted = clientSNS.UnsubscribeAsync(i.SubscriptionArn);
});
nextToken = subs.Result.NextToken;
} while (!String.IsNullOrEmpty(nextToken));
var mapper = lambdaClient.ListEventSourceMappingsAsync(new Amazon.Lambda.Model.ListEventSourceMappingsRequest
{
FunctionName = "WebhookDispatcher"
});
mapper.Result.EventSourceMappings.ToList().ForEach(i =>
{
var result = lambdaClient.DeleteEventSourceMappingAsync(new Amazon.Lambda.Model.DeleteEventSourceMappingRequest()
{
UUID = i.UUID
});
if (result.Result.HttpStatusCode != HttpStatusCode.OK)
{
int x = 0;
}
});
topics.Result.Topics.ForEach(i =>
{
var deleted = clientSNS.DeleteTopicAsync(new DeleteTopicRequest()
{
TopicArn = i.TopicArn
});
});
}
public async Task RegisterUserNotifications()
{
string deviceToken = GetDeviceToken();
var notificationsSubscriptions = GetNotificationsSubscriptions();
if (string.IsNullOrEmpty(deviceToken))
{
return;
}
var credentials = new BasicAWSCredentials(
AppSettings.Instance.AwsKey,
AppSettings.Instance.AwsSecret
);
var client = new AmazonSimpleNotificationServiceClient(
credentials,
Amazon.RegionEndpoint.EUWest1
);
if (string.IsNullOrEmpty(notificationsSubscriptions.ApplicationEndPoint) ||
notificationsSubscriptions.DeviceToken != deviceToken)
{
// **********************************************
// de-register old endpoint and all subscriptions
if (!string.IsNullOrEmpty(notificationsSubscriptions.ApplicationEndPoint))
{
try
{
var response = await client.DeleteEndpointAsync(new DeleteEndpointRequest { EndpointArn = notificationsSubscriptions.ApplicationEndPoint });
if (response.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
ShowAlert("Debug", $"Error eliminando endpoint: {response.HttpStatusCode}");
}
}
catch { /*Silent error in case endpoint doesn´t exist */ }
notificationsSubscriptions.ApplicationEndPoint = null;
foreach (var sub in notificationsSubscriptions.Subscriptions)
{
try
{
await client.UnsubscribeAsync(sub.Value);
}
catch { /*Silent error in case endpoint doesn´t exist */ }
}
notificationsSubscriptions.Subscriptions.Clear();
}
// register with SNS to create a new endpoint
var endPointResponse = await client.CreatePlatformEndpointAsync(
new CreatePlatformEndpointRequest
{
Token = deviceToken,
PlatformApplicationArn = Device.RuntimePlatform == Device.iOS ?
AppSettings.Instance.AwsPlatformApplicationArnIOS :
AppSettings.Instance.AwsPlatformApplicationArnAndroid
}
);
if (endPointResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
ShowAlert("Debug", $"Error registrando endpoint: {endPointResponse.HttpStatusCode}, {endPointResponse.ResponseMetadata}");
}
// Save device token and application endpoint created
notificationsSubscriptions.DeviceToken = deviceToken;
notificationsSubscriptions.ApplicationEndPoint = endPointResponse.EndpointArn;
}
// Retrieve subscriptions
var subscriptions = await AudioLibrary.Instance.GetUserSubscriptions(false);
if (subscriptions == null)
{
subscriptions = new UserSubscriptions {
Subscriptions = new List <Models.Api.Subscription>()
}
}
;
// Register non existings subscriptions
var subscriptionsCodes = subscriptions.Subscriptions.Select(s => s.Code).ToList();
foreach (var code in subscriptionsCodes)
{
if (!notificationsSubscriptions.Subscriptions.ContainsKey(code))
{
var topicArn = AppSettings.Instance.AwsTopicArn;
topicArn += string.IsNullOrEmpty(code) ? "" : $"-{code}";
if (!await TopicExists(topicArn, client))
{
var topicResponse = await client.CreateTopicAsync(new CreateTopicRequest { Name = $"{AppSettings.Instance.AwsTopicName}-{code}" });
if (topicResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
ShowAlert("Debug", $"Error creando topic: {topicResponse.HttpStatusCode}, {topicResponse.ResponseMetadata}");
}
topicArn = topicResponse.TopicArn;
}
// Subscribe
var subscribeResponse = await client.SubscribeAsync(new SubscribeRequest
{
Protocol = "application",
Endpoint = notificationsSubscriptions.ApplicationEndPoint,
TopicArn = topicArn
});
if (subscribeResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
ShowAlert("Debug", $"Error creando suscripción: {subscribeResponse.HttpStatusCode}, {subscribeResponse.ResponseMetadata}");
}
// Add to the list
notificationsSubscriptions.Subscriptions.Add(code, subscribeResponse.SubscriptionArn);
}
}
// Remove subscriptions not in user list
var currentSubscriptions = notificationsSubscriptions.Subscriptions.ToList();
foreach (var subs in currentSubscriptions)
{
if (!subscriptionsCodes.Contains(subs.Key))
{
try
{
await client.UnsubscribeAsync(subs.Value);
}
catch { /*Silent error in case endpoint doesn´t exist */ }
notificationsSubscriptions.Subscriptions.Remove(subs.Key);
}
}
// Save notifications subscriptions
await SaveNotificationsSubscriptions(notificationsSubscriptions);
}
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");
}