private async Task AssertMessagePublishedAndReceivedAsync <T>(
IServiceCollection services,
IHandlerAsync <T> handler,
TaskCompletionSource <object> completionSource)
where T : Message, new()
{
IServiceProvider serviceProvider = services.BuildServiceProvider();
IMessagePublisher publisher = serviceProvider.GetRequiredService <IMessagePublisher>();
IMessagingBus listener = serviceProvider.GetRequiredService <IMessagingBus>();
using var source = new CancellationTokenSource(Timeout);
await listener.StartAsync(source.Token);
await publisher.StartAsync(source.Token);
var message = new T();
// Act
await publisher.PublishAsync(message, source.Token);
// Assert
try
{
completionSource.Task.Wait(source.Token);
}
catch (OperationCanceledException)
{
// Ignore
}
await handler.Received(1).Handle(Arg.Is <T>((p) => p.UniqueKey() == message.UniqueKey()));
}
/// <summary>
/// Set message handlers for the given topic
/// </summary>
/// <typeparam name="T">Message type to be handled</typeparam>
/// <param name="handler">Handler for the message type</param>
/// <returns></returns>
public IHaveFulfilledSubscriptionRequirements WithMessageHandler <T>(IHandlerAsync <T> handler) where T : Message
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
if (_serializationFactory == null)
{
throw new InvalidOperationException($"No {nameof(IMessageSerializationFactory)} has been configured.");
}
// TODO - Subscription listeners should be just added once per queue,
// and not for each message handler
var thing = _subscriptionConfig.SubscriptionType == SubscriptionType.PointToPoint
? PointToPointHandler <T>()
: TopicHandler <T>();
Bus.SerializationRegister.AddSerializer <T>(_serializationFactory.GetSerializer <T>());
foreach (var region in Bus.Config.Regions)
{
Bus.AddMessageHandler(region, _subscriptionConfig.QueueName, () => handler);
}
_log.LogInformation(
"Added a message handler of type '{HandlerType}' for message type '{MessageType}' on queue '{QueueName}'.",
handler.GetType(),
typeof(T),
_subscriptionConfig.QueueName);
return(thing);
}
public ExactlyOnceHandler(IHandlerAsync <T> inner, IMessageLockAsync messageLock, TimeSpan timeout, string handlerName)
{
_inner = inner;
_messageLock = messageLock;
_timeout = timeout;
_lockSuffixKeyForHandler = $"{typeof(T).ToString().ToLowerInvariant()}-{handlerName}";
}
public ExactlyOnceHandler(IHandlerAsync <T> inner, IMessageLockAsync messageLock, int timeOut, string handlerName)
{
_inner = inner;
_messageLock = messageLock;
_timeOut = timeOut;
_handlerName = handlerName;
}
private async Task AssertMessagePublishedAndReceivedAsync <T>(
IServiceCollection services,
IHandlerAsync <T> handler,
TaskCompletionSource <object> completionSource)
where T : Message
{
IServiceProvider serviceProvider = services.BuildServiceProvider();
IMessagePublisher publisher = serviceProvider.GetRequiredService <IMessagePublisher>();
IMessagingBus listener = serviceProvider.GetRequiredService <IMessagingBus>();
using (var source = new CancellationTokenSource(Timeout))
{
listener.Start(source.Token);
var message = new SimpleMessage();
// Act
await publisher.PublishAsync(message, source.Token);
// Assert
completionSource.Task.Wait(source.Token);
await handler.Received(1).Handle(Arg.Any <T>());
}
}
protected override void Given()
{
base.Given();
_subscriber = Substitute.For<INotificationSubscriber>();
_handler1 = Substitute.For<IHandlerAsync<Message>>();
_handler2 = Substitute.For<IHandlerAsync<Message2>>();
_region = "west-1";
}
protected override void Given()
{
base.Given();
_subscriber = Substitute.For <INotificationSubscriber>();
_handler1 = Substitute.For <IHandlerAsync <Message> >();
_handler2 = Substitute.For <IHandlerAsync <Message2> >();
_region = "west-1";
}
protected override void Given()
{
base.Given();
_futureHandler1 = () => _handler1;
_futureHandler2 = () => _handler2;
_queue = Substitute.For <ISqsQueue>();
_handler1 = Substitute.For <IHandlerAsync <Message> >();
_handler2 = Substitute.For <IHandlerAsync <Message2> >();
}
private IHandlerAsync <T> MaybeWrapWithStopwatch <T>(IHandlerAsync <T> handler) where T : Message
{
if (!(_messagingMonitor is IMeasureHandlerExecutionTime executionTimeMonitoring))
{
return(handler);
}
return(new StopwatchHandler <T>(handler, executionTimeMonitoring));
}
// final
public AdminkaRoutineHandlerBaseAsync(
ApplicationSettings applicationSettings,
Func <TUserContext, string> getAuditStamp,
IHandlerAsync <RoutineClosure <TUserContext> > routineHandler
) : base(
closure => new PerCallContainer <TUserContext>(closure, applicationSettings, getAuditStamp),
routineHandler
)
{
}
private IHandlerAsync <T> MaybeWrapStopwatch <T>(IHandlerAsync <T> handler) where T : Message
{
var executionTimeMonitoring = _messagingMonitor as IMeasureHandlerExecutionTime;
if (executionTimeMonitoring == null)
{
return(handler);
}
return(new StopwatchHandler <T>(handler, executionTimeMonitoring));
}
public static ExactlyOnceReader ReadExactlyOnce <T>(IHandlerAsync <T> handler) where T : Message
{
var asyncingHandler = handler as BlockingHandler <T>;
if (asyncingHandler != null)
{
return(ReadExactlyOnce(asyncingHandler.Inner));
}
return(new ExactlyOnceReader(handler.GetType()));
}
protected override async Task Given()
{
await base.Given();
_futureHandler1 = () => _handler1;
_futureHandler2 = () => _handler2;
_subscriber = Substitute.For <INotificationSubscriber>();
_handler1 = Substitute.For <IHandlerAsync <Message> >();
_handler2 = Substitute.For <IHandlerAsync <Message2> >();
_region = "west-1";
}
protected IHandlerAsync <T> CreateHandler <T>(TaskCompletionSource <object> completionSource)
where T : Message
{
IHandlerAsync <T> handler = Substitute.For <IHandlerAsync <T> >();
handler.Handle(Arg.Any <T>())
.Returns(true)
.AndDoes((_) => completionSource.TrySetResult(null));
return(handler);
}
protected override void Given()
{
base.Given();
_handler1 = Substitute.For <IHandlerAsync <Message> >();
_handler2 = Substitute.For <IHandlerAsync <Message2> >();
_futureHandler1 = new DelegateMessageHandlingMiddleware <Message>(m => _handler1.Handle(m));
_futureHandler2 = new DelegateMessageHandlingMiddleware <Message2>(m => _handler2.Handle(m));
_queue = Substitute.For <ISqsQueue>();
}
public LoggingDomStorageRoutineHandlerAsync(
AdminkaStorageConfiguration adminkaStorageConfiguration,
TUserContext userContext,
Action <string> efDbContextVerbose,
IHandlerAsync <RoutineClosure <TUserContext> > routineHandler,
Func <TUserContext, string> getAudit) :
this(
LoggingDomDataAccessEfCoreManager.LoggingDomEntityMetaServiceContainer,
userContext,
() => LoggingDomDataAccessEfCoreManager.CreateLoggingDomDbContext(adminkaStorageConfiguration, efDbContextVerbose),
routineHandler, getAudit)
{
}
public void Subscribe <TMessage, THandler>(IHandlerAsync <TMessage> handler)
where TMessage : Message
where THandler : class, IHandlerAsync <TMessage>
{
var queueName = this.queueNamingStrategy.GetName(typeof(TMessage));
var queueUrl = this.sqsService.GetQueueUrl(queueName);
Queues.Add(queueName, new QueueInfo(typeof(TMessage), queueUrl));
var handlerResolver = new HandlerResolver();
handlerResolver.Add(new HandlerWrapper <TMessage>(handler));
handlerResolvers.Add(handlerResolver);
}
/// <summary>
/// Set message handlers for the given topic
/// </summary>
/// <typeparam name="T">Message type to be handled</typeparam>
/// <param name="handler">Handler for the message type</param>
/// <returns></returns>
public IHaveFulfilledSubscriptionRequirements WithMessageHandler <T>(IHandlerAsync <T> handler) where T : Message
{
// TODO - Subscription listeners should be just added once per queue,
// and not for each message handler
var thing = _subscriptionConfig.SubscriptionType == SubscriptionType.PointToPoint
? PointToPointHandler <T>()
: TopicHandler <T>();
Bus.SerialisationRegister.AddSerialiser <T>(_serialisationFactory.GetSerialiser <T>());
foreach (var region in Bus.Config.Regions)
{
Bus.AddMessageHandler(region, _subscriptionConfig.QueueName, () => handler);
}
_log.LogInformation($"Added a message handler - MessageType: {typeof(T)}, QueueName: {_subscriptionConfig.QueueName}, HandlerType: {handler.GetType()}");
return(thing);
}
private LoggingDomStorageRoutineHandlerAsync(
IEntityMetaServiceContainer entityMetaServiceContainer,
TUserContext userContext,
Func <LoggingDomDbContext> createDbContext,
IHandlerAsync <RoutineClosure <TUserContext> > routineHandler,
Func <TUserContext, string> getAudit) :
base(
entityMetaServiceContainer,
createDbContext,
() => new ValueTuple <LoggingDomDbContext, IAuditVisitor>(
createDbContext(),
new AuditVisitor <IVersioned>(
(e) => { e.RowVersionAt = DateTime.Now; e.RowVersionBy = getAudit(userContext); })
),
routineHandler)
{
}
protected override async Task <bool> RunInnerAsync(
HandleMessageContext context,
Func <CancellationToken, Task <bool> > func,
CancellationToken stoppingToken)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
stoppingToken.ThrowIfCancellationRequested();
var resolutionContext = new HandlerResolutionContext(context.QueueName);
IHandlerAsync <T> handler = _handlerResolver(resolutionContext);
return(await handler.Handle(context.MessageAs <T>()).ConfigureAwait(false));
}
private IHandlerAsync <T> MaybeWrapWithExactlyOnce <T>(IHandlerAsync <T> handler) where T : Message
{
var handlerType = handler.GetType();
var exactlyOnceMetadata = new ExactlyOnceReader(handlerType);
if (!exactlyOnceMetadata.Enabled)
{
return(handler);
}
if (_messageLock == null)
{
throw new Exception("IMessageLock is null. You need to specify an implementation for IMessageLock.");
}
var handlerName = handlerType.FullName.ToLower();
return(new ExactlyOnceHandler <T>(handler, _messageLock, exactlyOnceMetadata.GetTimeOut(), handlerName));
}
/// <summary>
/// Set message handlers for the given topic
/// </summary>
/// <typeparam name="T">Message type to be handled</typeparam>
/// <param name="handler">Handler for the message type</param>
/// <returns></returns>
public IHaveFulfilledSubscriptionRequirements WithMessageHandler <T>(IHandlerAsync <T> handler) where T : Message
{
// TODO - Subscription listeners should be just added once per queue,
// and not for each message handler
var thing = _subscriptionConfig.SubscriptionType == SubscriptionType.PointToPoint
? PointToPointHandler <T>()
: TopicHandler <T>();
Bus.SerialisationRegister.AddSerialiser <T>(_serialisationFactory.GetSerialiser <T>());
foreach (var region in Bus.Config.Regions)
{
Bus.AddMessageHandler(region, _subscriptionConfig.QueueName, () => handler);
}
var messageTypeName = GetMessageTypeName <T>();
Log.Info(string.Format("Added a message handler - MessageName: {0}, QueueName: {1}, HandlerName: {2}", messageTypeName, _subscriptionConfig.QueueName, handler.GetType().Name));
return(thing);
}
private IHandlerAsync <T> MaybeWrapWithExactlyOnce <T>(IHandlerAsync <T> handler) where T : Message
{
var handlerType = handler.GetType();
var exactlyOnceMetadata = new ExactlyOnceReader(handlerType);
if (!exactlyOnceMetadata.Enabled)
{
return(handler);
}
if (_messageLock == null)
{
throw new Exception("IMessageLock is null. You need to specify an implementation for IMessageLock.");
}
var handlerName = handlerType.FullName.ToLowerInvariant();
var timeout = TimeSpan.FromSeconds(exactlyOnceMetadata.GetTimeOut());
var logger = _loggerFactory.CreateLogger <ExactlyOnceHandler <T> >();
return(new ExactlyOnceHandler <T>(handler, _messageLock, timeout, handlerName, logger));
}
public static ComplexRoutineHandlerAsync <StorageRoutineHandlerAsync <TUserContext>, TUserContext> GetContainerStorageHandlerAsync <TUserContext>(
ContainerFactory containerFactory,
MemberTag memberTag,
AspRoutineFeature aspRoutineFeature,
Func <object> getInput,
TUserContext userContext,
ApplicationSettings applicationSettings,
//Func<TUserContext, string> getConfigurationFor,
Func <TUserContext, string> getAuditStamp
)
{
var adminkaRoutineHandlerFactory = new AdminkaRoutineHandlerFactory <TUserContext>(
correlationToken: Guid.NewGuid(),
InjectedManager.DefaultRoutineTagTransformException,
InjectedManager.ComposeNLogMemberLoggerFactory(null),
applicationSettings.PerformanceCounters);
IHandlerAsync <RoutineClosure <TUserContext> > loggingHandler = adminkaRoutineHandlerFactory.CreateLoggingHandler(
memberTag,
containerFactory.CreateContainer(memberTag, getAuditStamp(userContext)),
userContext,
hasVerboseLoggingPrivilege: false,
getInput());
return(new ComplexRoutineHandlerAsync <StorageRoutineHandlerAsync <TUserContext>, TUserContext> /*AdminkaRoutineHandlerBase<TUserContext>*/ (
closure => new AuthenticationDomStorageRoutineHandlerAsync <TUserContext>(
applicationSettings.AdminkaStorageConfiguration,
userContext,
null,
new Handler <RoutineClosure <TUserContext>, RoutineClosure <TUserContext> >(
() => closure,
closure
),
getAudit: uc => getAuditStamp(uc)
),
loggingHandler
));
}
protected override void Given()
{
LoggerFactory = new LoggerFactory();
Sqs = Substitute.For <IAmazonSQS>();
SerialisationRegister = Substitute.For <IMessageSerialisationRegister>();
Monitor = Substitute.For <IMessageMonitor>();
Handler = Substitute.For <IHandlerAsync <SimpleMessage> >();
LoggerFactory = Substitute.For <ILoggerFactory>();
var response = GenerateResponseMessage(MessageTypeString, Guid.NewGuid());
Sqs.ReceiveMessageAsync(
Arg.Any <ReceiveMessageRequest>(),
Arg.Any <CancellationToken>())
.Returns(
x => Task.FromResult(response),
x => Task.FromResult(new ReceiveMessageResponse()));
DeserialisedMessage = new SimpleMessage {
RaisingComponent = "Component"
};
SerialisationRegister.DeserializeMessage(Arg.Any <string>()).Returns(DeserialisedMessage);
}
public async Task CheckForMessages <T>(QueueInfo queue) where T : Message
{
var queueUrl = queue.Url;
var response = this.sqsService.ReceiveMessageAsync(queueUrl);
if (response.Result.Messages.Count > 0)
{
var busMessage = response.Result.Messages.First();
T message = messageDeserializer.Deserialize <T>(busMessage);
IHandlerAsync <T> handler = this.messageBus.GetHandler <T>();
if (handler != null)
{
var isSuccess = await handler.Handle(message);
if (isSuccess)
{
await this.DeleteMessageAsync(queueUrl, busMessage.ReceiptHandle);
}
}
}
}
public StopwatchHandler(IHandlerAsync <T> inner, IMeasureHandlerExecutionTime monitoring)
{
_inner = inner;
_monitoring = monitoring;
_handlerType = _inner.GetType();
}
public StopwatchHandler(IHandlerAsync <T> inner, IMeasureHandlerExecutionTime monitoring)
{
_inner = inner;
_monitoring = monitoring;
}
public SignallingHandler(TaskCompletionSource <object> doneSignal, IHandlerAsync <T> inner)
{
_doneSignal = doneSignal;
_inner = inner;
}
public static ExactlyOnceReader ReadExactlyOnce <T>(IHandlerAsync <T> handler) where T : Message
{
return(new ExactlyOnceReader(handler.GetType()));
}
public ComplexRoutineHandlerAsync2(
Func <RoutineClosure <TUserContext>, Task <TClosure> > createResource,
IHandlerAsync <RoutineClosure <TUserContext> > handler
) : base(createResource, handler)
{
}
