public void Notify(string header, string message, SqsConfiguration configuration)
{
var client = CreateClient(configuration);
try
{
var response = client.SendMessageAsync(new SendMessageRequest
{
QueueUrl = configuration.QueueUrl,
MessageBody = message,
MessageAttributes = new Dictionary <string, MessageAttributeValue>
{
["Title"] = new MessageAttributeValue {
DataType = "String", StringValue = header
}
}
}, CancellationToken.None).Result;
if (response.HttpStatusCode != HttpStatusCode.OK)
{
Logger.Error($"Error while sending SNS notification, status code {response.HttpStatusCode}");
}
}
catch (Exception e)
{
Logger.Error(e, "Unexpected error while sending SQS notification");
}
}
public void EnsureQueueAndErrorQueueExistAndAllAttributesAreUpdated(SqsConfiguration queueConfig)
{
if (!Exists())
{
Create(queueConfig);
}
else
{
UpdateQueueAttribute(queueConfig);
}
//Create an error queue for existing queues if they don't already have one
if (ErrorQueue != null)
{
var errorQueueConfig = new SqsConfiguration
{
ErrorQueueRetentionPeriodSeconds = queueConfig.ErrorQueueRetentionPeriodSeconds,
ErrorQueueOptOut = true
};
if (!ErrorQueue.Exists())
{
ErrorQueue.Create(errorQueueConfig);
}
else
{
ErrorQueue.UpdateQueueAttribute(errorQueueConfig);
}
}
UpdateRedrivePolicy(new RedrivePolicy(queueConfig.RetryCountBeforeSendingToErrorQueue, ErrorQueue.Arn));
}
public RuleService(IConfigurationRepository configurationRepository,
IMonitorRuleRepository monitorRuleRepository,
ISqsNotifier sqsNotifier)
{
_monitorRuleRepository = monitorRuleRepository;
_sqsNotifier = sqsNotifier;
var sqsConfig = configurationRepository.GetByKey("sqs_notification_config");
if (sqsConfig == null)
{
Logger.Debug("No SQS notification configuration found");
return;
}
try
{
_sqsConfiguration = JsonConvert.DeserializeObject <SqsConfiguration>(sqsConfig.Value);
}
catch (Exception e)
{
Logger.Error(e, "SQS notification configuration is invalid");
_sqsConfiguration = null;
}
}
public override bool Create(SqsConfiguration queueConfig, int attempt = 0)
{
if (!queueConfig.ErrorQueueOptOut)
{
throw new InvalidOperationException("Cannot create a dead letter queue for a dead letter queue.");
}
return(base.Create(queueConfig, attempt: attempt));
}
public override bool Create(SqsConfiguration queueConfig, int attempt = 0)
{
if (!ErrorQueue.Exists())
{
ErrorQueue.Create(new SqsConfiguration()
{
ErrorQueueRetentionPeriodSeconds = queueConfig.ErrorQueueRetentionPeriodSeconds, ErrorQueueOptOut = true
});
}
return(base.Create(queueConfig, attempt));
}
private AmazonSQSClient CreateClient(SqsConfiguration configuration)
{
if (_sqsClient == null)
{
_sqsClient = string.IsNullOrEmpty(configuration.AccessKey)
? new AmazonSQSClient(new AmazonSQSConfig
{
RegionEndpoint = RegionEndpoint.GetBySystemName(configuration.Region)
})
: new AmazonSQSClient(new BasicAWSCredentials(configuration.AccessKey, configuration.SecretKey),
RegionEndpoint.GetBySystemName(configuration.Region));
}
return(_sqsClient);
}
public virtual bool Create(SqsConfiguration queueConfig, int attempt = 0)
{
try
{
var result = Client.CreateQueue(new CreateQueueRequest {
QueueName = QueueNamePrefix,
Attributes = GetCreateQueueAttributes(queueConfig.MessageRetentionSeconds, queueConfig.VisibilityTimeoutSeconds)
});
if (!string.IsNullOrWhiteSpace(result.QueueUrl))
{
Url = result.QueueUrl;
SetQueueProperties();
Log.Info(string.Format("Created Queue: {0} on Arn: {1}", QueueNamePrefix, Arn));
return(true);
}
}
catch (AmazonSQSException ex)
{
if (ex.ErrorCode == "AWS.SimpleQueueService.QueueDeletedRecently")
{
// Ensure we wait for queue delete timeout to expire.
Log.Info(string.Format("Waiting to create Queue due to AWS time restriction - Queue: {0}, AttemptCount: {1}", QueueNamePrefix, attempt + 1));
Thread.Sleep(60000);
Create(queueConfig, attempt: attempt++);
}
else
{
// Throw all errors which are not delete timeout related.
Log.ErrorException(string.Format("Create Queue error: {0}", QueueNamePrefix), ex);
throw;
}
// If we're on a delete timeout, throw after 2 attempts.
if (attempt >= 2)
{
Log.ErrorException(string.Format("Create Queue error, max retries exceeded for delay - Queue: {0}", QueueNamePrefix), ex);
throw;
}
}
Log.Info(string.Format("Failed to create Queue: {0}", QueueNamePrefix));
return(false);
}
protected internal void UpdateQueueAttribute(SqsConfiguration queueConfig)
{
if (QueueNeedsUpdating(queueConfig))
{
var response = Client.SetQueueAttributes(
new SetQueueAttributesRequest
{
QueueUrl = Url,
Attributes = new Dictionary <string, string>
{
{ JustSayingConstants.ATTRIBUTE_RETENTION_PERIOD, queueConfig.MessageRetentionSeconds.ToString() },
{ JustSayingConstants.ATTRIBUTE_VISIBILITY_TIMEOUT, queueConfig.VisibilityTimeoutSeconds.ToString() },
}
});
if (response.HttpStatusCode == HttpStatusCode.OK)
{
MessageRetentionPeriod = queueConfig.MessageRetentionSeconds;
VisibilityTimeout = queueConfig.VisibilityTimeoutSeconds;
}
}
}
public SqsSubscribtionEndpointProvider(SqsConfiguration config)
{
_config = config;
}
public virtual IPublishEndpointProvider CreatePublisherEndpointProvider(SqsConfiguration subscriptionConfig)
{
return(new SnsPublishEndpointProvider(subscriptionConfig.Topic));
}
// ToDo: Move these into the factory class?
public virtual IPublishSubscribtionEndpointProvider CreateSubscriptiuonEndpointProvider(SqsConfiguration subscriptionConfig)
{
return(new SqsSubscribtionEndpointProvider(subscriptionConfig));
}
public ISubscriberIntoQueue WithSqsTopicSubscriber()
{
_subscriptionConfig = new SqsConfiguration();
return(this);
}
private bool QueueNeedsUpdating(SqsConfiguration queueConfig)
{
return(MessageRetentionPeriod != queueConfig.MessageRetentionSeconds ||
VisibilityTimeout != queueConfig.VisibilityTimeoutSeconds);
}
