/// <summary>
/// Lists all the queues on the SQS.
/// </summary>
/// <returns></returns>
public async Task <List <string> > ListQueuesAsync()
{
var request = new ListQueuesRequest();
var response = await _client.ListQueuesAsync(request);
return(response.QueueUrls);
}
public void SendMessage()
{
IAmazonSQS sqs = new AmazonSQSClient(RegionEndpoint.USEast1);
var sqsRequest = new CreateQueueRequest
{
QueueName = "CartQueue"
};
var createQueueResponse = sqs.CreateQueueAsync(sqsRequest).Result;
var queueUrl = createQueueResponse.QueueUrl;
var listQueueRequest = new ListQueuesRequest();
var listQueueResponse = sqs.ListQueuesAsync(listQueueRequest);
Console.WriteLine($"List of amazon queue url. \n");
foreach (var item in listQueueResponse.Result.QueueUrls)
{
Console.WriteLine($"Queue URL{item}");
}
Console.WriteLine($"Sending Message. \n");
var sqsMessageRequest = new SendMessageRequest
{
QueueUrl = queueUrl,
MessageBody = "Message Bodykkkkk"
};
sqs.SendMessageAsync(sqsMessageRequest);
}
public static async Task <IEnumerable <string> > FindQueueUrls()
{
using (var client = new AmazonSQSClient(ConfigManager.ConfigSettings.AccessKey, ConfigManager.ConfigSettings.Secret, Amazon.RegionEndpoint.USWest2))
{
var response = await client.ListQueuesAsync(new ListQueuesRequest());
return(response.QueueUrls);
}
}
public static async Task<string?> FindQueueUrlByQueueName(string name)
{
using (var client = new AmazonSQSClient(ConfigManager.ConfigSettings.AccessKey, ConfigManager.ConfigSettings.Secret, Amazon.RegionEndpoint.USWest2))
{
ListQueuesResponse response = await client.ListQueuesAsync(new ListQueuesRequest(name));
return response.QueueUrls?.FirstOrDefault();
}
}
public static void SQSQueueStandard()
{
Console.WriteLine("**********************************");
Console.WriteLine("*******___Amazon SQS___***********");
Console.WriteLine("**********************************\n");
//------- Creating a SQS standard queue
IAmazonSQS sqs = new AmazonSQSClient(RegionEndpoint.USEast1);
var sqsRequest = new CreateQueueRequest
{
QueueName = "pradoqueue3"
};
var createQueueResponse = sqs.CreateQueueAsync(sqsRequest).Result;
var myQueueUrl = createQueueResponse.QueueUrl; // Retrieving the queue URL
//------- Retrieving all existing queues URL
var listQueuesRequest = new ListQueuesRequest();
var listQueuesResponse = sqs.ListQueuesAsync(listQueuesRequest);
Console.WriteLine("List of Amazon SQS Queues\n");
foreach (var queue in listQueuesResponse.Result.QueueUrls)
{
Console.WriteLine($"QueueUrl: {queue}");
}
//------- Sending a message tho the created queue
Console.WriteLine("Sending a message to the queue\n");
var sqsMessageRequest = new SendMessageRequest
{
QueueUrl = myQueueUrl,
MessageBody = "Email information"
};
sqs.SendMessageAsync(sqsMessageRequest);
Console.WriteLine("Finished sending message to the SQS queue\n");
//------- Reading the message sended above
Console.WriteLine("Reading messages from the queue\n");
var receiveMessageRequest = new ReceiveMessageRequest();
receiveMessageRequest.QueueUrl = myQueueUrl;
var receiveMessageResponse = sqs.ReceiveMessageAsync(receiveMessageRequest);
foreach (var message in receiveMessageResponse.Result.Messages)
{
Console.WriteLine(message.Body); // Go to a method to process messages.
}
Console.ReadLine();
}
public async Task <string> ListQueues()
{
AmazonSQSClient client = new AmazonSQSClient();
ListQueuesResponse response = await client.ListQueuesAsync(string.Empty);
var queueList = string.Join("#", response.QueueUrls.Select(x => x.Substring(x.LastIndexOf("/") + 1)));
//"Compaints#inquairy"
return(queueList);
}
public void SQSCleanUp()
{
var sqsQueueList = sqsClient.ListQueuesAsync(prefix);
foreach (string queue in sqsQueueList.Result.QueueUrls)
{
if (queue.Contains(prefix))
{
try
{
sqsClient.DeleteQueueAsync(queue);
}
catch (Exception)
{
Console.Write("Failed to clean up queue {0}", queue);
}
}
}
}
private async Task <bool> QueueExists(AmazonSQSClient client, string queueName)
{
var listQueuesRequest = new ListQueuesRequest
{
QueueNamePrefix = queueName
};
ListQueuesResponse response = await client.ListQueuesAsync(listQueuesRequest);
return(response.QueueUrls.Count == 0 ? false : true);
}
static void Main(string[] args)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
Console.WriteLine("*************************");
Console.WriteLine("Amazon SQS");
Console.WriteLine("************************\n");
//var accessKey = JsonConfig.GetJsonValue("AccessKey");
//var secretKey = JsonConfig.GetJsonValue("SecretKey");
var accessKey = ConfigurationManager.AppSettings.Get("AccessKey");
var secretKey = ConfigurationManager.AppSettings.Get("SecretKey");
var queueName = "EmailQueue2";
AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
IAmazonSQS amazonSQS = new AmazonSQSClient(credentials, RegionEndpoint.EUWest2);
Console.WriteLine("Create a queue called EmailQueue.\n");
logger.Info("Create a queue called EmailQueue");
logger.Info("Testing Logs");
var sqsRequest = new CreateQueueRequest
{
QueueName = queueName
};
var createQueueResponse = amazonSQS.CreateQueueAsync(sqsRequest).Result;
var myQueueRrl = createQueueResponse.QueueUrl;
var listQueueRequest = new ListQueuesRequest();
var listQueuesResponce = amazonSQS.ListQueuesAsync(listQueueRequest);
Console.WriteLine("List of Amazon SQS queuse.\n");
foreach (var queueurl in listQueuesResponce.Result.QueueUrls)
{
Console.WriteLine($"QueueUrl : {queueurl}");
}
Console.WriteLine("Sendin a message to our emailQueue. \n");
var sqsMessageRequest = new SendMessageRequest
{
QueueUrl = myQueueRrl,
MessageBody = "Email Information"
};
amazonSQS.SendMessageAsync(sqsMessageRequest);
Console.WriteLine("Finished sending message to our sqs queue. \n");
Console.ReadLine();
}
public void DeleteQueuesWithPrefix()
{
try {
var queues = _client.ListQueuesAsync(new ListQueuesRequest(QUEUE_NAME)).Result;
foreach (var queue in queues.QueueUrls)
{
_client.DeleteQueueAsync(queue).Wait();
}
} catch (Exception ex) {
// These may get deleted by a tear down
}
}
static async void MainAsync(string[] args)
{
try
{
var listQueuesRequest = new ListQueuesRequest();
var listQueuesResponse = await _sqs.ListQueuesAsync(listQueuesRequest);
try
{
Console.WriteLine($"Checking for a queue called {_queueName}.\n");
var resp = await _sqs.GetQueueUrlAsync(_queueName);
_myQueueUrl = resp.QueueUrl;
}
catch (QueueDoesNotExistException quex)
{
//Creating a queue
Console.WriteLine($"Create a queue called {_queueName}.\n");
var sqsRequest = new CreateQueueRequest {
QueueName = _queueName
};
var createQueueResponse = await _sqs.CreateQueueAsync(sqsRequest);
_myQueueUrl = createQueueResponse.QueueUrl;
}
//Sending a message
for (int i = 0; i < 2; i++)
{
var message = $"This is my message text-Id-{Guid.NewGuid().ToString("N")}";
//var message = $"This is my message text";
Console.WriteLine($"Sending a message to MyQueue : {message}");
var sendMessageRequest = new SendMessageRequest
{
QueueUrl = _myQueueUrl, //URL from initial queue creation
MessageBody = message
};
await _sqs.SendMessageAsync(sendMessageRequest);
}
}
catch (AmazonSQSException ex)
{
Console.WriteLine("Caught Exception: " + ex.Message);
Console.WriteLine("Response Status Code: " + ex.StatusCode);
Console.WriteLine("Error Code: " + ex.ErrorCode);
Console.WriteLine("Error Type: " + ex.ErrorType);
Console.WriteLine("Request ID: " + ex.RequestId);
}
Console.WriteLine("Press Enter to continue...");
Console.Read();
}
public async Task <List <string> > GetQueueUrls()
{
ListQueuesResponse response = await sqsClient.ListQueuesAsync(new ListQueuesRequest());
var queues = new List <string>();
foreach (var queueUrl in response.QueueUrls)
{
queues.Add($"{queueUrl}");
}
return(queues);
}
private async Task <string> CheckIfQueueExist(string queueName)
{
var listQueuesRequest = new ListQueuesRequest
{
QueueNamePrefix = queueName
};
var listQueuesResponse = await _sqs.ListQueuesAsync(listQueuesRequest);
var queueUrl = listQueuesResponse.QueueUrls.FirstOrDefault(s => s.Contains(queueName));
return(queueUrl);
}
public async Task ListQueueExample()
{
// Create service client using the SDK's default logic for determining AWS credentials and region to use.
// For information configuring service clients checkout the .NET developer guide: https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config.html
AmazonSQSClient client = new AmazonSQSClient();
ListQueuesResponse response = await client.ListQueuesAsync(new ListQueuesRequest());
foreach (var queueUrl in response.QueueUrls)
{
Console.WriteLine(queueUrl);
}
}
public async Task <IList <string> > ListQueuesAsync(string profile, string region)
{
var creds = GetCredentials(profile);
var queues = new List <string>();
using (var client = new AmazonSQSClient(creds, RegionEndpoint.GetBySystemName(region)))
{
var response = await client.ListQueuesAsync(new ListQueuesRequest());
return(response.QueueUrls);
}
}
static void Main(string[] args)
{
var _awsAccessKeyId = "aqui_vai_a_AccessKeyId";
var _awsSecretAccessKey = "aqui_vai_a_SecretAccessKey";
var _nameQueue = "nome_da_fila_na_AWS";
var _from = "*****@*****.**";
var _recipient = "*****@*****.**";
var _subject = "assunto do email";
var _content = "conteudo do email";
var dadosEmail = new email(_subject, _recipient, _from, _content);
string msg = JsonConvert.SerializeObject(dadosEmail);
// acesso ao cliente SQS da AWS
IAmazonSQS sqs = new AmazonSQSClient(_awsAccessKeyId, _awsSecretAccessKey, RegionEndpoint.SAEast1);
// conexao com a fila pelo nome
var sqsRequest = new CreateQueueRequest
{
QueueName = _nameQueue
};
var createQueueResponse = sqs.CreateQueueAsync(sqsRequest).Result;
// get na url da fila pelo nome
var myQueueUrl = createQueueResponse.QueueUrl;
var listQueueRequest = new ListQueuesRequest();
var listQueuesResponse = sqs.ListQueuesAsync(listQueueRequest);
var sqsMessageRequest = new SendMessageRequest
{
QueueUrl = myQueueUrl,
MessageBody = msg
};
if (sqs.SendMessageAsync(sqsMessageRequest).Result.HttpStatusCode.ToString() == "OK")
{
Console.WriteLine("menssagem enviada");
}
else
{
Console.WriteLine("nao menssagem enviada");
}
}
public static async Task DeleteAllQueues()
{
using (var client = new AmazonSQSClient(ConfigManager.ConfigSettings.AccessKey, ConfigManager.ConfigSettings.Secret, Amazon.RegionEndpoint.USWest2))
{
var response = await client.ListQueuesAsync(new ListQueuesRequest());
foreach (var queueUrl in response.QueueUrls)
{
await PurgeQueueByQueueUrl(queueUrl);
await client.DeleteQueueAsync(queueUrl);
}
}
}
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 static List <string> GetAWSSQSQueues()
{
using (IAmazonSQS sqs = new AmazonSQSClient(RegionEndpoint.USEast1))
{
Console.WriteLine("Getting list of available sqs queues .....");
var listeQueueReq = new ListQueuesRequest();
var listQueueRes = sqs.ListQueuesAsync(listeQueueReq).Result;
if (listQueueRes.HttpStatusCode == HttpStatusCode.OK)
{
return(listQueueRes.QueueUrls);
}
else
{
return(null);
}
}
}
static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
IConfigurationRoot configuration = builder.Build();
Console.WriteLine(new string('*', 100));
Console.WriteLine("SQS Service");
Console.WriteLine(new string('*', 100));
var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(configuration["seecretAccess"], configuration["seecretKey"]);
IAmazonSQS sqsClient = new AmazonSQSClient(awsCredentials, RegionEndpoint.APSoutheast2);
Console.WriteLine("Create a queue called EmailQueue");
var sqsRequest = new CreateQueueRequest {
QueueName = "EmailQueue"
};
var createQueueReponse = sqsClient.CreateQueueAsync(sqsRequest).Result;
var sqsUrl = createQueueReponse.QueueUrl;
var listQueueRequest = new ListQueuesRequest();
var listQueueResponse = sqsClient.ListQueuesAsync(listQueueRequest);
foreach (var item in listQueueResponse.Result.QueueUrls)
{
Console.WriteLine($"Queue url: {item}");
}
Console.WriteLine("Send a message to Queue");
var sqsMessageRequest = new SendMessageRequest
{
QueueUrl = sqsUrl,
MessageBody = "First message"
};
sqsClient.SendMessageAsync(sqsMessageRequest);
Console.WriteLine("Message sent");
Console.ReadKey();
}
static async Task Main(string[] args)
{
string url;
var sharedFile = new SharedCredentialsFile();
sharedFile.TryGetProfile("default", out var sourceProfile);
var credentials = AWSCredentialsFactory.GetAWSCredentials(sourceProfile, sharedFile);
_client = new AmazonSQSClient(credentials, new AmazonSQSConfig()
{
ServiceURL = "http://192.168.1.57:4566"
});
ListQueuesResponse response = await _client.ListQueuesAsync(new ListQueuesRequest());
if (!response.QueueUrls.Any())
{
CreateQueueResponse c_response = await _client.CreateQueueAsync("test");
if (c_response.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
url = c_response.QueueUrl;
Console.WriteLine("create queue success");
}
else
{
Console.WriteLine("create queue fail");
return;
}
}
else
{
url = response.QueueUrls.First();
}
//var msg = Console.ReadLine();
Console.WriteLine(url);
//SendMessageResponse s_reponse=await _client.SendMessageAsync(url,msg);
//Console.WriteLine(response.HttpStatusCode.ToString());
Console.ReadLine();
}
public static void SQSQueueFIFO()
{
Console.WriteLine("**********************************");
Console.WriteLine("*******___Amazon SQS___***********");
Console.WriteLine("**********************************\n");
IAmazonSQS sqs = new AmazonSQSClient(RegionEndpoint.USEast1);
var sqsRequest = new CreateQueueRequest
{
QueueName = "pradoqueue.fifo",
Attributes = new Dictionary <string, string> {
{ "FifoQueue", "true" }
}
};
var createQueueResponse = sqs.CreateQueueAsync(sqsRequest).Result;
var myQueueUrl = createQueueResponse.QueueUrl;
var listQueuesRequest = new ListQueuesRequest();
var listQueuesResponse = sqs.ListQueuesAsync(listQueuesRequest);
Console.WriteLine("List of Amazon SQS Queues\n");
foreach (var queue in listQueuesResponse.Result.QueueUrls)
{
Console.WriteLine($"QueueUrl: {queue}");
}
Console.WriteLine("Sending a message to the queue\n");
var sqsMessageRequest = new SendMessageRequest
{
QueueUrl = myQueueUrl,
MessageBody = "Email information"
};
sqs.SendMessageAsync(sqsMessageRequest);
Console.WriteLine("Finished sending message to the SQS queue\n");
Console.ReadLine();
}
static async System.Threading.Tasks.Task Main(string[] args)
{
Boolean continuar = true;
//Subscribe to SQS, which is being fed by the SNS topic
myQueueUrl = "myTestQueue";
IAmazonSQS sqs = new AmazonSQSClient(RegionEndpoint.EUCentral1);
//Confirming the queue exists
ListQueuesRequest listQueuesRequest = new ListQueuesRequest();
ListQueuesResponse listQueuesResponse = await sqs.ListQueuesAsync(listQueuesRequest);
while (continuar)
{
ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
receiveMessageRequest.QueueUrl = myQueueUrl;
ReceiveMessageResponse receiveMessageResponse = await sqs.ReceiveMessageAsync(receiveMessageRequest);
Console.WriteLine("Printing received message.\n");
foreach (Message message in receiveMessageResponse.Messages)
{
//Print the message
Console.WriteLine(" Message");
Console.WriteLine(" MessageId: {0}", message.MessageId);
Console.WriteLine(" ReceiptHandle: {0}", message.ReceiptHandle);
Console.WriteLine(" MD5OfBody: {0}", message.MD5OfBody);
Console.WriteLine(" Body: {0}", message.Body);
var messageRecieptHandle = message.ReceiptHandle;
//Deleting each message
Console.WriteLine("Deleting the message.\n");
DeleteMessageRequest deleteRequest = new DeleteMessageRequest();
deleteRequest.QueueUrl = myQueueUrl;
deleteRequest.ReceiptHandle = messageRecieptHandle;
await sqs.DeleteMessageAsync(deleteRequest);
}
Thread.Sleep(5000);
}
}
static void Main(string[] args)
{
Console.WriteLine("*************************************");
Console.WriteLine("Amazon SQS");
Console.WriteLine("*************************************\n");
IAmazonSQS sqs = new AmazonSQSClient(RegionEndpoint.APSouth1);
Console.WriteLine("Create a queue called email queue\n");
var sqsRequest = new CreateQueueRequest
{
QueueName = "EmailQueue"
};
var createQueueResponse = sqs.CreateQueueAsync(sqsRequest).Result;
var myQueueUrl = createQueueResponse.QueueUrl;
var listQueuesRequest = new ListQueuesRequest();
var listQueuesResponse = sqs.ListQueuesAsync(listQueuesRequest);
Console.WriteLine("List Amazon queues\n");
foreach (var queueUrl in listQueuesResponse.Result.QueueUrls)
{
Console.WriteLine($"QueueUrl {queueUrl}\n");
}
Console.WriteLine("Sending a message to our Email Queue\n");
var sqsMessageRequest = new SendMessageRequest
{
QueueUrl = myQueueUrl,
MessageBody = "Email information Sent by Kaushik"
};
sqs.SendMessageAsync(sqsMessageRequest);
Console.WriteLine("Finished Sending message to our SQS queue \n");
Console.ReadLine();
}
public async Task ExecuteAsync()
{
try
{
var creds = Utils.GetCredentials(this.AWSProfile);
using (var client = new AmazonSQSClient(creds, RegionEndpoint.GetBySystemName(this.AWSRegion)))
{
var response = await client.ListQueuesAsync(new ListQueuesRequest());
foreach (var queue in response.QueueUrls)
{
Console.WriteLine(queue);
}
}
}
catch (Exception e)
{
Console.Error.WriteLine("Error listing queues: " + e.Message);
throw;
}
}
private static void CreateQueue()
{
var awsCreds = new BasicAWSCredentials(AccessKey, SecretKey);
var config = new AmazonSQSConfig
{
ServiceURL = ServiceUrl,
//RegionEndpoint = RegionEndpoint.USEast1
};
var amazonSqsClient = new AmazonSQSClient(awsCreds, config);
var createQueueRequest = new CreateQueueRequest();
try
{
amazonSqsClient.GetQueueUrlAsync(QueueName);
var result = amazonSqsClient.ListQueuesAsync(QueueName);
if (result.Result.QueueUrls.Count <= 0)
{
try
{
var lista = amazonSqsClient.GetQueueUrlAsync(QueueName);
// create channel
createQueueRequest.QueueName = QueueName;
var createQueueResponse = amazonSqsClient.CreateQueueAsync(createQueueRequest);
Console.WriteLine("QueueUrl : " + createQueueResponse.Result.QueueUrl);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Method to run light work Health Check for AWS
/// </summary>
/// <param name="serviceKey"></param>
/// <param name="value"></param>
/// <returns></returns>
public LightHealth.HealthCheck HealthCheck(string serviceKey, string value)
{
try
{
if (_queues.Count > 0)
{
var queueEnum = _queues.GetEnumerator();
var queue = queueEnum.Current;
SqsSnsConfiguration config = GetConnection(queue);
MethodInfo method = GetMethod(queue);
string queueName = queue.Value.QueueName;
int takeQuantity = queue.Value.TakeQuantity;
AmazonSQSClient sqsClient = new AmazonSQSClient(config.AwsAccessKeyId, config.AwsSecretAccessKey);
sqsClient.ListQueuesAsync("healthQueue");
}
if (_topics.Count > 0)
{
var topicEnum = _topics.GetEnumerator();
var topic = topicEnum.Current;
SqsSnsConfiguration config = GetConnection(topic);
MethodInfo method = GetMethod(topic);
string topicName = topic.Value.TopicName;
string subscriptName = topic.Value.Subscription;
AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(config.AwsAccessKeyId, config.AwsSecretAccessKey);
snsClient.ListTopicsAsync("healthTopic");
}
return(LightHealth.HealthCheck.Healthy);
}
catch
{
return(LightHealth.HealthCheck.Unhealthy);
}
}
private void WaitTillReady()
{
for (var i = 0; i < 20; i++)
{
try
{
Log.Logger.Information("Waiting for SNS SQS...");
var cancellationToken = new CancellationTokenSource(2000).Token;
var snsResponse = _snsClient.ListTopicsAsync(cancellationToken).Result;
var sqsResponse = _sqsClient.ListQueuesAsync("", cancellationToken).Result;
if (snsResponse.HttpStatusCode == HttpStatusCode.OK && sqsResponse.HttpStatusCode == HttpStatusCode.OK)
{
return;
}
}
catch (Exception ex)
{
Log.Logger.Information($"Failed to connect, attempt - {i} - {ex.Message}");
}
}
throw new Exception("SNS/SQS initialization failed");
}
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
});
});
}
private static async Task ListQueuesAsync(AmazonSQSClient sqsClient)
{
var listQueuesResponse = await sqsClient.ListQueuesAsync(new ListQueuesRequest());
Console.WriteLine($"ListQueuesAsync HTTP status code: {listQueuesResponse.HttpStatusCode}");
}
