public SqsNotificationListener(
SqsQueueBase queue,
IMessageSerializationRegister serializationRegister,
IMessageMonitor messagingMonitor,
ILoggerFactory loggerFactory,
IMessageContextAccessor messageContextAccessor,
Action <Exception, Amazon.SQS.Model.Message> onError = null,
IMessageLockAsync messageLock = null,
IMessageBackoffStrategy messageBackoffStrategy = null)
{
_queue = queue;
_messagingMonitor = messagingMonitor;
onError = onError ?? DefaultErrorHandler;
_log = loggerFactory.CreateLogger("JustSaying");
_messageProcessingStrategy = new DefaultThrottledThroughput(_messagingMonitor);
_messageHandlerWrapper = new MessageHandlerWrapper(messageLock, _messagingMonitor);
_messageDispatcher = new MessageDispatcher(
_queue,
serializationRegister,
messagingMonitor,
onError,
_handlerMap,
loggerFactory,
messageBackoffStrategy,
messageContextAccessor);
Subscribers = new Collection <ISubscriber>();
if (messageBackoffStrategy != null)
{
_requestMessageAttributeNames.Add(MessageSystemAttributeName.ApproximateReceiveCount);
}
}
public MessageReceiveBuffer(
int prefetch,
int bufferSize,
TimeSpan readTimeout,
TimeSpan sqsWaitTime,
ISqsQueue sqsQueue,
MiddlewareBase <ReceiveMessagesContext, IList <Message> > sqsMiddleware,
IMessageMonitor monitor,
ILogger <IMessageReceiveBuffer> logger,
IMessageBackoffStrategy messageBackoffStrategy = null)
{
_prefetch = prefetch;
_bufferSize = bufferSize;
_readTimeout = readTimeout;
_sqsWaitTime = sqsWaitTime;
if (sqsQueue == null)
{
throw new ArgumentNullException(nameof(sqsQueue));
}
_sqsQueueReader = new SqsQueueReader(sqsQueue);
_sqsMiddleware = sqsMiddleware ?? throw new ArgumentNullException(nameof(sqsMiddleware));
_monitor = monitor ?? throw new ArgumentNullException(nameof(monitor));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_backoffStrategyName = messageBackoffStrategy?.GetType()?.Name;
_channel = Channel.CreateBounded <IQueueMessageContext>(bufferSize);
if (messageBackoffStrategy != null)
{
_requestMessageAttributeNames.Add(MessageSystemAttributeName.ApproximateReceiveCount);
}
}
/// <summary>
/// Constructs a <see cref="BackoffMiddleware"/> with a given backoff strategy and logger/monitor.
/// </summary>
/// <param name="backoffStrategy">An <see cref="IMessageBackoffStrategy"/> to use to determine how long to delay message redelivery when a handler returns false or throws.</param>
/// <param name="loggerFactory">An <see cref="ILoggerFactory"/> to use when logging request failures.</param>
/// <param name="monitor">An <see cref="IMessageMonitor"/> to use when recording request failures.</param>
public BackoffMiddleware(IMessageBackoffStrategy backoffStrategy, ILoggerFactory loggerFactory, IMessageMonitor monitor)
{
_backoffStrategy = backoffStrategy ?? throw new ArgumentNullException(nameof(backoffStrategy));
_monitor = monitor ?? throw new ArgumentNullException(nameof(monitor));
_logger = loggerFactory?.CreateLogger <BackoffMiddleware>() ??
throw new ArgumentNullException(nameof(loggerFactory));
}
public MessageDispatcher(
IMessageSerializationRegister serializationRegister,
IMessageMonitor messagingMonitor,
HandlerMap handlerMap,
ILoggerFactory loggerFactory,
IMessageBackoffStrategy messageBackoffStrategy,
IMessageContextAccessor messageContextAccessor)
{
_serializationRegister = serializationRegister;
_messagingMonitor = messagingMonitor;
_handlerMap = handlerMap;
_logger = loggerFactory.CreateLogger("JustSaying");
_messageBackoffStrategy = messageBackoffStrategy;
_messageContextAccessor = messageContextAccessor;
}
public MessageDispatcher(
SqsQueueBase queue,
IMessageSerialisationRegister serialisationRegister,
IMessageMonitor messagingMonitor,
Action <Exception, SQSMessage> onError,
HandlerMap handlerMap,
ILoggerFactory loggerFactory,
IMessageBackoffStrategy messageBackoffStrategy)
{
_queue = queue;
_serialisationRegister = serialisationRegister;
_messagingMonitor = messagingMonitor;
_onError = onError;
_handlerMap = handlerMap;
_log = loggerFactory.CreateLogger("JustSaying");
_messageBackoffStrategy = messageBackoffStrategy;
}
/// <summary>
/// If an <see cref="IMessageBackoffStrategy"/> has been registered in services, then this will create
/// a <see cref="BackoffMiddleware"/> and add it to the pipeline.
/// </summary>
/// <param name="builder">The <see cref="HandlerMiddlewareBuilder"/> to add the middleware to.</param>
/// <param name="backoffStrategy">The <see cref="IMessageBackoffStrategy"/> to use to determine message visibility timeouts.</param>
/// <returns>The current <see cref="HandlerMiddlewareBuilder"/>.</returns>
/// <exception cref="ArgumentNullException">When the <see cref="HandlerMiddlewareBuilder"/> is null.</exception>
public static HandlerMiddlewareBuilder UseBackoff(this HandlerMiddlewareBuilder builder, IMessageBackoffStrategy backoffStrategy)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (backoffStrategy == null)
{
throw new ArgumentNullException(nameof(backoffStrategy));
}
var loggerFactory = builder.ServiceResolver.ResolveService <ILoggerFactory>();
var monitor = builder.ServiceResolver.ResolveService <IMessageMonitor>();
return(builder.Use(new BackoffMiddleware(backoffStrategy, loggerFactory, monitor)));
}
