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);
}
}
public InMemoryServiceResolver(ITestOutputHelper outputHelper, IMessageMonitor monitor, Action <IServiceCollection> configure = null) :
this(sc =>
{
Configure(sc, outputHelper, monitor);
configure?.Invoke(sc);
})
{ }
public void Given()
{
_handler.Handle(Arg.Any<GenericMessage>()).Returns(true).AndDoes(ex => { throw new Exception("My Ex"); });
_globalErrorHandler = (ex, m) => { _handledException = true; };
_monitoring = Substitute.For<IMessageMonitor>();
var bus = CreateMeABus.InRegion(RegionEndpoint.EUWest1.SystemName)
.WithMonitoring(_monitoring)
.ConfigurePublisherWith(c =>
{
c.PublishFailureBackoffMilliseconds = 1;
c.PublishFailureReAttempts = 3;
})
.WithSnsMessagePublisher<GenericMessage>()
.WithSqsTopicSubscriber()
.IntoQueue("queuename")
.ConfigureSubscriptionWith(cfg =>
{
cfg.MessageRetentionSeconds = 60;
cfg.InstancePosition = 1;
cfg.OnError = _globalErrorHandler;
})
.WithMessageHandler(_handler);
bus.StartListening();
_bus = bus;
}
protected override IAmJustSayingFluently CreateSystemUnderTest()
{
var handler = Substitute.For <IHandler <GenericMessage> >();
handler.When(x => x.Handle(Arg.Any <GenericMessage>()))
.Do(x => _handler.Complete((GenericMessage)x.Args()[0]));
Monitoring = Substitute.For <IMessageMonitor>();
ServiceBus = CreateMeABus.InRegion(RegionEndpoint.EUWest1.SystemName)
.WithMonitoring(Monitoring)
.ConfigurePublisherWith(c =>
{
c.PublishFailureBackoffMilliseconds = _config.PublishFailureBackoffMilliseconds;
c.PublishFailureReAttempts = _config.PublishFailureReAttempts;
})
.WithSnsMessagePublisher <GenericMessage>()
.WithSqsTopicSubscriber()
.IntoQueue("queuename")
.ConfigureSubscriptionWith(cf =>
{
cf.MessageRetentionSeconds = 60;
cf.VisibilityTimeoutSeconds = JustSayingConstants.DEFAULT_VISIBILITY_TIMEOUT;
cf.InstancePosition = 1;
})
.WithMessageHandler(handler);
ServiceBus.StartListening();
return(ServiceBus);
}
/// <summary>
/// Initializes a new instance of the <see cref="Throttled"/> class.
/// </summary>
/// <param name="options">The <see cref="ThrottledOptions"/> to use.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="options"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="options"/> does not specify an <see cref="ILogger"/> or <see cref="IMessageMonitor"/>.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// The concurrency specified by <paramref name="options"/> is less than one,
/// or the start timeout specified by <paramref name="options"/> is zero or negative.
/// </exception>
public Throttled(ThrottledOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (options.MaxConcurrency < 1)
{
throw new ArgumentOutOfRangeException(nameof(options), options.MaxConcurrency, "The maximum concurrency value must be a positive integer.");
}
if (options.StartTimeout <= TimeSpan.Zero && options.StartTimeout != Timeout.InfiniteTimeSpan)
{
throw new ArgumentOutOfRangeException(
nameof(options),
options.StartTimeout,
"The start timeout must be a positive value or Timeout.InfiniteTimeSpan.");
}
_messageMonitor = options.MessageMonitor ?? throw new ArgumentException($"A value for {nameof(ThrottledOptions.MessageMonitor)} must be specified.", nameof(options));
_logger = options.Logger ?? throw new ArgumentException($"A value for {nameof(ThrottledOptions.Logger)} must be specified.", nameof(options));
MaxConcurrency = options.MaxConcurrency;
StartTimeout = options.StartTimeout;
_processSequentially = options.ProcessMessagesSequentially;
_semaphore = new SemaphoreSlim(MaxConcurrency, MaxConcurrency);
}
protected override void Given()
{
Config = Substitute.For <IMessagingConfig>();
Monitor = Substitute.For <IMessageMonitor>();
Logging.ToConsole();
}
internal Operation(IMessageMonitor messageMonitor, Action <TimeSpan, IMessageMonitor> onComplete)
{
_messageMonitor = messageMonitor ?? throw new ArgumentNullException(nameof(messageMonitor));
_onComplete = onComplete ?? throw new ArgumentNullException(nameof(onComplete));
_stopWatch = Stopwatch.StartNew();
}
protected override Task Given()
{
Config = Substitute.For <IMessagingConfig>();
Monitor = Substitute.For <IMessageMonitor>();
LoggerFactory = Substitute.For <ILoggerFactory>();
return(Task.CompletedTask);
}
public void Given()
{
_handler.Handle(Arg.Any <GenericMessage>()).Returns(true).AndDoes(ex => { throw new Exception("My Ex"); });
_globalErrorHandler = (ex, m) => { _handledException = true; };
_monitoring = Substitute.For <IMessageMonitor>();
var bus = CreateMeABus.InRegion(RegionEndpoint.EUWest1.SystemName)
.WithMonitoring(_monitoring)
.ConfigurePublisherWith(c =>
{
c.PublishFailureBackoffMilliseconds = 1;
c.PublishFailureReAttempts = 3;
})
.WithSnsMessagePublisher <GenericMessage>()
.WithSqsTopicSubscriber()
.IntoQueue("queuename")
.ConfigureSubscriptionWith(cfg =>
{
cfg.MessageRetentionSeconds = 60;
cfg.InstancePosition = 1;
cfg.OnError = _globalErrorHandler;
})
.WithMessageHandler(_handler);
bus.StartListening();
_bus = bus;
}
/// <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));
}
protected override IAmJustSayingFluently CreateSystemUnderTest()
{
const int TimeoutMillis = 1000;
var snsHandler = Substitute.For <IHandlerAsync <GenericMessage> >();
snsHandler.When(x => x.Handle(Arg.Any <GenericMessage>()))
.Do(x =>
{
var msg = (GenericMessage)x.Args()[0];
if (_snsHandler != null)
{
_snsHandler.Complete(msg).Wait(TimeoutMillis);
}
});
var sqsHandler = Substitute.For <IHandlerAsync <AnotherGenericMessage> >();
sqsHandler.When(x => x.Handle(Arg.Any <AnotherGenericMessage>()))
.Do(x =>
{
var msg = (AnotherGenericMessage)x.Args()[0];
if (_sqsHandler != null)
{
_sqsHandler.Complete(msg).Wait(TimeoutMillis);
}
});
Monitoring = Substitute.For <IMessageMonitor>();
ServiceBus = CreateMeABus.WithLogging(new LoggerFactory())
.InRegion(RegionEndpoint.EUWest1.SystemName)
.WithMonitoring(Monitoring)
.ConfigurePublisherWith(c =>
{
c.PublishFailureBackoffMilliseconds = _config.PublishFailureBackoffMilliseconds;
c.PublishFailureReAttempts = _config.PublishFailureReAttempts;
})
.WithSnsMessagePublisher <GenericMessage>()
.WithSqsTopicSubscriber()
.IntoQueue("queuename")
.ConfigureSubscriptionWith(cf =>
{
cf.MessageRetentionSeconds = 60;
cf.VisibilityTimeoutSeconds = JustSayingConstants.DEFAULT_VISIBILITY_TIMEOUT;
cf.InstancePosition = 1;
})
.WithMessageHandler(snsHandler)
.WithSqsMessagePublisher <AnotherGenericMessage>(configuration => { })
.WithSqsPointToPointSubscriber()
.IntoDefaultQueue()
.WithMessageHandler(sqsHandler);
ServiceBus.StartListening();
return(ServiceBus);
}
public AbstractEventProcessor(string name, IEventHandlerInvoker eventHandlerInvoker, RollbackConfigurationType rollbackConfiguration, IErrorHandler errorHandler, IMessageMonitor messageMonitor)
{
EventHandlerInvoker = eventHandlerInvoker ?? throw new ArgumentNullException(nameof(name));
_rollbackConfiguration = rollbackConfiguration;
_errorHandler = errorHandler ?? PropagatingErrorHandler.Instance;
_messageMonitor = messageMonitor ?? NoOpMessageMonitor.Instance;
Name = name ?? throw new ArgumentNullException(nameof(name));
}
public Throttled(Func<int> maximumAllowedMesagesInFlightProducer, int maximumBatchSize,
IMessageMonitor messageMonitor)
{
_maximumAllowedMesagesInFlightProducer = maximumAllowedMesagesInFlightProducer;
_activeTasks = new List<Task>();
_maximumBatchSize = maximumBatchSize;
_messageMonitor = messageMonitor;
}
public Throttled(Func <int> maximumAllowedMesagesInFlightProducer, int maximumBatchSize,
IMessageMonitor messageMonitor)
{
_maximumAllowedMesagesInFlightProducer = maximumAllowedMesagesInFlightProducer;
_activeTasks = new List <Task>();
_maximumBatchSize = maximumBatchSize;
_messageMonitor = messageMonitor;
}
public void SetUp()
{
_fakeMonitor = Substitute.For<IMessageMonitor>();
_fakeAmazonBatchSize = 10;
_concurrencyLevel = 20;
_messageProcessingStrategy = new Throttled(_concurrencyLevel, _fakeAmazonBatchSize, _fakeMonitor);
_actionsProcessed = 0;
}
public void SetUp()
{
_fakeMonitor = Substitute.For <IMessageMonitor>();
_fakeAmazonBatchSize = 10;
_concurrencyLevel = 20;
_messageProcessingStrategy = new Throttled(_concurrencyLevel, _fakeAmazonBatchSize, _fakeMonitor);
_actionsProcessed = 0;
}
public Throttled(Func <int> maxWorkersProducer,
IMessageMonitor messageMonitor)
{
_maxWorkersProducer = maxWorkersProducer;
_messageMonitor = messageMonitor;
_activeTasks = new List <Task>(_maxWorkersProducer());
}
public MessageHandlerWrapper(
IMessageLockAsync messageLock,
IMessageMonitor messagingMonitor,
ILoggerFactory loggerFactory)
{
_messageLock = messageLock;
_messagingMonitor = messagingMonitor;
_loggerFactory = loggerFactory;
}
private JustSayingBus CreateBus(IMessagingConfig config, ILoggerFactory loggerFactory)
{
IMessageSerializationRegister register = ServiceResolver.ResolveService <IMessageSerializationRegister>();
IMessageMonitor monitor = ServiceResolver.ResolveOptionalService <IMessageMonitor>() ?? new NullOpMessageMonitor();
var bus = new JustSayingBus(config, register, loggerFactory, monitor);
return(bus);
}
public static Operation MeasureThrottle(this IMessageMonitor messageMonitor)
=> new Operation(messageMonitor, (duration, monitor) =>
{
if (duration.TotalMilliseconds < 1)
{
return;
}
monitor.IncrementThrottlingStatistic();
monitor.HandleThrottlingTime(duration);
});
public SqsNotificationListener(SqsQueueBase queue, IMessageSerialisationRegister serialisationRegister, IMessageMonitor messagingMonitor, Action <Exception, Amazon.SQS.Model.Message> onError = null, IMessageLock messageLock = null)
{
_queue = queue;
_serialisationRegister = serialisationRegister;
_messagingMonitor = messagingMonitor;
_onError = onError ?? ((ex, message) => { });
_handlers = new Dictionary <Type, List <Func <Message, bool> > >();
_messageProcessingStrategy = new MaximumThroughput();
_messageLock = messageLock;
}
public SubscribingEventProcessor(String name,
IEventHandlerInvoker eventHandlerInvoker,
ISubscribableMessageSource <IEventMessage> messageSource,
IEventProcessingStrategy processingStrategy,
IErrorHandler errorHandler,
IMessageMonitor messageMonitor)
: this(name, eventHandlerInvoker, RollbackConfigurationType.AnyThrowable, messageSource, processingStrategy,
errorHandler, messageMonitor)
{
}
/// <summary>
/// Adds an error handler to the pipeline that will call methods on the the <see cref="IMessageMonitor"/>
/// registered in services.
/// </summary>
/// <param name="builder">The <see cref="HandlerMiddlewareBuilder"/> to add the middleware to.</param>
/// <returns>The current <see cref="HandlerMiddlewareBuilder"/>.</returns>
/// <exception cref="ArgumentNullException">When the <see cref="HandlerMiddlewareBuilder"/> is null.</exception>
public static HandlerMiddlewareBuilder UseErrorHandler(this HandlerMiddlewareBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
IMessageMonitor monitor = builder.ServiceResolver.ResolveService <IMessageMonitor>();
return(builder.Use(new ErrorHandlerMiddleware(monitor)));
}
private void GivenInternal()
{
SqsClient = Substitute.For <IAmazonSQS>();
Queue = Substitute.For <ISqsQueue>();
Queue.Uri.Returns(new Uri("http://test.com"));
Queue.Client.Returns(SqsClient);
Monitor = Substitute.For <IMessageMonitor>();
SqsMiddleware = new DelegateMiddleware <GetMessagesContext, IList <Amazon.SQS.Model.Message> >();
Given();
}
/// <summary>
/// Creates an instance of <see cref="SubscriptionGroupFactory"/>.
/// </summary>
/// <param name="messageDispatcher">The <see cref="IMessageDispatcher"/> to use to dispatch messages.</param>
/// <param name="monitor">The <see cref="IMessageMonitor"/> used by the <see cref="IMessageReceiveBuffer"/>.</param>
/// <param name="loggerFactory">The <see cref="ILoggerFactory"/> to use.</param>
public SubscriptionGroupFactory(
IMessageDispatcher messageDispatcher,
IMessageMonitor monitor,
ILoggerFactory loggerFactory)
{
_messageDispatcher = messageDispatcher;
_monitor = monitor;
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_defaultSqsMiddleware =
new DefaultReceiveMessagesMiddleware(_loggerFactory.CreateLogger <DefaultReceiveMessagesMiddleware>());
}
private static ThrottledOptions CreateOptions(IMessageMonitor messageMonitor, ILogger logger)
{
return(new ThrottledOptions()
{
MaxConcurrency = Environment.ProcessorCount * MessageConstants.ParallelHandlerExecutionPerCore,
Logger = logger,
MessageMonitor = messageMonitor,
StartTimeout = Timeout.InfiniteTimeSpan,
ProcessMessagesSequentially = false,
});
}
public MessageDispatcher(
IMessageSerializationRegister serializationRegister,
IMessageMonitor messagingMonitor,
MiddlewareMap middlewareMap,
ILoggerFactory loggerFactory)
{
_serializationRegister = serializationRegister;
_messagingMonitor = messagingMonitor;
_middlewareMap = middlewareMap;
_logger = loggerFactory.CreateLogger("JustSaying");
}
public SubscribingEventProcessor(String name,
IEventHandlerInvoker eventHandlerInvoker,
RollbackConfigurationType rollbackConfiguration,
ISubscribableMessageSource <IEventMessage> messageSource,
IEventProcessingStrategy processingStrategy,
IErrorHandler errorHandler,
IMessageMonitor messageMonitor)
: base(name, eventHandlerInvoker, rollbackConfiguration, errorHandler, messageMonitor)
{
_messageSource = messageSource;
_processingStrategy = processingStrategy;
}
/// <summary>
/// Adds a <see cref="StopwatchMiddleware"/> to the current pipeline.
/// </summary>
/// <param name="builder">The current <see cref="HandlerMiddlewareBuilder"/>.</param>
/// <param name="handlerType">The type of the handler that results should be reported against.</param>
/// <returns>The current <see cref="HandlerMiddlewareBuilder"/>.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="builder"/> is <see langword="null"/>.
/// </exception>
public static HandlerMiddlewareBuilder UseStopwatch(
this HandlerMiddlewareBuilder builder,
Type handlerType)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
IMessageMonitor monitor = builder.ServiceResolver.ResolveService <IMessageMonitor>();
return(builder.Use(new StopwatchMiddleware(monitor, handlerType)));
}
public MessageDispatcher(
SqsQueueBase queue,
IMessageSerialisationRegister serialisationRegister,
IMessageMonitor messagingMonitor,
Action<Exception, SQSMessage> onError,
HandlerMap handlerMap)
{
_queue = queue;
_serialisationRegister = serialisationRegister;
_messagingMonitor = messagingMonitor;
_onError = onError;
_handlerMap = handlerMap;
}
public MessageDispatcher(
SqsQueueBase queue,
IMessageSerialisationRegister serialisationRegister,
IMessageMonitor messagingMonitor,
Action <Exception, SQSMessage> onError,
HandlerMap handlerMap)
{
_queue = queue;
_serialisationRegister = serialisationRegister;
_messagingMonitor = messagingMonitor;
_onError = onError;
_handlerMap = handlerMap;
}
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)
{
_queue = queue;
_serialisationRegister = serialisationRegister;
_messagingMonitor = messagingMonitor;
_onError = onError;
_handlerMap = handlerMap;
_log = loggerFactory.CreateLogger("JustSaying");
}
public async Task Setup()
{
// Setup
_globalErrorHandler = (ex, m) => { _handledException = true; };
_monitoring = Substitute.For<IMessageMonitor>();
// Given
_handler = new ThrowingHandler();
var bus = CreateMeABus.InRegion(RegionEndpoint.EUWest1.SystemName)
.WithMonitoring(_monitoring)
.ConfigurePublisherWith(c =>
{
c.PublishFailureBackoffMilliseconds = 1;
c.PublishFailureReAttempts = 3;
})
.WithSnsMessagePublisher<GenericMessage>()
.WithSqsTopicSubscriber()
.IntoQueue("queuename")
.ConfigureSubscriptionWith(cfg =>
{
cfg.MessageRetentionSeconds = 60;
cfg.InstancePosition = 1;
cfg.OnError = _globalErrorHandler;
})
.WithMessageHandler(_handler);
// When
bus.StartListening();
bus.Publish(new GenericMessage());
// Teardown
await _handler.DoneSignal.Task;
bus.StopListening();
}
public DefaultThrottledThroughput(IMessageMonitor messageMonitor) :
base(MaxActiveHandlersForProcessors(), messageMonitor)
{
}
public void SetUp()
{
_fakeMonitor = Substitute.For<IMessageMonitor>();
}
public DefaultThrottledThroughput(IMessageMonitor messageMonitor) :
base(MaxActiveHandlersForProcessors(), MessageConstants.MaxAmazonMessageCap, messageMonitor)
{
}
public Throttled(int maxWorkers, IMessageMonitor messageMonitor)
{
_messageMonitor = messageMonitor;
MaxWorkers = maxWorkers;
_semaphore = new SemaphoreSlim(maxWorkers, maxWorkers);
}
public Throttled(int maximumAllowedMesagesInFlight, int maximumBatchSize, IMessageMonitor messageMonitor)
: this(() => maximumAllowedMesagesInFlight, maximumBatchSize, messageMonitor)
{}
