public async Task <bool> SubscribeEmail(string topicArn, string email)
{
//subscribe to an SNS topic
SubscribeRequest subscribeRequest = new SubscribeRequest(topicArn, "email", email);
SubscribeResponse subscribeResponse = await _sns.SubscribeAsync(subscribeRequest);
Console.WriteLine("Subscribe RequestId: {0}", subscribeResponse.ResponseMetadata.RequestId);
Console.WriteLine("Check your email and confirm subscription.");
return(true);
}
private async void HandleRegistration(Intent intent)
{
string registrationId = intent.GetStringExtra("registration_id");
string error = intent.GetStringExtra("error");
string unregistration = intent.GetStringExtra("unregistered");
CognitoAWSCredentials credentials = new Authenticator().getCredentials();
snsClient = new AmazonSimpleNotificationServiceClient(credentials, RegionEndpoint.USEast1);
if (string.IsNullOrEmpty(error))
{
var response = await snsClient.CreatePlatformEndpointAsync(new CreatePlatformEndpointRequest
{
Token = registrationId,
PlatformApplicationArn = Keys.GCMEndpointARN /* insert your platform application ARN here */
});
var endpoint = response.EndpointArn;
var subscribeResponse = await snsClient.SubscribeAsync(new SubscribeRequest
{
TopicArn = Keys.AppTopicARN,
Endpoint = endpoint,
Protocol = "application"
});
}
}
// Notify through sms (or email)
private static void snsPublish(string contact, string message)
{
AmazonSimpleNotificationServiceClient client = new AmazonSimpleNotificationServiceClient(RegionEndpoint.USEast1);
string arn = "arn:aws:sns:xxxxxxxx:TrafficTicket";
// subscribe user to the ticketing policy
SubscribeRequest request = new SubscribeRequest(arn, "sms", contact); // ("sms" can be replaced by "email)
var task = client.SubscribeAsync(request, new System.Threading.CancellationToken());
task.Wait();
// Publish the message
PublishRequest p = new PublishRequest
(
message: message,
topicArn: arn
);
var task2 = client.PublishAsync(p, new System.Threading.CancellationToken());
task2.Wait();
PublishResponse r = task2.Result;
Console.WriteLine("PublishRequest: " + r.ResponseMetadata.RequestId);
Console.WriteLine("Message sent succesfully.");
}
public override async void RegisteredForRemoteNotifications(UIApplication application, NSData token)
{
var deviceToken = token.Description.Replace("<", "").Replace(">", "").Replace(" ", "");
if (!string.IsNullOrEmpty(deviceToken))
{
//register with SNS to create an endpoint ARN
var response = await snsClient.CreatePlatformEndpointAsync(
new CreatePlatformEndpointRequest
{
Token = deviceToken,
PlatformApplicationArn = Keys.APNSEndpointARN /* insert your platform application ARN here */
});
var endpoint = response.EndpointArn;
var subscribeResponse = await snsClient.SubscribeAsync(new SubscribeRequest
{
TopicArn = Keys.AppTopicARN,
Endpoint = endpoint,
Protocol = "application"
});
}
}
public static async Task CreateEmailSubscription(string topicArn, string emailAddress)
{
using (var client = new AmazonSimpleNotificationServiceClient(ConfigManager.ConfigSettings.AccessKey, ConfigManager.ConfigSettings.Secret, Amazon.RegionEndpoint.USWest2))
{
var request = new SubscribeRequest(topicArn, "email", emailAddress);
await client.SubscribeAsync(request);
}
}
public async System.Threading.Tasks.Task <SubscribeResponse> SubscribeToTopic(string topicArn, string emailAddress)
{
SubscribeResponse subscribeResponse = new SubscribeResponse();
using (AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(credentials, Amazon.RegionEndpoint.USEast2))
{
SubscribeRequest subscribeRequest = new SubscribeRequest(topicArn, "email", emailAddress);
subscribeResponse = await snsClient.SubscribeAsync(subscribeRequest);
}
return(subscribeResponse);
}
public async Task <IActionResult> Subscribe(string email)
{
var clientSNS = new AmazonSimpleNotificationServiceClient(_awsAccessKeySNS, _awsSecretKeySNS, Amazon.RegionEndpoint.USEast1);
var subscribeResponse = await clientSNS.SubscribeAsync(new SubscribeRequest(_topic, "email", email));
if (subscribeResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
throw new Exception("Topic subscription falied");
}
return(Ok());
}
public async System.Threading.Tasks.Task SubscribeAsync()
{
AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(RegionEndpoint.APSoutheast1);
string topicArn = "";
// Subscribe an email endpoint to an Amazon SNS topic.
SubscribeRequest subscribeRequest = new SubscribeRequest(topicArn, "email", "*****@*****.**");
SubscribeResponse subscribeResponse = await snsClient.SubscribeAsync(subscribeRequest);
// Print the request ID for the SubscribeRequest action.
Console.WriteLine("SubscribeRequest: " + subscribeResponse.ResponseMetadata.RequestId);
Console.WriteLine("To confirm the subscription, check your email.");
}
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 static async Task SetupAws()
{
try
{
Environment.SetEnvironmentVariable("AWS_ACCESS_KEY_ID", "XXX", EnvironmentVariableTarget.Process);
Environment.SetEnvironmentVariable("AWS_SECRET_ACCESS_KEY", "XXX", EnvironmentVariableTarget.Process);
Environment.SetEnvironmentVariable("AWS_SESSION_TOKEN", "XXX", EnvironmentVariableTarget.Process);
Environment.SetEnvironmentVariable("AWS_DEFAULT_REGION", "us-east-1", EnvironmentVariableTarget.Process);
var snsClient = new AmazonSimpleNotificationServiceClient(new AmazonSimpleNotificationServiceConfig
{
ServiceURL = "http://localhost:4575"
});
var sqsClient = new AmazonSQSClient(new AmazonSQSConfig
{
ServiceURL = "http://localhost:4576"
});
var topicName = topic.Replace(".", "_");
var topicRequest = new CreateTopicRequest(topicName);
var topicResponse = await snsClient.CreateTopicAsync(topicRequest);
var queueRequest = new CreateQueueRequest($"{topicName}.queue");
var queueResponse = await sqsClient.CreateQueueAsync(queueRequest);
var subscribeRequest = new SubscribeRequest
{
Endpoint = queueResponse.QueueUrl,
TopicArn = topicResponse.TopicArn,
Protocol = "sqs",
ReturnSubscriptionArn = true,
Attributes = new Dictionary <string, string>
{
["RawMessageDelivery"] = "true"
}
};
var subscribeResponse = await snsClient.SubscribeAsync(subscribeRequest);
(await snsClient.ListTopicsAsync()).Topics.ForEach(x => Console.WriteLine($"[AWS] Topic: {x.TopicArn}"));
(await sqsClient.ListQueuesAsync(new ListQueuesRequest())).QueueUrls.ForEach(x => Console.WriteLine($"[AWS] Queue: {x}"));
(await snsClient.ListSubscriptionsAsync(new ListSubscriptionsRequest())).Subscriptions.ForEach(x => Console.WriteLine($"[AWS] Subscription: {x.TopicArn} -> {x.Endpoint}"));
}
catch (Exception e)
{
Console.WriteLine($"[AWS] {e.Message}");
}
}
public async System.Threading.Tasks.Task <SubscribeResponse> SubscribeToSQS(string topicARN, string sqsArn, string queueUrl)
{
// subcriber SNS to a SQS
SubscribeResponse subscriptionResponse = new SubscribeResponse();
using (AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(credentials, Amazon.RegionEndpoint.USEast2))
{
SubscribeRequest request = new SubscribeRequest()
{
TopicArn = topicARN,
Endpoint = sqsArn,
Protocol = "sqs"
};
subscriptionResponse = await snsClient.SubscribeAsync(request);
}
return(subscriptionResponse);
}
private void CreateTopicsAndQueues()
{
var topicAndQueueName = $"toll-amount-threshold-breached-{Guid.NewGuid().ToString().Substring(0,8)}";
var createTopicResponse = _snsClient.CreateTopicAsync(new CreateTopicRequest {
Name = topicAndQueueName
}).Result;
var createQueueResponse = _sqsClient.CreateQueueAsync(new CreateQueueRequest {
QueueName = topicAndQueueName
}).Result;
TopicArn = createTopicResponse.TopicArn;
QueueUrl = createQueueResponse.QueueUrl;
var subscriptionArn = _snsClient.SubscribeAsync(new SubscribeRequest {
TopicArn = createTopicResponse.TopicArn, Endpoint = createQueueResponse.QueueUrl, Protocol = "sqs"
}).Result;
var r = _snsClient.SetSubscriptionAttributesAsync(subscriptionArn.SubscriptionArn, "RawMessageDelivery", "true").Result;
}
public async Task <ISubscription> SubscribeAsync(String topic)
{
var amazonTopic = await amazonSnsClient.CreateTopicAsync(new CreateTopicRequest()
{
Name = topic
});
var queue = await amazonSqsClient.CreateQueueAsync(new CreateQueueRequest()
{
QueueName = Guid.NewGuid().ToString()
});
var queueAttributes = await amazonSqsClient.GetQueueAttributesAsync(new GetQueueAttributesRequest()
{
AttributeNames = new List <String>(new String[] { "QueueArn" }),
QueueUrl = queue.QueueUrl
});
var policy = new Policy()
.WithStatements(
new Statement(Statement.StatementEffect.Allow)
.WithPrincipals(Principal.AllUsers)
.WithConditions(ConditionFactory.NewSourceArnCondition(amazonTopic.TopicArn))
.WithResources(new Resource(queueAttributes.QueueARN))
.WithActionIdentifiers(SQSActionIdentifiers.SendMessage));
await amazonSqsClient.SetQueueAttributesAsync(queue.QueueUrl, new Dictionary <String, String>()
{
["Policy"] = policy.ToJson()
});
await amazonSnsClient.SubscribeAsync(new SubscribeRequest()
{
Endpoint = queueAttributes.QueueARN,
Protocol = "sqs",
TopicArn = amazonTopic.TopicArn
});
var subscription = amazonSubscriptionFactory.Create(queue.QueueUrl);
return(subscription);
}
public async Task <IActionResult> AddUserByEmail([FromBody] AddUserDto model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(NotFound());
}
_dbContext.UserClass.Add(new UserClass()
{
ApplicationUserId = user.Id, ClassRoomId = model.ClassRoomId
});
_dbContext.SaveChanges();
AmazonSimpleNotificationServiceClient client = new AmazonSimpleNotificationServiceClient("AKIAJLAJIOHNR4Q2EQSQ", "+5t2ISSTpRYQnZomhd+C4S9LqQ8YiRqKjV1YRHLM", Amazon.RegionEndpoint.USWest2);
var topicArn = await client.CreateTopicAsync(new CreateTopicRequest(model.ClassRoomId.ToString()));
await client.SubscribeAsync(new SubscribeRequest(topicArn.TopicArn, "email", model.Email));
return(Json("All good bro!"));
}
public async Task <IActionResult> Subscribe(RegisterViewModel registerViewModel)
{
var emailAddress = registerViewModel.Email;
var sns = new AmazonSimpleNotificationServiceClient();
if (!string.IsNullOrEmpty(emailAddress))
{
var listTopicsRequest = new ListTopicsRequest();
ListTopicsResponse listTopicsResponse;
listTopicsResponse = await sns.ListTopicsAsync(listTopicsRequest);
var selectedTopic = listTopicsResponse.Topics.FirstOrDefault();
await sns.SubscribeAsync(new SubscribeRequest
{
TopicArn = selectedTopic.TopicArn,
Protocol = "email",
Endpoint = emailAddress
});
}
return(View("Index"));
}
private async Task SubscribeQueueToTopic()
{
var subscribeRequest = new SubscribeRequest(topicArn, "sqs", queueUrl);
await snsClient.SubscribeAsync(subscribeRequest);
}
private async Task SubscribeMessage()
{
var subscribeRequest = new SubscribeRequest(topicArn, "email", "*****@*****.**");
var subscribeResponse = await snsClient.SubscribeAsync(subscribeRequest);
}
public static async Task SetupAsync(IWebApi webApi, string topicArn, string endPoint, string bucketName, Func <string, string, string[], Task <string> > handler)
{
if (!string.IsNullOrEmpty(endPoint))
{
Uri endPointUri = new Uri(endPoint);
//logger.Debug($"SetupWebApi():endPointUri.PathAndQuery={endPointUri.PathAndQuery}");
using (AmazonSimpleNotificationServiceClient amazonSimpleNotificationServiceClient = new AmazonSimpleNotificationServiceClient(Amazon.RegionEndpoint.USEast1)) {
SubscribeResponse subscribeResponse = await amazonSimpleNotificationServiceClient.SubscribeAsync(new SubscribeRequest {
TopicArn = topicArn,
Protocol = endPointUri.Scheme,
Endpoint = endPoint
});
}
AmazonS3Client amazonS3Client = new AmazonS3Client(Amazon.RegionEndpoint.USEast1);
webApi.OnPost(
endPointUri.PathAndQuery,
async(req, res) => {
logger.Debug($"{endPointUri.PathAndQuery}");
Dict evt = await req.ParseAsJsonAsync <Dict>();
logger.Debug($"{endPointUri.PathAndQuery},evt=" + JsonUtil.Serialize(evt));
string type = evt.GetAs("Type", (string)null);
if (type == "SubscriptionConfirmation")
{
string subscribeUrl = evt.GetAs("SubscribeURL", (string)null);
using (WebClient webClient = new WebClient()) {
string result = await webClient.DownloadStringTaskAsync(new Uri(subscribeUrl));
logger.Debug($"{endPointUri.PathAndQuery},result=" + result);
}
}
else if (type == "Notification")
{
//string messageId = evt.GetAs("MessageId", (string)null);
string messageJson = evt.GetAs("Message", (string)null);
logger.Debug($"{endPointUri.PathAndQuery},messageJson={messageJson}");
Dict message = JsonUtil.Deserialize <Dict>(messageJson);
Dict mail = message.GetAs("mail", (Dict)null);
Dict[] headers = mail.GetAs("headers", (Dict[])null);
Dict inReplyToHeader = Array.Find(headers, x => x.GetAs("name", "") == "In-Reply-To");
string inReplyTo = inReplyToHeader.GetAs("value", "");
logger.Debug($"{endPointUri.PathAndQuery},inReplyTo={inReplyTo}");
Match match = IN_REPLY_TO_REGEX.Match(inReplyTo);
if (match.Success)
{
string sentMessageId = match.Groups[1].Value;
string bucketKey = mail.GetAs("messageId", (string)null);
logger.Debug($"{endPointUri.PathAndQuery},sentMessageId={sentMessageId},bucketKey={bucketKey}");
if (!string.IsNullOrEmpty(bucketKey))
{
GetObjectResponse getObjectResponse = await amazonS3Client.GetObjectAsync(new GetObjectRequest {
BucketName = bucketName,
Key = bucketKey
});
logger.Debug($"{endPointUri.PathAndQuery},getObjectResponse={getObjectResponse}");
MimeMessage mimeMessage = await MimeMessage.LoadAsync(getObjectResponse.ResponseStream);
logger.Debug($"{endPointUri.PathAndQuery},mimeMessage={mimeMessage}");
await handler(sentMessageId, mimeMessage.TextBody, new string[] { });
}
}
}
}
);
}
}
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 void MonitorEmail(string emailaddr)
{
if (Exists(emailaddr) && !monitors.ContainsKey(emailaddr))
{
FastEmailMailbox mbx = Mailboxes[emailaddr];
FastEmailMonitor monitor = new FastEmailMonitor();
monitor.mbx = mbx;
monitor.sqsqueue_name = mbx.S3Bucket + "-" + Process.GetCurrentProcess().Id + "-" + System.Environment.MachineName;
create_sqsclient();
try
{
// create the queue
var sqscreateresponse = sqsclient.CreateQueueAsync(new CreateQueueRequest
{
QueueName = monitor.sqsqueue_name
});
CreateQueueResponse sqsresult = sqscreateresponse.Result;
monitor.sqsqueue_url = sqsresult.QueueUrl;
}
catch (AmazonSQSException e)
{
Console.WriteLine("Exception while creating SQS Queue for {0}: {1}", emailaddr, e.Message);
}
// get the queue arn
try
{
List <string> attr = new List <string>()
{
"QueueArn"
};
var sqsattrresponse = sqsclient.GetQueueAttributesAsync(new GetQueueAttributesRequest
{
QueueUrl = monitor.sqsqueue_url,
AttributeNames = attr
});
GetQueueAttributesResponse sqsresponse = sqsattrresponse.Result;
monitor.sqsqueue_arn = sqsresponse.QueueARN;
}
catch (AmazonSQSException e)
{
Console.WriteLine("Exception while getting QueueARN SQS Queue for {0}: {1}", emailaddr, e.Message);
}
// add permission
string perm = @"{
""Version"":""2012-10-17"",
""Statement"":[
{
""Sid"":""Policy-"
+ monitor.mbx.TopicArn;
perm += @""",
""Effect"":""Allow"",
""Principal"":""*"",
""Action"":""sqs:SendMessage"",
""Resource"":"""
+ monitor.sqsqueue_arn;
perm += @""",
""Condition"":{
""ArnEquals"":{
""aws:SourceArn"":"""
+ monitor.mbx.TopicArn;
perm += @"""
}
}
}
]
}";
var policy = new Dictionary <string, string>();
policy.Add("Policy", perm);
try
{
var qsattrrequest = sqsclient.SetQueueAttributesAsync(new SetQueueAttributesRequest
{
QueueUrl = monitor.sqsqueue_url,
Attributes = policy
});
var qsattrresponse = qsattrrequest.Result;
}
catch (AmazonSQSException e)
{
Console.WriteLine("Exception while adding permission policy to queue for {0}: {1}", emailaddr, e.Message);
}
create_snsclient();
try
{
var snsresponse = snsclient.SubscribeAsync(new SubscribeRequest
{
Protocol = "sqs",
Endpoint = monitor.sqsqueue_arn,
TopicArn = monitor.mbx.TopicArn
});
var subresult = snsresponse.Result;
monitor.subscription_arn = subresult.SubscriptionArn;
}
catch (AmazonSimpleNotificationServiceException e)
{
Console.WriteLine("Exception while subscribing to queue for {0}: {1}", emailaddr, e.Message);
}
monitors.Add(emailaddr, monitor);
}
}
private static async Task <Topic> SetupTopicAndSubscriptionsAsync(string topicFileName, string outputDirectory, string regionSystemName, string archiveId = null, string filename = null)
{
var topic = new Topic
{
TopicFileName = topicFileName,
OutputDirectory = outputDirectory,
ArchiveId = archiveId,
FileName = filename,
DateRequested = DateTime.Now
};
long ticks = DateTime.Now.Ticks;
var settings = GetSettingsAsync().Result;
#region Setup SNS topic
var snsClient = new AmazonSimpleNotificationServiceClient(
settings.AWSAccessKeyID,
settings.AWSSecretAccessKey,
RegionEndpoint.GetBySystemName(regionSystemName));
var sqsClient = new AmazonSQSClient(
settings.AWSAccessKeyID,
settings.AWSSecretAccessKey,
RegionEndpoint.GetBySystemName(regionSystemName));
var topicArn = snsClient.CreateTopicAsync(new CreateTopicRequest {
Name = "GlacierDownload-" + ticks
}).Result.TopicArn;
//Debug.WriteLine($"topicArn: {topicArn}");
topic.TopicARN = topicArn;
#endregion
#region Setup SQS queue
var createQueueRequest = new CreateQueueRequest {
QueueName = "GlacierDownload-" + ticks
};
var createQueueResponse = sqsClient.CreateQueueAsync(createQueueRequest).Result;
var queueUrl = createQueueResponse.QueueUrl;
//Debug.WriteLine($"QueueURL: {queueUrl}");
topic.QueueUrl = queueUrl;
var getQueueAttributesRequest = new GetQueueAttributesRequest
{
AttributeNames = new List <string> {
"QueueArn"
},
QueueUrl = queueUrl
};
var response = await sqsClient.GetQueueAttributesAsync(getQueueAttributesRequest);
var queueArn = response.QueueARN;
Debug.WriteLine($"QueueArn: {queueArn}");
topic.QueueARN = queueArn;
#endregion
// Setup the Amazon SNS topic to publish to the SQS queue.
// TODO SMS subscription
await snsClient.SubscribeAsync(new SubscribeRequest()
{
Protocol = "sqs",
Endpoint = queueArn,
TopicArn = topicArn
});
// Add the policy to the queue so SNS can send messages to the queue.
var policy = SQS_POLICY.Replace("{TopicArn}", topicArn).Replace("{QuernArn}", queueArn);
await sqsClient.SetQueueAttributesAsync(new SetQueueAttributesRequest
{
QueueUrl = queueUrl,
Attributes = new Dictionary <string, string>
{
{ QueueAttributeName.Policy, policy }
}
});
return(topic);
}