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