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); } } } }