public TransportMessage SendRawAndReceiveMessage(string rawMessageString)
{
return(SendAndReceiveCore(() =>
{
SqsClient.SendMessage(QueueUrlCache.GetQueueUrl(Address), rawMessageString);
}));
}
public Application(ILoggerFactory loggerFactory, IdentityClient identityClient, SqsClient sqsClient, IServiceProvider serviceProvider)
{
_logger = loggerFactory.CreateLogger(nameof(Application));
_identityClient = identityClient;
_sqsClient = sqsClient;
_serviceProvider = serviceProvider;
}
public async Task Init(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, PushSettings settings)
{
_queueUrl = SqsQueueUrlCache.GetQueueUrl(SqsQueueNameHelper.GetSqsQueueName(settings.InputQueue, ConnectionConfiguration));
if (settings.PurgeOnStartup)
{
// SQS only allows purging a queue once every 60 seconds or so.
// If you try to purge a queue twice in relatively quick succession,
// PurgeQueueInProgressException will be thrown.
// This will happen if you are trying to start an endpoint twice or more
// in that time.
try
{
await SqsClient.PurgeQueueAsync(_queueUrl).ConfigureAwait(false);
}
catch (PurgeQueueInProgressException ex)
{
Logger.Warn("Multiple queue purges within 60 seconds are not permitted by SQS.", ex);
}
catch (Exception ex)
{
Logger.Error("Exception thrown from PurgeQueue.", ex);
throw;
}
}
_onMessage = onMessage;
_onError = onError;
}
/// <summary>
/// Gets a message from an SQS queue and if successful, deletes the message from the queue.
/// Safe method for multiple concurrent consumers of a single SQS because the initial message read makes the message unavailable to other callers.
/// </summary>
/// <param name="QueueUrl">The SQS queue URL</param>
/// <param name="bForceNoDelete">Debug option. Skips the message delete when testing reading messages from a live queue</param>
/// <returns>A dequeued SQS message or null if it fails.</returns>
public Message SQSDequeueMessage(string QueueUrl, bool bForceNoDelete)
{
if (!IsSQSValid)
{
return(null);
}
ReceiveMessageRequest ReceiveRequest = new ReceiveMessageRequest
{
QueueUrl = QueueUrl,
MaxNumberOfMessages = 1
};
ReceiveMessageResponse ReceiveResponse = SqsClient.ReceiveMessage(ReceiveRequest);
if (ReceiveResponse.Messages.Count == 1)
{
Message Message = ReceiveResponse.Messages[0];
if (Message != null && (bForceNoDelete || DeleteRecordSQS(QueueUrl, Message)))
{
return(Message);
}
}
return(null);
}
private bool DequeueRecordSQS(out string OutRecordString)
{
OutRecordString = string.Empty;
try
{
var ReceiveRequest = new ReceiveMessageRequest
{
QueueUrl = Config.Default.AWSSQSQueueUrl,
MaxNumberOfMessages = 1
};
var ReceiveResponse = SqsClient.ReceiveMessage(ReceiveRequest);
if (ReceiveResponse.Messages.Count == 1)
{
var Message = ReceiveResponse.Messages[0];
if (Message != null && TryDeleteRecordSQS(Message))
{
OutRecordString = Message.Body;
return(true);
}
}
}
catch (Exception Ex)
{
CrashReporterProcessServicer.WriteException("DequeueRecordSQS: " + Ex.ToString());
}
return(false);
}
public override void Dispose()
{
SqsClient.Dispose();
S3Client.Dispose();
base.Dispose();
}
private void SendMessage(string message, SendOptions sendOptions)
{
var delayDeliveryBy = TimeSpan.MaxValue;
if (sendOptions.DelayDeliveryWith.HasValue)
{
delayDeliveryBy = sendOptions.DelayDeliveryWith.Value;
}
else
{
if (sendOptions.DeliverAt.HasValue)
{
delayDeliveryBy = sendOptions.DeliverAt.Value - DateTime.UtcNow;
}
}
var sendMessageRequest = new SendMessageRequest(QueueUrlCache.GetQueueUrl(sendOptions.Destination), message);
// There should be no need to check if the delay time is greater than the maximum allowed
// by SQS (15 minutes); the call to AWS will fail with an appropriate exception if the limit is exceeded.
if (delayDeliveryBy != TimeSpan.MaxValue)
{
sendMessageRequest.DelaySeconds = Math.Max(0, (int)delayDeliveryBy.TotalSeconds);
}
SqsClient.SendMessage(sendMessageRequest);
}
public void Init()
{
var accountId = Environment.GetEnvironmentVariable("SQS_ACCOUNT_ID");
if(string.IsNullOrEmpty(accountId)) {
accountId = "accountid";
}
var publicKey = Environment.GetEnvironmentVariable("AWS_ACCESS_KEY_ID");
if(string.IsNullOrEmpty(publicKey)) {
publicKey = "publickey";
}
var privateKey = Environment.GetEnvironmentVariable("AWS_SECRET_ACCESS_KEY");
if(string.IsNullOrEmpty("privatekey")) {
privateKey = "privatekey";
}
_client = new SqsClient(SqsClientConfig.From(new XDoc("sqs-config")
.Elem("endpoint", "default")
.Elem("accountid", accountId)
.Elem("publickey", publicKey)
.Elem("privatekey", privateKey)));
TEST_QUEUE = new SqsQueueName("steveb-events");
// purge the queue
while(true) {
var messages = _client.ReceiveMessages(TEST_QUEUE, 1.Seconds(), SqsUtils.MAX_NUMBER_OF_MESSAGES_TO_FETCH);
if(messages.None()) {
break;
}
_client.DeleteMessages(TEST_QUEUE, messages);
}
}
public async Task It_Dispatches_A_Message()
{
// Arrange.
var expiry = DateTime.Now.AddDays(1);
var message = Message.WithContent("abc").WhichExpiresAt(expiry);
// Act.
var response = await QueueManager.Dispatch(message);
// Assert.
Assert.NotEqual(Guid.Empty, response.MessageId);
var receivedMessage = await SqsClient.ReceiveMessageAsync(new ReceiveMessageRequest
{
QueueUrl = QueueUrl,
WaitTimeSeconds = 1,
MaxNumberOfMessages = 1
});
Assert.NotEmpty(receivedMessage.Messages);
var deserialisedMessage = JsonSerializer.Deserialize <ReceivedMessage>(receivedMessage.Messages.First().Body);
Assert.Equal(response.MessageId, deserialisedMessage.Id);
Assert.Equal("default", deserialisedMessage.Queue);
Assert.Equal("abc", deserialisedMessage.Content);
Assert.Equal(expiry, deserialisedMessage.Expiry);
}
private async Task SendMessage(string message, string destination, List <DeliveryConstraint> constraints)
{
var delayWithConstraint = constraints.OfType <DelayDeliveryWith>().SingleOrDefault();
var deliverAtConstraint = constraints.OfType <DoNotDeliverBefore>().SingleOrDefault();
var delayDeliveryBy = TimeSpan.MaxValue;
if (delayWithConstraint != null)
{
delayDeliveryBy = delayWithConstraint.Delay;
}
else
{
if (deliverAtConstraint != null)
{
delayDeliveryBy = deliverAtConstraint.At - DateTime.UtcNow;
}
}
var sendMessageRequest = new SendMessageRequest(
SqsQueueUrlCache.GetQueueUrl(
SqsQueueNameHelper.GetSqsQueueName(destination, ConnectionConfiguration)),
message);
// There should be no need to check if the delay time is greater than the maximum allowed
// by SQS (15 minutes); the call to AWS will fail with an appropriate exception if the limit is exceeded.
if (delayDeliveryBy != TimeSpan.MaxValue)
{
sendMessageRequest.DelaySeconds = Math.Max(0, (int)delayDeliveryBy.TotalSeconds);
}
await SqsClient.SendMessageAsync(sendMessageRequest).ConfigureAwait(false);
}
/// <summary>
/// Send a message to the specified SQS queue. The Lambda function requires <c>sqs:SendMessage</c> permission
/// on the specified SQS queue.
/// </summary>
/// <param name="deadLetterQueueUrl">The SQS queue URL.</param>
/// <param name="message">The message to send.</param>
/// <param name="messageAttributes">Optional attributes for the message.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>The task object representing the asynchronous operation.</returns>
public virtual Task SendMessageToQueueAsync(string deadLetterQueueUrl, string message, IEnumerable <KeyValuePair <string, string> >?messageAttributes, CancellationToken cancellationToken)
=> SqsClient.SendMessageAsync(new SendMessageRequest {
QueueUrl = deadLetterQueueUrl,
MessageBody = message,
MessageAttributes = messageAttributes?.ToDictionary(kv => kv.Key, kv => new MessageAttributeValue {
DataType = "String",
StringValue = kv.Value
}) ?? new Dictionary <string, MessageAttributeValue>()
}, cancellationToken);
public void Publish(T message)
{
message.Require("message");
SqsClient.SendMessage(new SendMessageRequest
{
QueueUrl = QueueUrl,
MessageBody = Serializer.Serialize(message)
});
}
public bool ChangeVisibility(ChangeMessageVisibilityRequest request)
{
if (request == null)
{
return(false);
}
var response = SqsClient.ChangeMessageVisibility(request);
return(response != null);
}
public bool Send(SendMessageRequest request)
{
if (request == null)
{
return(false);
}
var response = SqsClient.SendMessage(request);
return(response != null);
}
public bool Delete(DeleteMessageRequest request)
{
if (request == null)
{
return(false);
}
var response = SqsClient.DeleteMessage(request);
return(response != null);
}
public BnetClient(IOptions <Config> config, S3Client s3Client, SqsClient sqsClient, ILoggerFactory loggerFactory, IHub sentry, IServiceProvider serviceProvider)
{
_s3Client = s3Client;
_sqsClient = sqsClient;
_logger = loggerFactory.CreateLogger(nameof(BnetClient));
_sentry = sentry;
_serviceProvider = serviceProvider;
_puppeteerRemoteHost = config.Value.PuppeteerRemoteHost;
this.ConnectOrLaunch().Wait();
}
public void CreateQueue()
{
Creator.CreateQueueIfNecessary(Address, "");
try
{
SqsClient.PurgeQueue(QueueUrlCache.GetQueueUrl(Address));
}
catch (PurgeQueueInProgressException)
{
}
}
private bool DeleteRecordSQS(string QueueUrl, Message InMessage)
{
DeleteMessageRequest DeleteRequest = new DeleteMessageRequest
{
QueueUrl = QueueUrl,
ReceiptHandle = InMessage.ReceiptHandle
};
var DeleteResponse = SqsClient.DeleteMessage(DeleteRequest);
return(DeleteResponse.HttpStatusCode == HttpStatusCode.OK);
}
private static void EnsureQueue(IServiceHandler handler)
{
if (!_registeredHandlerUrls.ContainsKey(handler.QueueName))
{
var createQueueRequest = new CreateQueueRequest();
createQueueRequest.QueueName = handler.QueueName;
var createQueueResponse = SqsClient.CreateQueue(createQueueRequest);
var queueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
_registeredHandlerUrls[handler.QueueName] = queueUrl;
}
handler.QueueUrl = _registeredHandlerUrls[handler.QueueName];
}
public async Task <SendMessageResponse> SendMessage(string message)
{
var response = await SystemsManagementClient.GetParameterAsync(new GetParameterRequest()
{
Name = "OrdersQueueName"
});
return(await SqsClient.SendMessageAsync(new SendMessageRequest()
{
MessageBody = message,
QueueUrl = response.Parameter.Value
}));
}
public string GetQueueUrl(Address address)
{
string result;
var addressKey = address.ToString();
if (!_cache.TryGetValue(addressKey, out result))
{
var getQueueUrlResponse = SqsClient.GetQueueUrl(address.ToSqsQueueName(ConnectionConfiguration));
result = getQueueUrlResponse.QueueUrl;
_cache.AddOrUpdate(addressKey, result, (x, y) => result);
}
return(result);
}
public void Dispose()
{
DequeueStrategy.Stop();
if (S3Client != null)
{
S3Client.Dispose();
}
if (SqsClient != null)
{
SqsClient.Dispose();
}
}
public Message Receive(ReceiveMessageRequest request)
{
if (request == null)
{
return(null);
}
request.MaxNumberOfMessages = 1;
var response = SqsClient.ReceiveMessage(request);
return(response?.Messages.SingleOrDefault());
}
/// <summary>
/// Dispose of this object
/// </summary>
/// <param name="disposing">Dispose of managed resources?</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (SqsClient != null)
{
SqsClient.Dispose();
}
if (S3Client != null)
{
S3Client.Dispose();
}
}
}
protected override void Given()
{
SqsClient.ReceiveMessageAsync(Arg.Any <ReceiveMessageRequest>(), Arg.Any <CancellationToken>())
.Returns(_ =>
{
Interlocked.Increment(ref _callCount);
var messages = new List <Message> {
new TestMessage()
};
return(new ReceiveMessageResponse {
Messages = messages
});
});
}
public IMessageContext <T> Receive(TimeSpan?timeout = null)
{
var receiveResponse = SqsClient.ReceiveMessage(new ReceiveMessageRequest {
QueueUrl = QueueUrl
});
var message = receiveResponse.Messages.FirstOrDefault();
if (message == null)
{
return(null);
}
return(new AwsSqsMessageContext <T>(this, Serializer.Deserialize(message.Body), message.ReceiptHandle));
}
public async Task Setup()
{
_sqsClient = SqsClient.GetAmazonSqsClient();
await _sqsClient.CreateQueueAsync(new CreateQueueRequest(_testReceiveQueueName));
GetQueueUrlResponse getQueueUrlResponse = await _sqsClient.GetQueueUrlAsync(_testReceiveQueueName);
_testQueueUrl = getQueueUrlResponse.QueueUrl;
for (var i = 0; i < 10; i++)
{
await _sqsClient.SendMessageAsync(new SendMessageRequest(_testQueueUrl, $"message body {i}"));
}
}
public Message Receive(ReceiveMessageRequest request)
{
if (request == null)
{
return(null);
}
if (receiveBuffer.Count > 0 && receiveBuffer.TryDequeue(out var toReturn))
{
return(toReturn);
}
request.MaxNumberOfMessages = Math.Min(SqsQueueDefinition.MaxBatchReceiveItems, Math.Max(request.MaxNumberOfMessages, 1));
var response = SqsClient.ReceiveMessage(request);
return(BufferResponse(response));
}
/// <summary>
/// Get the number of items in an SQS queue
/// </summary>
/// <param name="QueueUrl">The SQS queue URL</param>
/// <returns>Number of messages in the queue. Returns zero in the event of an error.</returns>
public int GetSQSQueueCount(string QueueUrl)
{
if (!IsSQSValid)
{
return(0);
}
GetQueueAttributesRequest AttribRequest = new GetQueueAttributesRequest
{
QueueUrl = QueueUrl,
AttributeNames = new List <string>
{
"ApproximateNumberOfMessages"
}
};
GetQueueAttributesResponse AttribResponse = SqsClient.GetQueueAttributes(AttribRequest);
return(AttribResponse.ApproximateNumberOfMessages);
}
private bool DeleteEnqueued(int minBufferCount, bool forceOne = false)
{
var deletedAtSqs = false;
minBufferCount = Math.Min(SqsQueueDefinition.MaxBatchDeleteItems, Math.Max(minBufferCount, 1));
try
{
while (forceOne || deleteBuffer.Count >= minBufferCount)
{
forceOne = false;
var entries = EntriesToDelete(SqsQueueDefinition.MaxBatchDeleteItems).ToList();
if (entries.Count <= 0)
{
break;
}
deletedAtSqs = true;
var response = SqsClient.DeleteMessageBatch(new DeleteMessageBatchRequest
{
QueueUrl = queueDefinition.QueueUrl,
Entries = entries
});
if (response.Failed != null && response.Failed.Count > 0)
{
response.Failed.Each(f => HandleError(f.ToException()));
}
}
}
catch (Exception ex)
{
HandleError(ex);
}
return(deletedAtSqs);
}
private bool CvEnqueued(int minBufferCount, bool forceOne = false)
{
var cvAtAws = false;
minBufferCount = Math.Min(SqsQueueDefinition.MaxBatchCvItems, Math.Max(minBufferCount, 1));
try
{
while (forceOne || cvBuffer.Count >= minBufferCount)
{
forceOne = false;
var entries = EntriesToCv(SqsQueueDefinition.MaxBatchCvItems).ToList();
if (entries.Count <= 0)
{
break;
}
cvAtAws = true;
var response = SqsClient.ChangeMessageVisibilityBatch(new ChangeMessageVisibilityBatchRequest
{
QueueUrl = queueDefinition.QueueUrl,
Entries = entries
});
if (response.Failed != null && response.Failed.Count > 0)
{
response.Failed.Each(f => HandleError(f.ToException()));
}
}
}
catch (Exception ex)
{
HandleError(ex);
}
return(cvAtAws);
}
public void Teardown()
{
_client = null;
}
