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