static async Task Main() { Console.Title = "Sqs.Delayed.Tests"; Console.WriteLine("Purging queues"); var client = new AmazonSQSClient(); try { var inputQueue = await client.GetQueueUrlAsync("Sqs-Delayed-Tests"); await client.PurgeQueueAsync(inputQueue.QueueUrl); } catch (QueueDoesNotExistException) { } try { var delayedQueue = await client.GetQueueUrlAsync("Sqs-Delayed-Tests-delay.fifo"); await client.PurgeQueueAsync(delayedQueue.QueueUrl); } catch (QueueDoesNotExistException) { } Console.WriteLine("Queues purged."); var endpointConfiguration = new EndpointConfiguration("Sqs.Delayed.Tests"); var transport = endpointConfiguration.UseTransport <SqsTransport>(); transport.S3("nservicebus-sqs-delayed", "sqs-delayed"); transport.UnrestrictedDurationDelayedDelivery(); endpointConfiguration.SendFailedMessagesTo("error"); endpointConfiguration.EnableInstallers(); endpointConfiguration.UsePersistence <InMemoryPersistence>(); var endpointInstance = await Endpoint.Start(endpointConfiguration) .ConfigureAwait(false); var cts = new CancellationTokenSource(TimeSpan.FromHours(1)); var syncher = new TaskCompletionSource <bool>(); var sendTask = Task.Run(() => Sending(endpointInstance, cts.Token, syncher), CancellationToken.None); var checkTask = Task.Run(() => DumpCurrentState(cts.Token), CancellationToken.None); await Task.WhenAll(sendTask, checkTask); await CheckState(syncher); await endpointInstance.Stop() .ConfigureAwait(false); Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
private async Task InitAsync() { if (_didInit) { return; } var blockIpQueue = await _client.GetQueueUrlAsync("block-ip"); _blockIpQueueUrl = blockIpQueue.QueueUrl; var unblockIpQueue = await _client.GetQueueUrlAsync("unblock-ip"); _unblockIpQueueUrl = unblockIpQueue.QueueUrl; _didInit = true; }
public void OnMessageReceived(object sender, OnMessageReceivedArgs e) { var message = e.ChatMessage.Message; #if DEBUG if (message.StartsWith('%')) { Task.Run(async() => { _client.SendMessage(e.ChatMessage.Channel, "Hey, got your message"); using var sqsClient = new AmazonSQSClient(); var queueResponse = await sqsClient.GetQueueUrlAsync(new GetQueueUrlRequest { QueueName = "ReqeustQueue", }); await sqsClient.SendMessageAsync(new SendMessageRequest { QueueUrl = queueResponse.QueueUrl, MessageBody = e.ToJsonString(), MessageAttributes = new Dictionary <string, MessageAttributeValue> { { "EventType", new MessageAttributeValue { DataType = "String", StringValue = "TicketsCommand" } } } }); }); } #else throw new NotImplementedException("Not ready for release") #endif }
public async Task TestCreateQueueAsync() { queueName = setQueueName(); // Check if any queue is already created var sqsQueueList = await sqsClient.ListQueuesAsync(prefix); Assert.IsFalse(sqsQueueList.QueueUrls.Count >= 1, "There is something in the queue already"); // Create the queue CreateQueueResponse createResponse = await sqsClient.CreateQueueAsync(queueName); // Get the queue list. Assert is added to make sure that the queue is created and make sure that we only create 1 queue sqsQueueList = await sqsClient.ListQueuesAsync(prefix); Assert.IsTrue(sqsQueueList.QueueUrls.Count == 1, "Queue is not created or more than one queue is created"); // Verify the queue list contains the queue name created before Assert.IsTrue(sqsQueueList.QueueUrls[0].Contains(queueName), "Queue name is not the same"); // Verify the response created from when creating the queue is the same as the one we get from get queue URL var request = new GetQueueUrlRequest(queueName); var response = sqsClient.GetQueueUrlAsync(request); Assert.AreEqual(createResponse.QueueUrl, response.Result.QueueUrl, "The queue URL is not the same"); }
static void Main(string[] args) { var sqs = new AmazonSQSClient(RegionEndpoint.APSouth1); var queueUrl = sqs.GetQueueUrlAsync("EmailQueue").Result.QueueUrl; var receiveMessageRequest = new ReceiveMessageRequest { QueueUrl = queueUrl }; var receiveMessageResponse = sqs.ReceiveMessageAsync(receiveMessageRequest).Result; foreach (var message in receiveMessageResponse.Messages) { Console.WriteLine("Message \n"); Console.WriteLine($"Message id {message.MessageId} \n"); Console.WriteLine($"RecepientHandle {message.ReceiptHandle} \n"); Console.WriteLine($"MSD5Body {message.MD5OfBody} \n"); Console.WriteLine($" Body {message.Body} \n"); foreach (var attribute in message.Attributes) { Console.WriteLine("Attributes \n"); Console.WriteLine($"Name {attribute.Key} \n"); Console.WriteLine($"Value {attribute.Value} \n"); } var messageReceiptHandle = receiveMessageResponse.Messages.FirstOrDefault()?.ReceiptHandle; var deleteRequest = new DeleteMessageRequest { QueueUrl = queueUrl, ReceiptHandle = messageReceiptHandle }; sqs.DeleteMessageAsync(deleteRequest); Console.ReadLine(); } }
/// <summary> /// initialize queue's for use /// </summary> /// <param name="sqsClient"></param> /// <param name="queueName"></param> /// <returns></returns> public static string GetOrCreateQueue(AmazonSQSClient sqsClient, string queueName) { queueName = queueName.ToLowerInvariant(); string returnValue; if (!_QueueUrls.TryGetValue(queueName, out returnValue)) { GetQueueUrlResponse respQueueUrl = null; try { respQueueUrl = sqsClient.GetQueueUrlAsync(queueName).Result; } catch { respQueueUrl = null; } if (null == respQueueUrl || HttpStatusCode.OK != respQueueUrl.HttpStatusCode) { CreateQueueResponse respQueueCreate = sqsClient.CreateQueueAsync(queueName).Result; if (HttpStatusCode.OK != respQueueCreate.HttpStatusCode) { throw new ApplicationException("Unexpected result creating SQS: " + respQueueCreate.HttpStatusCode); } returnValue = respQueueCreate.QueueUrl; } else { returnValue = respQueueUrl.QueueUrl; } _QueueUrls[queueName] = returnValue; } return(returnValue); }
/// <summary> /// Requeues the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="delayMilliseconds">Number of milliseconds to delay delivery of the message.</param> /// <returns>True if the message was requeued successfully</returns> public bool Requeue(Message message, int delayMilliseconds) { if (!message.Header.Bag.ContainsKey("ReceiptHandle")) { return(false); } var receiptHandle = message.Header.Bag["ReceiptHandle"].ToString(); try { s_logger.LogInformation("SqsMessageConsumer: re-queueing the message {Id}", message.Id); using (var client = new AmazonSQSClient(_awsConnection.Credentials, _awsConnection.Region)) { var urlResponse = client.GetQueueUrlAsync(_queueName).Result; client.ChangeMessageVisibilityAsync(new ChangeMessageVisibilityRequest(urlResponse.QueueUrl, receiptHandle, 0)).Wait(); } s_logger.LogInformation("SqsMessageConsumer: re-queued the message {Id}", message.Id); return(true); } catch (Exception exception) { s_logger.LogError(exception, "SqsMessageConsumer: Error during re-queueing the message {Id} with receipt handle {ReceiptHandle} on the queue {ChannelName}", message.Id, receiptHandle, _queueName); return(false); } }
private string getQueueUrl(string queueName) { GetQueueUrlResponse s = null; string result = string.Empty; try { GetQueueUrlRequest urlQueueRequest = new GetQueueUrlRequest { QueueName = queueName }; try { s = amazonSQSClient.GetQueueUrlAsync(urlQueueRequest).Result; } catch (System.AggregateException) { return(createQueue(queueName)); } if (s.QueueUrl.Any()) { return(s.QueueUrl); } else { return(createQueue(queueName)); } } catch (Exception e) { throw new Exception(e.Message); } }
private (bool, string) QueueExists(AmazonSQSClient client, string channelName) { bool exists = false; string queueUrl = null; try { var response = client.GetQueueUrlAsync(channelName).Result; //If the queue does not exist yet then if (!string.IsNullOrWhiteSpace(response.QueueUrl)) { queueUrl = response.QueueUrl; exists = true; } } catch (AggregateException ae) { ae.Handle((e) => { if (e is QueueDoesNotExistException) { //handle this, because we expect a queue might be missing and will create exists = false; return(true); } //we didn't expect this return(false); }); } return(exists, queueUrl); }
/// <summary> /// Requeues the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="delayMilliseconds">Number of milliseconds to delay delivery of the message.</param> public void Requeue(Message message, int delayMilliseconds) { if (!message.Header.Bag.ContainsKey("ReceiptHandle")) { return; } var receiptHandle = message.Header.Bag["ReceiptHandle"].ToString(); try { _logger.Value.InfoFormat("SqsMessageConsumer: requeueing the message {0}", message.Id); using (var client = new AmazonSQSClient(_awsConnection.Credentials, _awsConnection.Region)) { var urlResponse = client.GetQueueUrlAsync(_queueName).Result; client.ChangeMessageVisibilityAsync(new ChangeMessageVisibilityRequest(urlResponse.QueueUrl, receiptHandle, 0)).Wait(); } _logger.Value.InfoFormat("SqsMessageConsumer: requeued the message {0}", message.Id); } catch (Exception exception) { _logger.Value.ErrorException("SqsMessageConsumer: Error during requeing the message {0} with receipt handle {1} on the queue {2}", exception, message.Id, receiptHandle, _queueName); throw; } }
async Task ConfigureLambdaWithQueueAsync(string queueName) { string queueArn = null; AmazonSQSClient sqsClient = AwsFactory.CreateClient <AmazonSQSClient>(); GetQueueUrlRequest queueUrlReq = new GetQueueUrlRequest(); queueUrlReq.QueueName = queueName; GetQueueUrlResponse getQueueUrlResp = await sqsClient.GetQueueUrlAsync(queueUrlReq); GetQueueAttributesRequest queueAttribReq = new GetQueueAttributesRequest(); queueAttribReq.AttributeNames.Add(QueueAttributeName.QueueArn); queueAttribReq.QueueUrl = getQueueUrlResp.QueueUrl; var queueAttribResp = await sqsClient.GetQueueAttributesAsync(queueAttribReq); queueArn = queueAttribResp.QueueARN; AmazonLambdaClient lambdaClient = AwsFactory.CreateClient <AmazonLambdaClient>(); CreateEventSourceMappingRequest eventMappingReq = new CreateEventSourceMappingRequest(); eventMappingReq.FunctionName = "WebhookDispatcher"; eventMappingReq.BatchSize = 10; eventMappingReq.Enabled = true; eventMappingReq.EventSourceArn = queueArn; await lambdaClient.CreateEventSourceMappingAsync(eventMappingReq); }
static async Task PushToSQS(IClient client, string accountId) { var source = new CancellationTokenSource(); var sqsClient = new AmazonSQSClient(RegionEndpoint.USEast1); var urlRequest = new GetQueueUrlRequest { QueueName = AWSConstructs.Names.FroniusIngressQueue, QueueOwnerAWSAccountId = accountId }; var url = (await sqsClient.GetQueueUrlAsync(urlRequest))?.QueueUrl; if (url == null) { throw new Exception($"Failed to get SQS URL for: {JsonSerializer.Serialize(urlRequest)}"); } Response?dataLast = null; while (true) { var data = await client.GetPowerFlowRealtimeData(source.Token); if (data?.Head.Timestamp == dataLast?.Head.Timestamp) { await Task.Delay(10); continue; } var dataJson = JsonSerializer.Serialize(data); var message = new SendMessageRequest(url, dataJson); var response = await sqsClient.SendMessageAsync(message); Console.WriteLine($"{response.HttpStatusCode} | {response.MessageId} | {dataJson}"); dataLast = data; } }
/// <summary> /// Rejects the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="requeue">if set to <c>true</c> [requeue].</param> public void Reject(Message message, bool requeue) { if (!message.Header.Bag.ContainsKey("ReceiptHandle")) return; var receiptHandle = message.Header.Bag["ReceiptHandle"].ToString(); try { _logger.Value.InfoFormat("SqsMessageConsumer: Rejecting the message {0} with receipt handle {1} on the queue {2} with requeue paramter {3}", message.Id, receiptHandle, _queueName, requeue); using (var client = new AmazonSQSClient(_connection.Credentials, _connection.Region)) { var urlResponse = client.GetQueueUrlAsync(_queueName).Result; if (requeue) { client.ChangeMessageVisibilityAsync(new ChangeMessageVisibilityRequest(urlResponse.QueueUrl, receiptHandle, 0)).Wait(); } else { client.DeleteMessageAsync(urlResponse.QueueUrl, receiptHandle).Wait(); } } _logger.Value.InfoFormat("SqsMessageConsumer: Message {0} with receipt handle {1} on the queue {2} with requeue paramter {3} has been rejected", message.Id, receiptHandle, _queueName, requeue); } catch (Exception exception) { _logger.Value.ErrorException("SqsMessageConsumer: Error during rejecting the message {0} with receipt handle {1} on the queue {2}", exception, message.Id, receiptHandle, _queueName); throw; } }
/// <summary> /// Acknowledges the specified message. /// </summary> /// <param name="message">The message.</param> 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(_awsConnection.Credentials, _awsConnection.Region)) { var urlResponse = client.GetQueueUrlAsync(_queueName).Result; client.DeleteMessageAsync(new DeleteMessageRequest(urlResponse.QueueUrl, receiptHandle)).Wait(); s_logger.LogInformation("SqsMessageConsumer: Deleted the message {Id} with receipt handle {ReceiptHandle} on the queue {URL}", message.Id, receiptHandle, urlResponse.QueueUrl); } } catch (Exception exception) { s_logger.LogError(exception, "SqsMessageConsumer: Error during deleting the message {Id} with receipt handle {ReceiptHandle} on the queue {ChannelName}", message.Id, receiptHandle, _queueName); throw; } }
/// <summary> /// Gets the URL for the queue from its name. /// </summary> /// <param name="queueName">The name of the queue</param> /// <returns></returns> private async Task <string> GetQueueUrlAsync(string queueName) { var request = new GetQueueUrlRequest(queueName); var response = await _client.GetQueueUrlAsync(request); return(response.QueueUrl); }
static void Main(string[] args) { Console.WriteLine("Initializing Amazon SQS Client and getting queue URL..."); var sqsClient = new AmazonSQSClient(); var getQueueUrlRequest = new GetQueueUrlRequest { QueueName = "DemoMasterWorkerPattern", QueueOwnerAWSAccountId = "545983628851" }; var getQueueUrlResponse = sqsClient.GetQueueUrlAsync(getQueueUrlRequest).Result; var queueUrl = getQueueUrlResponse.QueueUrl; Console.WriteLine($"Received Queue URL: {queueUrl}"); while (true) { Console.Write("Type a message to be sent to the queue or type 'exit' to quit: "); var message = Console.ReadLine(); if (string.Equals(message, "exit", StringComparison.OrdinalIgnoreCase)) { break; } Console.WriteLine($"Sending message with content '{message}' to the queue..."); var sendMessageRequest = new SendMessageRequest(); sendMessageRequest.QueueUrl = queueUrl; sendMessageRequest.MessageBody = message; var sendMessageResponse = sqsClient.SendMessageAsync(sendMessageRequest).Result; Console.WriteLine("Message has been sent."); Console.WriteLine($"HttpStatusCode: {sendMessageResponse.HttpStatusCode}"); } }
public int GetDLQCount(string queueName) { using (var sqsClient = new AmazonSQSClient(_awsConnection.Credentials, _awsConnection.Region)) { var queueUrlResponse = sqsClient.GetQueueUrlAsync(queueName).GetAwaiter().GetResult(); var response = sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest { QueueUrl = queueUrlResponse.QueueUrl, WaitTimeSeconds = 5, AttributeNames = new List <string> { "ApproximateReceiveCount" }, MessageAttributeNames = new List <string> { "All" } }).GetAwaiter().GetResult(); if (response.HttpStatusCode != HttpStatusCode.OK) { throw new AmazonSQSException($"Failed to GetMessagesAsync for queue {queueName}. Response: {response.HttpStatusCode}"); } return(response.Messages.Count); } }
bool IQueueClientService.SendMessage(AppointmentModel appointment, string operation) { IAmazonSQS sqs = new AmazonSQSClient(RegionEndpoint.USEast2); var queueUrl = sqs.GetQueueUrlAsync(Configuration.GetValue <string>("DASAppointmentsQueueName")).Result.QueueUrl; var message = new SQSMessageModel { Op = operation, Appointment = appointment }; var sqsMessageRequest = new SendMessageRequest { QueueUrl = queueUrl, MessageBody = JsonConvert.SerializeObject(message), MessageGroupId = "Appointments", //MessageDeduplicationId = Guid.NewGuid().ToString(), }; try { SendMessageResponse response = sqs.SendMessageAsync(sqsMessageRequest).Result; } catch (Exception ex) { throw ex; } return(true); }
public static string GetQueueUrl(string queueName) { using (IAmazonSQS sqs = new AmazonSQSClient(RegionEndpoint.USEast1)) { return(sqs.GetQueueUrlAsync(queueName).Result.QueueUrl); } }
/// <summary> /// Acknowledges the specified message. /// </summary> /// <param name="message">The message.</param> 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(_connection.Credentials, _connection.Region)) { var urlResponse = client.GetQueueUrlAsync(_queueName).Result; client.DeleteMessageAsync(new DeleteMessageRequest(urlResponse.QueueUrl, receiptHandle)); _logger.Value.InfoFormat("SqsMessageConsumer: Deleted the message {0} with receipt handle {1} on the queue {2}", message.Id, receiptHandle, urlResponse.QueueUrl); } } catch (Exception exception) { _logger.Value.ErrorException("SqsMessageConsumer: Error during deleting the message {0} with receipt handle {1} on the queue {2}", exception, message.Id, receiptHandle, _queueName); throw; } }
private static async Task GetQueueUrlAsync(AmazonSQSClient sqsClient) { var getQueueUrlRequest = new GetQueueUrlRequest { QueueName = SingleQueue }; var response1 = await sqsClient.GetQueueUrlAsync(getQueueUrlRequest); Console.WriteLine($"GetQueueUrlAsync(GetQueueUrlRequest) HTTP status code: {response1.HttpStatusCode}"); _singleQueueUrl = response1.QueueUrl; var response2 = await sqsClient.GetQueueUrlAsync(BatchedQueue); Console.WriteLine($"GetQueueUrlAsync(string) HTTP status code: {response2.HttpStatusCode}"); _batchedQueueUrl = response2.QueueUrl; }
public async Task SendMessage_HasMessageTypeAttributeAndBody() { //Arrange var queueName = Guid.NewGuid().ToString(); var firstMessage = new FirstMessage { Value = "value1" }; var secondMessage = new SecondMessage { Value = "value2" }; var thirdMessage = new ThirdMessage { Value = "value3" }; var sqsClient = new AmazonSQSClient( AppConfig.AccessKey, AppConfig.SecretKey, new AmazonSQSConfig { ServiceURL = AppConfig.ServiceUrl }); await sqsClient.CreateQueueAsync(queueName); var queueUrl = (await sqsClient.GetQueueUrlAsync(queueName)).QueueUrl; //Act await sqsClient.SendMessageAsync(queueUrl, firstMessage); await sqsClient.SendMessageAsync(queueUrl, secondMessage); await sqsClient.SendMessageAsync(queueUrl, thirdMessage, typeof(ThirdMessage)); var response = await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest { QueueUrl = queueUrl, MaxNumberOfMessages = 3, MessageAttributeNames = new List <string> { "All" } }); var messageTypes = response.Messages .Select(message => JsonConvert.DeserializeObject <MessageBody>(message.Body)) .Select(body => body.MessageAttributes.Single(pair => pair.Key == "MessageType").Value.Value) .ToList(); var messages = response.Messages .Select(message => JsonConvert.DeserializeObject <MessageBody>(message.Body)) .Select(body => body.Message) .ToArray(); //Assert new[] { nameof(FirstMessage), nameof(SecondMessage), nameof(ThirdMessage) } .ShouldAllBe(s => messageTypes.Contains(s)); new [] { firstMessage.Value, secondMessage.Value, thirdMessage.Value } .ShouldAllBe(s => messages.Any(m => m.Contains(s))); }
/// <summary> /// Creates the queue with the given name /// </summary> public void CreateQueue(string address) { m_log.Info("Creating queue {queueName} on region {regionEndpoint}", address, m_AmazonInternalSettings.AmazonSqsConfig.RegionEndpoint); var amazonSqsConfig = m_AmazonInternalSettings.AmazonSqsConfig; var awsCredentials = m_AmazonInternalSettings.AmazonCredentialsFactory.Create(); using (var client = new AmazonSQSClient(awsCredentials, amazonSqsConfig)) { var queueName = GetQueueNameFromAddress(address); // Check if queue exists try { var request = new GetQueueUrlRequest(queueName); // See http://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSGetQueueUrlRequest.html for options var getQueueUrlTask = client.GetQueueUrlAsync(request); AsyncHelpers.RunSync(() => getQueueUrlTask); var getQueueUrlResponse = getQueueUrlTask.Result; if (getQueueUrlResponse.HttpStatusCode != HttpStatusCode.OK) { throw new Exception($"Could not check for existing queue '{queueName}' - got HTTP {getQueueUrlResponse.HttpStatusCode}"); } var visibilityTimeout = ((int)m_AmazonInternalSettings.AmazonPeekLockDuration.PeekLockDuration.TotalSeconds).ToString(CultureInfo.InvariantCulture); // See http://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSSetQueueAttributesRequest.html for options var setAttributesTask = client.SetQueueAttributesAsync(getQueueUrlResponse.QueueUrl, new Dictionary <string, string> { ["VisibilityTimeout"] = visibilityTimeout }); AsyncHelpers.RunSync(() => setAttributesTask); var setAttributesResponse = setAttributesTask.Result; if (setAttributesResponse.HttpStatusCode != HttpStatusCode.OK) { throw new Exception($"Could not set attributes for queue '{queueName}' - got HTTP {setAttributesResponse.HttpStatusCode}"); } } catch (QueueDoesNotExistException) { // See http://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SQS/TSQSCreateQueueRequest.html for options var createQueueRequest = new CreateQueueRequest(queueName) { Attributes = { ["VisibilityTimeout"] = ((int)m_AmazonInternalSettings.AmazonPeekLockDuration.PeekLockDuration.TotalSeconds).ToString(CultureInfo.InvariantCulture) } }; var task = client.CreateQueueAsync(createQueueRequest); AsyncHelpers.RunSync(() => task); var response = task.Result; if (response.HttpStatusCode != HttpStatusCode.OK) { throw new Exception($"Could not create queue '{queueName}' - got HTTP {response.HttpStatusCode}"); } } } }
private async static void OnTimedEvent(object source, ElapsedEventArgs e) { var sqs = new AmazonSQSClient(RegionEndpoint.SAEast1); var queueUrl = sqs.GetQueueUrlAsync("BariMessagesQueue").Result.QueueUrl; var receiveMessageRequest = new ReceiveMessageRequest { QueueUrl = queueUrl, MaxNumberOfMessages = 10 }; Console.WriteLine("Checking for new messages in the queue BariMessagesQueue...\n"); var receiveMessageResponse = sqs.ReceiveMessageAsync(receiveMessageRequest).Result; var counter = receiveMessageResponse.Messages.Count; foreach (var message in receiveMessageResponse.Messages) { Console.WriteLine("Message \n"); Console.WriteLine($" MessageId: {message.MessageId} \n"); Console.WriteLine($" ReceiptHandle: {message.ReceiptHandle} \n"); Console.WriteLine($" MD5OfBody: {message.MD5OfBody} \n"); Console.WriteLine($" Body: {message.Body} \n"); foreach (var atribute in message.Attributes) { Console.WriteLine($" Key:{atribute.Key} "); Console.WriteLine($" Value:{atribute.Value} \n"); } Console.WriteLine($" Cleaning a Message in Queue... \n"); var messageReceptHandle = message.ReceiptHandle; var deleteResquest = new DeleteMessageRequest { QueueUrl = queueUrl, ReceiptHandle = messageReceptHandle }; await sqs.DeleteMessageAsync(deleteResquest); } if (counter == 0) { Console.WriteLine("There is no new messages.\n"); } else { Console.WriteLine($" {counter} New Messages Received. \n"); } }
private async Task <string> GetQueueUrl() { if (_queueUrl == null) { var response = await _client.GetQueueUrlAsync(_queueName); _queueUrl = response.QueueUrl; } return(_queueUrl); }
public async Task Listen() { IAmazonSQS sqs = new AmazonSQSClient(RegionEndpoint.USEast2); //var queueUrl = sqs.GetQueueUrlAsync(Configuration.GetValue<string>("DASAppointmentsQueueName")).Result.QueueUrl; var queueUrl = sqs.GetQueueUrlAsync(DASAppointmentsQueueName).Result.QueueUrl; //while (!stoppingToken.IsCancellationRequested) //{ try { var receiveMessageRequest = new ReceiveMessageRequest { QueueUrl = queueUrl }; var receiveMessageResponse = sqs.ReceiveMessageAsync(receiveMessageRequest).Result; foreach (var message in receiveMessageResponse.Messages) { var messageObj = JsonConvert.DeserializeObject <SQSMessageModel>(message.Body); if (messageObj.Op == "bookAppointment") { if (AppointmentStorageService.Book(messageObj.Appointment).Result) { await AppointmentOpLogStorageService.AddLogEntry(messageObj.Appointment, "book"); await ConflictsManager.CheckAndAddConflict(messageObj.Appointment); } } else { if (messageObj.Op == "cancelAppointment") { if (AppointmentStorageService.Cancel(messageObj.Appointment).Result) { await AppointmentOpLogStorageService.AddLogEntry(messageObj.Appointment, "cancel"); await ConflictsManager.RemoveConflicts(messageObj.Appointment); } } } var messageReceiveHandle = receiveMessageResponse.Messages.FirstOrDefault()?.ReceiptHandle; var deleteRequest = new DeleteMessageRequest { QueueUrl = queueUrl, ReceiptHandle = messageReceiveHandle }; await sqs.DeleteMessageAsync(deleteRequest); } } catch (Exception ex) { //await Task.Delay(TimeSpan.FromSeconds(3),stoppingToken); } //} }
public async Task SendMessageToForroLevelSQS(ForroLevel forroLevel) { var request = new GetQueueUrlRequest(_forroLevelQueueName); var response = await _amazonSQSClient.GetQueueUrlAsync(request); var newForroLevelJson = JsonConvert.SerializeObject(forroLevel); var sendMessageRequest = new SendMessageRequest(response.QueueUrl, newForroLevelJson); var result = await _amazonSQSClient.SendMessageAsync(sendMessageRequest); }
protected string GetQueueUrl(string queueName) { var result = Client.GetQueueUrlAsync(queueName).Result; if (result.HttpStatusCode != HttpStatusCode.OK) { throw new Exception(String.Format("Error while trying to get queue url. Status code: {0}", result.HttpStatusCode)); } return(result.QueueUrl); }
static void GetUrl(AmazonSQSClient client) { var request = new GetQueueUrlRequest { QueueName = "EventCollectQueue", QueueOwnerAWSAccountId = "468917192189" }; var response = client.GetQueueUrlAsync(request).Result; Console.WriteLine("res: " + response.QueueUrl); }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var queueUrl = !string.IsNullOrEmpty(_config.QueueUrl) ? _config.QueueUrl : (await _amazonSqsClient.GetQueueUrlAsync(_config.QueueName, stoppingToken)).QueueUrl; while (!stoppingToken.IsCancellationRequested) { await Handle(queueUrl, stoppingToken); } }