private AmazonSQSClient InitializeQueue()
{
var client = new AmazonSQSClient(Utility.GetRegionEndpoint());
ListQueuesRequest listQueuesRequest = new ListQueuesRequest
{
QueueNamePrefix = QueueName
};
var listQueuesResponse = client.ListQueues(listQueuesRequest);
bool found = listQueuesResponse.ListQueuesResult.QueueUrls.Any(s => s == QueueName);
if (found == false)
{
var createQueueResponse = client.CreateQueue(new CreateQueueRequest
{
QueueName = QueueName
});
QueueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
}
else
{
QueueUrl = client.GetQueueUrl(
new GetQueueUrlRequest
{
QueueName = _queueName
}
).GetQueueUrlResult.QueueUrl;
}
return client;
}
public AmazonConnection(TypeOfMsg requestMsgType)
{
pollingMsg = requestMsgType;
objClient = new AmazonSQSClient(AccessKeyId, SecretAccessKey);
CreateQueueResponse queueResponse = new CreateQueueResponse();
//Request existing queues
ListQueuesResult allQueues = requestListOfQueuesInSQS();
bool eventSparkzQueueListExists = false;
foreach (string queueURL in allQueues.QueueUrl)
{
if (queueURL.Equals(QueueURLString))
{
eventSparkzQueueListExists = true;
}
}
if (!eventSparkzQueueListExists)
{
queueResponse = objClient.CreateQueue(new CreateQueueRequest()
{
QueueName
= EventSparkzQueueName
});
}
}
public bool sendPosition(string latitude, string longitude)
{
AmazonSQSClient sqsClient = new AmazonSQSClient(Amazon.RegionEndpoint.USEast1);
Amazon.SQS.Model.SendMessageRequest request = new Amazon.SQS.Model.SendMessageRequest();
request.QueueUrl = SQS_URL_STRING;
request.MessageBody = "lat: " + latitude + " lon: " + longitude;
sqsClient.SendMessage(request);
return true;
}
static void WriteToQueue(AWSCredentials credentials)
{
AmazonSQSClient client = new AmazonSQSClient(credentials, RegionEndpoint.USEast1);
string message = "my message";
string queueUrl = "https://sqs.us-east-1.amazonaws.com/025631894481/aws-talk";
SendMessageResponse sendMessageResponse = client.SendMessage(queueUrl, message);
}
public SqsActor ()
{
Receive<string> (x => {
var sqs_url = Environment.GetEnvironmentVariable("sqs_url", EnvironmentVariableTarget.Process);
var config = new AmazonSQSConfig();
config.ServiceURL = sqs_url;
var creds = new StoredProfileAWSCredentials();
var client = new AmazonSQSClient(creds, config);
var msg = x + " and what " + Guid.NewGuid().ToString();
var queue_url = Environment.GetEnvironmentVariable("queue_url", EnvironmentVariableTarget.Process);
var request = new Amazon.SQS.Model.SendMessageRequest(queue_url, msg);
client.SendMessage(request);
Sender.Tell(string.Format("done : [{0}]", msg ));
});
}
public void When_obtaining_details_on_a_message_queue(string queueName, bool exists)
{
// Arrange
var client = new AmazonSQSClient("access key", "secret key");
if (exists)
{
client.CreateQueue(new CreateQueueRequest().WithQueueName(queueName));
}
else
{
var response = client.ListQueues(new ListQueuesRequest().WithQueueNamePrefix(queueName));
if (response.ListQueuesResult.QueueUrl.Any())
{
client.DeleteQueue(new DeleteQueueRequest().WithQueueUrl(response.ListQueuesResult.QueueUrl.First()));
}
}
Thread.Sleep(2000); // Give the queues some time to spin up
var factory = new AmazonSqsMessageQueueDetailFactory(client);
// Act
var result = factory.Build<TestMessage>(queueName);
// Assert
Assert.That(result.Uri, Is.StringContaining(queueName));
Assert.That(result.Exists, Is.EqualTo(exists));
}
public static void DeleteQueueByQueueUrl(string queueUrl)
{
using (var client = new AmazonSQSClient(Settings.AccessKey, Settings.Secret))
{
client.DeleteQueue(queueUrl);
}
}
static void Main()
{
_awsConfig = AwsConfig.Read();
_client = _awsConfig.CreateSQSClient();
Console.WriteLine("Monitoring....");
Console.WriteLine("Press Ctrl+C to stop");
while (true)
{
Console.WriteLine("Checking");
var receivedMessage = Receive();
if (receivedMessage != null)
{
Console.WriteLine("Sending email");
Console.WriteLine(" From: " + receivedMessage.Email.From);
Console.WriteLine(" To: " + receivedMessage.Email.To);
Console.WriteLine(" Subject: " + receivedMessage.Email.Subject);
//Send email
Console.WriteLine("Email sent");
DeleteMessageFromQueue(receivedMessage.ReceiptHandle);
Console.WriteLine("Removed from queue");
}
Thread.Sleep(1000);
}
}
public async Task SendAsync(string message, CancellationToken token)
{
// Console.WriteLine("Sending messages:");
using (var client = new Amazon.SQS.AmazonSQSClient(accessKey, secretKey, region))
{
var queueUrlResult = await client.GetQueueUrlAsync(queueName, token);
var queueUrl = queueUrlResult.QueueUrl;
var req = new SendMessageRequest(queueUrl, message);
if (isFIFO)
{
// required
req.MessageGroupId = "group";
req.MessageDeduplicationId = message;
}
req.MessageAttributes.Add("CorrelationID", new MessageAttributeValue()
{
DataType = "string",
StringValue = Guid.NewGuid().ToString()
});
//req.DelaySeconds = 10;
var r = await client.SendMessageAsync(req);
Console.WriteLine("[" + DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss.fff") + "] [P] " + message + " | " + r.MessageId);
}
}
public SQSHandeler(BasicAWSCredentials amazonCredentials, AmazonSQSClient sqsClient)
{
if (amazonCredentials != null && sqsClient != null) {
this.amazonCredentials = amazonCredentials;
this.sqsClient = sqsClient;
}
}
public Queue(string queueName, int visibilityTimeout, bool deleteMessageDefault)
{
_client = GetClient();
_queueName = queueName;
_deleteMessageDefault = deleteMessageDefault;
#region Initialize Queue
QueueResult openResult = OpenQueue();
if (openResult.Success)
{
QueueResult visibilityResult = SetVisibilityAttribute(visibilityTimeout);
if (!visibilityResult.Success)
{
throw new Exception(visibilityResult.ErrorMessage, visibilityResult.Exception);
}
}
else
{
throw new Exception(openResult.ErrorMessage, openResult.Exception);
}
#endregion
}
static void Main(string[] args)
{
_awsConfig = AwsConfig.Read();
_client = _awsConfig.CreateSQSClient();
Console.Write("What would you like to call your queue? ");
var queueName = Console.ReadLine().Trim();
Console.Write("What is the ARN of your dead letter queue (Hit return for no dead letter queue)?");
var deadLetterQueueName = Console.ReadLine().Trim();
try
{
var deadLetterQueueArn = string.IsNullOrEmpty(deadLetterQueueName) ? null : LookupDeadLetterQueueArn(deadLetterQueueName);
var newQueueUrl = CreateQueue(queueName, deadLetterQueueArn);
Console.WriteLine("New queue url is " + newQueueUrl);
}
catch(Exception ex)
{
Console.WriteLine("ERROR: " + ex.Message);
}
Console.WriteLine();
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
public async Task ConsumeAsync(int maxMessages = 5, CancellationToken token = default)
{
Console.WriteLine("\nConsuming messages:");
using (var client = new Amazon.SQS.AmazonSQSClient(accessKey, secretKey, region))
{
var queueUrlResult = await client.GetQueueUrlAsync(queueName, token);
var queueUrl = queueUrlResult.QueueUrl;
while (true)
{
/// Console.WriteLine("Fetching messages:");
var req = new ReceiveMessageRequest(queueUrl);
req.WaitTimeSeconds = 20; // long pooling
req.MaxNumberOfMessages = maxMessages;
var r = await client.ReceiveMessageAsync(req, token);
if (r.Messages.Count > 0)
{
foreach (var m in r.Messages)
{
Console.WriteLine("[" + DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss.fff") + "] [C] " + m.Body + " | " + m.MessageId);
// ack
await client.DeleteMessageAsync(queueUrl, m.ReceiptHandle);
}
}
}
}
}
public async Task<Amazon.SQS.Model.Message> GetMessage(string queueName, int timeoutInMilliseconds, int numberOfCacheableMessages)
{
Amazon.SQS.Model.Message message = null;
if (_queue.ContainsKey(queueName) && _queue[queueName].TryDequeue(out message)) return message;
var request = new ReceiveMessageRequest(queueName)
{
MaxNumberOfMessages = numberOfCacheableMessages,
WaitTimeSeconds = (int)TimeSpan.FromMilliseconds(timeoutInMilliseconds).TotalSeconds
};
using (var client = new AmazonSQSClient(_credentials))
{
var response = await client.ReceiveMessageAsync(request);
if (response.HttpStatusCode != HttpStatusCode.OK) return message;
if (response.ContentLength == 0) return message;
if (!response.Messages.Any()) return message;
AddToQueue(queueName, response.Messages);
if(_queue.ContainsKey(queueName))
_queue[queueName].TryDequeue(out message);
}
return message;
}
private void InitAmazonData() {
sqsHandeler = new SQSHandeler(amazonCredentials, sqsClient);
if (sqsHandeler.AmazonCredentials != null
&& sqsHandeler.SQSClient != null) {
amazonCredentials = sqsHandeler.AmazonCredentials;
sqsClient = sqsHandeler.SQSClient;
}
}
public virtual void DeleteQueue(AmazonSQSClient sqsClient, string queueUrl)
{
var deleteQueueRequest = new DeleteQueueRequest
{
QueueUrl = queueUrl
};
// Delete the queue
sqsClient.DeleteQueue(deleteQueueRequest);
}
public override void ViewDidLoad ()
{
base.ViewDidLoad ();
CreateQueue.TouchUpInside += delegate(object sender, EventArgs e) {
var sqsClient = new Amazon.SQS.AmazonSQSClient (ACCESS_KEY, SECRET_KEY, Amazon.RegionEndpoint.EUWest1);
var request = new Amazon.SQS.Model.CreateQueueRequest ();
request.QueueName = "newQueue";
var response = sqsClient.CreateQueue (request);
CreateQueueResults.Text = String.Format("Queue created at {0}.", response.QueueUrl);
};
}
public static string CreateQueue(string name)
{
using (var client = new AmazonSQSClient(Settings.AccessKey, Settings.Secret))
{
var request = new CreateQueueRequest
{
QueueName = name
};
var response = client.CreateQueue(request);
return response.QueueUrl;
}
}
public static void DeleteAllQueues()
{
using (var client = new AmazonSQSClient(Settings.AccessKey, Settings.Secret))
{
var response = client.ListQueues(new ListQueuesRequest());
foreach (var queueUrl in response.QueueUrls)
{
PurgeQueueByQueueUrl(queueUrl);
client.DeleteQueue(queueUrl);
}
}
}
static void Main(string[] args)
{
// AWS: Get instance public address
string myId = "localhost";
try
{
myId = Encoding.ASCII.GetString(new WebClient().DownloadData("http://169.254.169.254/latest/meta-data/public-hostname"));
}
catch
{
}
// AWS SQS Client
var sqsClient = new AmazonSQSClient();
while (true)
{
// Get the next message
ReceiveMessageRequest request = new ReceiveMessageRequest()
.WithQueueUrl("https://queue.amazonaws.com/*****/codeCampDemo")
.WithMaxNumberOfMessages(1);
var response = sqsClient.ReceiveMessage(request);
foreach (var retrievedMessage in response.ReceiveMessageResult.Message)
{
var messageJson = JsonValue.Parse(retrievedMessage.Body);
var message = messageJson["message"].ReadAs<string>();
Console.WriteLine(message);
message = "Echo: " + message;
string address = string.Format("http://{0}", messageJson["sender"].ReadAs<string>());
var connection = new HubConnection(address);
connection.Start().Wait();
IHubProxy pongHub = connection.CreateProxy("MvcWebRole1.Hubs.EchoHub");
pongHub.Invoke("DoUpdateMessage", message, myId).Wait();
//Process the message and then delete the message
DeleteMessageRequest deleteRequest = new DeleteMessageRequest()
.WithQueueUrl("https://queue.amazonaws.com/******/codeCampDemo")
.WithReceiptHandle(retrievedMessage.ReceiptHandle);
sqsClient.DeleteMessage(deleteRequest);
}
Thread.Sleep(1000);
}
}
public virtual string CreateQueue(AmazonSQSClient sqsClient, string queueName)
{
string queueUrl;
// Create the request
var createQueueRequest = new CreateQueueRequest {QueueName = queueName};
// Submit the request
CreateQueueResponse createQueueResponse = sqsClient.CreateQueue(createQueueRequest);
// Return the URL for the newly created queue
queueUrl = createQueueResponse.QueueUrl;
return queueUrl;
}
public void Messages_are_queued()
{
var client = new AmazonSQSClient(ConfigurationManager.AppSettings["AWSKey"], ConfigurationManager.AppSettings["AWSSecret"]);
var queue = Guid.NewGuid().ToString();
var consumer = new SimpleQueueConsumer<StringEvent>(client, queue);
var block = new AutoResetEvent(false);
var producer = new ObservingProducer<StringEvent>();
producer.Attach(consumer);
producer.Produces(GetPayload().ToObservable());
producer.Start();
block.WaitOne(TimeSpan.FromSeconds(5));
client.DeleteQueue(new DeleteQueueRequest().WithQueueUrl(consumer.QueueUrl));
}
static void ReadFromQueue(AWSCredentials credentials)
{
AmazonSQSClient client = new AmazonSQSClient(credentials, RegionEndpoint.USEast1);
string queueUrl = "https://sqs.us-east-1.amazonaws.com/025631894481/aws-talk";
ReceiveMessageRequest request = new ReceiveMessageRequest(queueUrl);
request.MaxNumberOfMessages = 1;
ReceiveMessageResponse response = client.ReceiveMessage(request);
foreach (var message in response.Messages)
{
// Do something with the message
}
}
private static async Task MainAsync(string[] args)
{
var sqsClient = new Amazon.SQS.AmazonSQSClient();
for (var idx = 0; idx <= 50000; idx++)
{
Console.WriteLine(String.Format("BATCH No.: {0}", idx));
var sendMessageBatchRequest = new SendMessageBatchRequest
{
Entries = generateMessages(),
QueueUrl = "https://sqs.eu-west-1.amazonaws.com/655379451354/4developers_queue"
};
var resonse = await sqsClient.SendMessageBatchAsync(sendMessageBatchRequest);
}
}
/// <summary>
/// Creates the SQS queue. If the queue already exists, the existing URL is returned.
/// </summary>
/// <param name="awsCredentials">The AWS credentials for access the queue.</param>
/// <returns>System.String.</returns>
/// <exception cref="System.InvalidOperationException">Unable to create SQS queue</exception>
private string GetSqsQueueUrl(AWSCredentials awsCredentials)
{
Logger.LogDebug($"Getting SQS Queue: {AwsSettings.Sqs.Name}");
Logger.LogDebug($"Using AWS Region: {AwsSettings.Sqs.Region}");
sqsClient = new SQS.AmazonSQSClient(awsCredentials, RegionEndpoint.GetBySystemName(AwsSettings.Sqs.Region));
var queueUrlResponse = AsyncTaskHelper.RunSync(() => sqsClient.GetQueueUrlAsync(AwsSettings.Sqs.Name));
Logger.LogTrace($"SQS Queue Response[Status:{queueUrlResponse.HttpStatusCode}], [QueueUrl:{queueUrlResponse.QueueUrl}]");
if (queueUrlResponse.HttpStatusCode != HttpStatusCode.OK)
{
Logger.LogError($"Error getting SQS Queue. Status code: {queueUrlResponse.HttpStatusCode}. Aborting.");
throw new InvalidOperationException("Unable to open SQS queue");
}
return(queueUrlResponse.QueueUrl);
}
// TODO: Get/set these values from namespace Common program.cs file instead
public void Main(string[] args) {
InitUserData();
InitAmazonData();
InitPeasantTasks();
queueURL = sqsHandeler.QueueURL;
amazonCredentials = new BasicAWSCredentials(userID, userKey);
sqsClient = new AmazonSQSClient(amazonCredentials, RegionEndpoint.USEast1);
Console.Write("Greetings, overlord!\n\n> How many tasks must"
+ " be given to these lowly peasants? ");
var userMsg = Console.ReadLine();
var numPeasantTasks = ParseUserMsg(userMsg);
for (var i = 0; i < numPeasantTasks; i++) {
var peasantTask = AssignTaskToPeasant();
peasantTask.Wait();
}
}
public void Messages_are_dequeued()
{
var block = new AutoResetEvent(false);
var sent = 10;
var received = 0;
var serializer = new JsonSerializer();
var key = ConfigurationManager.AppSettings["AWSKey"];
var secret = ConfigurationManager.AppSettings["AWSSecret"];
var queueName = Guid.NewGuid().ToString();
var client = new AmazonSQSClient(key, secret);
// Anything put into the queue will go to Amazon SQS
var queue = new ConcurrentQueue<StringEvent>();
var consumer = new SimpleQueueConsumer<StringEvent>(client, queueName);
new CollectionProducer<StringEvent>(queue).Consumes(consumer).Start();
// Anything taken from Amazon SQS goes to the console
new SimpleQueueProducer<StringEvent>(client, queueName, serializer).Consumes(new DelegatingConsumer<StringEvent>(@event =>
{
Console.WriteLine(@event.Text);
received++;
if (received >= sent)
{
block.Set();
}
})).Start();
// Make some messages
queue.Enqueue(new StringEvent("Test1"));
queue.Enqueue(new StringEvent("Test2"));
queue.Enqueue(new StringEvent("Test3"));
queue.Enqueue(new StringEvent("Test4"));
queue.Enqueue(new StringEvent("Test5"));
queue.Enqueue(new StringEvent("Test6"));
queue.Enqueue(new StringEvent("Test7"));
queue.Enqueue(new StringEvent("Test8"));
queue.Enqueue(new StringEvent("Test9"));
queue.Enqueue(new StringEvent("Test10"));
block.WaitOne();
client.DeleteQueue(new DeleteQueueRequest().WithQueueUrl(consumer.QueueUrl));
}
/// <summary>
/// Constructor taking the landing zone
/// </summary>
public DataRouterReportQueue(string InQueueName, string InLandingZoneTempPath, int InDecimateWaitingCountStart, int InDecimateWaitingCountEnd)
: base(InQueueName, InLandingZoneTempPath, InDecimateWaitingCountStart, InDecimateWaitingCountEnd)
{
AWSCredentials Credentials = new StoredProfileAWSCredentials(Config.Default.AWSProfileName, Config.Default.AWSCredentialsFilepath);
AmazonSQSConfig SqsConfig = new AmazonSQSConfig
{
ServiceURL = Config.Default.AWSSQSServiceURL
};
SqsClient = new AmazonSQSClient(Credentials, SqsConfig);
AmazonS3Config S3Config = new AmazonS3Config
{
ServiceURL = Config.Default.AWSS3ServiceURL
};
S3Client = new AmazonS3Client(Credentials, S3Config);
}
public static void SQSReceiveMessage()
{
#region SQSReceiveMessage
var client = new AmazonSQSClient();
var request = new ReceiveMessageRequest
{
AttributeNames = new List<string>() { "All" },
MaxNumberOfMessages = 5,
QueueUrl = "https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyTestQueue",
VisibilityTimeout = (int)TimeSpan.FromMinutes(10).TotalSeconds,
WaitTimeSeconds = (int)TimeSpan.FromSeconds(5).TotalSeconds
};
var response = client.ReceiveMessage(request);
if (response.Messages.Count > 0)
{
foreach (var message in response.Messages)
{
Console.WriteLine("For message ID '" + message.MessageId + "':");
Console.WriteLine(" Body: " + message.Body);
Console.WriteLine(" Receipt handle: " + message.ReceiptHandle);
Console.WriteLine(" MD5 of body: " + message.MD5OfBody);
Console.WriteLine(" MD5 of message attributes: " +
message.MD5OfMessageAttributes);
Console.WriteLine(" Attributes:");
foreach (var attr in message.Attributes)
{
Console.WriteLine(" " + attr.Key + ": " + attr.Value);
}
}
}
else
{
Console.WriteLine("No messages received.");
}
#endregion
Console.ReadLine();
}
public void DoWork()
{
var credentials = new BasicAWSCredentials(ConfigurationManager.AppSettings["AccessKey"], ConfigurationManager.AppSettings["SecretKey"]);
_sqsClient = new AmazonSQSClient(credentials, RegionEndpoint.EUWest1);
var running = true;
while (running)
{
Console.WriteLine("Message to send: ");
var message = Console.ReadLine();
if (message == "end")
{
running = false;
}
else
{
AddToQueue(message);
}
}
}
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
// Set our view from the "main" layout resource
SetContentView (Resource.Layout.Main);
// Get our button from the layout resource,
// and attach an event to it
Button button = FindViewById<Button> (Resource.Id.createQueue);
EditText createQueueResult = FindViewById<EditText> (Resource.Id.createQueueResult);
button.Click += delegate {
var sqsClient = new Amazon.SQS.AmazonSQSClient (ACCESS_KEY, SECRET_KEY, Amazon.RegionEndpoint.EUWest1);
var request = new Amazon.SQS.Model.CreateQueueRequest ();
request.QueueName = "newQueue";
var response = sqsClient.CreateQueue (request);
createQueueResult.Text = String.Format("Queue created at {0}.", response.QueueUrl);
};
}
public static int Main(string[] args)
{
string awsAccessKeyId, awsSecretAccessKey;
try
{
System.Configuration.AppSettingsReader settings = new System.Configuration.AppSettingsReader();
awsAccessKeyId = (string)settings.GetValue("AwsAccessKeyId", typeof(string));
awsSecretAccessKey = (string)settings.GetValue("AwsSecretAccessKey", typeof(string));
}
catch (InvalidOperationException)
{
Console.Error.WriteLine("Could not read AwsAccessKeyId or AwsSecretAccessKey from the configuration.");
return 1;
}
AmazonSQS sqs = new AmazonSQSClient(awsAccessKeyId, awsSecretAccessKey);
FindOrCreateSQSQueue(sqs);
Console.WriteLine ("Hello World!");
return 0;
}
/// <summary>
/// Ensure sqs queue creation
/// </summary>
/// <param name="snsTopicArn">Subscribe to a sns topic</param>
/// <returns></returns>
public async Task EnsureQueueCreationAsync(string snsTopicArn = null)
{
// an integer representing seconds, from 60 (1 minute) to 1,209,600 (14 days). Default: 345,600 (4 days).
var messageRetentionPeriod = "1209600";
using (var client = new Amazon.SQS.AmazonSQSClient(accessKey, secretKey, region))
{
// dead letter queue
var req = new CreateQueueRequest("dead-" + queueName);
req.Attributes.Add(QueueAttributeName.MessageRetentionPeriod, messageRetentionPeriod);
if (isFIFO)
{
req.Attributes.Add(QueueAttributeName.FifoQueue, "true");
}
var r = await client.CreateQueueAsync(req);
string deadQueueArn = r.QueueUrl
.Replace("https://sqs.", "arn:aws:sqs:")
.Replace(".amazonaws.com", "")
.Replace("/", ":");
// queue
req = new CreateQueueRequest(queueName);
req.Attributes.Add(QueueAttributeName.MessageRetentionPeriod, messageRetentionPeriod);
req.Attributes.Add(QueueAttributeName.RedrivePolicy, "{\"maxReceiveCount\":3, \"deadLetterTargetArn\": \"" + deadQueueArn + "\"}");
if (isFIFO)
{
req.Attributes.Add(QueueAttributeName.FifoQueue, "true");
}
r = await client.CreateQueueAsync(req);
// subscribe to sns topic
if (!string.IsNullOrEmpty(snsTopicArn))
{
await notificationService.SubscribeSQS(snsTopicArn, client, r.QueueUrl);
}
}
}
public void Acknowledge(Message message)
{
if(!message.Header.Bag.ContainsKey("ReceiptHandle"))
return;
var receiptHandle = message.Header.Bag["ReceiptHandle"].ToString();
try
{
using (var client = new AmazonSQSClient())
{
client.DeleteMessageAsync(new DeleteMessageRequest(_queueUrl, receiptHandle));
_logger.InfoFormat("SqsMessageConsumer: Deleted the message {0} with receipt handle {1} on the queue {2}", message.Id, receiptHandle, _queueUrl);
}
}
catch (Exception exception)
{
_logger.ErrorException("SqsMessageConsumer: Error during deleting the message {0} with receipt handle {1} on the queue {2}", exception, message.Id, receiptHandle, _queueUrl);
throw;
}
}
/// <summary>
///
/// </summary>
/// <param name="messages"></param>
/// <param name="token"></param>
/// <returns></returns>
public async Task SendBatchAsync(string[] messages, CancellationToken token)
{
Console.WriteLine(string.Format("Sending {0} messages: ", messages.Length));
using (var client = new Amazon.SQS.AmazonSQSClient(accessKey, secretKey, region))
{
var queueUrlResult = await client.GetQueueUrlAsync(queueName, token);
var queueUrl = queueUrlResult.QueueUrl;
var entries = new List <SendMessageBatchRequestEntry>();
foreach (var message in messages)
{
var req = new SendMessageBatchRequestEntry(Guid.NewGuid().ToString(), message);
if (isFIFO)
{
// required
req.MessageGroupId = "group"; // fifo atua sobre o grupo
req.MessageDeduplicationId = Guid.NewGuid().ToString();
}
entries.Add(req);
}
var batch = new SendMessageBatchRequest(queueUrl, entries);
var r = await client.SendMessageBatchAsync(batch);
if (r.Failed != null && r.Failed.Count > 0)
{
foreach (var f in r.Failed)
{
Console.WriteLine("Failed : ", f.Message);
}
}
}
}
public void DoWork()
{
var credentials = new BasicAWSCredentials(ConfigurationManager.AppSettings["AccessKey"], ConfigurationManager.AppSettings["SecretKey"]);
_sqsClient = new AmazonSQSClient(credentials, RegionEndpoint.EUWest1);
Console.WriteLine("Number of messages at once");
int numberOfMessages;
int.TryParse(Console.ReadLine(), out numberOfMessages);
var running = true;
while (running)
{
var messageList = GetMessageFromQueue(numberOfMessages);
Console.WriteLine("Number of messages: " + messageList.Count);
if (messageList.Count == 0)
{
Thread.Sleep(5000);
}
Console.WriteLine();
foreach (var message in messageList)
{
Console.WriteLine("Message: " + message.Body);
Console.WriteLine("Receipt Handle: " + message.ReceiptHandle);
Console.WriteLine("Delete?");
var readLine = Console.ReadLine();
var delete = readLine != null ? readLine.ToLower() : "n";
if (delete == "y")
{
DeleteMessageFromQueue(message.ReceiptHandle);
}
}
}
}
