public IHaveFulfilledSubscriptionRequirements WithMessageHandler <T>(IHandlerResolver handlerResolver) where T : Message
{
if (handlerResolver is null)
{
throw new ArgumentNullException(nameof(handlerResolver));
}
_subscriptionConfig.TopicName = GetOrUseTopicNamingConvention <T>(_subscriptionConfig.TopicName);
_subscriptionConfig.QueueName = GetOrUseQueueNamingConvention <T>(_subscriptionConfig.QueueName);
_subscriptionConfig.SubscriptionGroupName ??= _subscriptionConfig.QueueName;
var thing = _subscriptionConfig.SubscriptionType == SubscriptionType.PointToPoint
? PointToPointHandler <T>()
: TopicHandler <T>();
var resolutionContext = new HandlerResolutionContext(_subscriptionConfig.QueueName);
var proposedHandler = handlerResolver.ResolveHandler <T>(resolutionContext);
if (proposedHandler == null)
{
throw new HandlerNotRegisteredWithContainerException($"There is no handler for '{typeof(T)}' messages.");
}
Bus.AddMessageHandler(_subscriptionConfig.QueueName, () => handlerResolver.ResolveHandler <T>(resolutionContext));
_log.LogInformation(
"Added a message handler for message type for '{MessageType}' on topic '{TopicName}' and queue '{QueueName}'.",
typeof(T),
_subscriptionConfig.TopicName,
_subscriptionConfig.QueueName);
return(thing);
}
public ExceptionCentricTestSpecificationRunner(IExceptionComparer comparer, IFactWriter factWriter, IFactReader factReader, IHandlerResolver handlerResolver)
{
_comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
_factWriter = factWriter ?? throw new ArgumentNullException(nameof(factWriter));
_factReader = factReader ?? throw new ArgumentNullException(nameof(factReader));
_handlerResolver = handlerResolver ?? throw new ArgumentNullException(nameof(handlerResolver));
}
public IHaveFulfilledSubscriptionRequirements WithMessageHandler <T>(IHandlerResolver handlerResolver) where T : Message
{
if (_serializationFactory == null)
{
throw new InvalidOperationException($"No {nameof(IMessageSerializationFactory)} has been configured.");
}
var thing = _subscriptionConfig.SubscriptionType == SubscriptionType.PointToPoint
? PointToPointHandler <T>()
: TopicHandler <T>();
Bus.SerializationRegister.AddSerializer <T>(_serializationFactory.GetSerializer <T>());
var resolutionContext = new HandlerResolutionContext(_subscriptionConfig.QueueName);
var proposedHandler = handlerResolver.ResolveHandler <T>(resolutionContext);
if (proposedHandler == null)
{
throw new HandlerNotRegisteredWithContainerException($"There is no handler for '{typeof(T)}' messages.");
}
foreach (var region in Bus.Config.Regions)
{
Bus.AddMessageHandler(region, _subscriptionConfig.QueueName, () => handlerResolver.ResolveHandler <T>(resolutionContext));
}
_log.LogInformation(
"Added a message handler for message type for '{MessageType}' on topic '{TopicName}' and queue '{QueueName}'.",
typeof(T),
_subscriptionConfig.Topic,
_subscriptionConfig.QueueName);
return(thing);
}
internal DefaultHandlerSettings(
[NotNull] IHandlerResolver handlerModule,
[NotNull] IRequestTypeResolver requestTypeResolver,
IExceptionToModelConverter exceptionToModelConverter = null)
: this(Enumerable.Repeat(handlerModule, 1), requestTypeResolver, exceptionToModelConverter)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="DurableCommitDispatcher"/> class.
/// </summary>
/// <param name="eventStoreClient">An event store client.</param>
/// <param name="checkpointRepository">A checkpoint repository. Each instane of a <see cref="DurableCommitDispatcher"/>
/// should have their own instance of a <see cref="ICheckpointRepository"/>.</param>
/// <param name="handlerResolver">A collection of handler modules to dispatch the commit to.</param>
/// <exception cref="System.ArgumentNullException">
/// eventStoreClient
/// or
/// checkpointRepository
/// or
/// dispatchCommit
/// </exception>
public DurableCommitDispatcher(
[NotNull] IEventStoreClient eventStoreClient,
[NotNull] ICheckpointRepository checkpointRepository,
[NotNull] IHandlerResolver handlerResolver)
: this(eventStoreClient, checkpointRepository, handlerResolver.DispatchCommit)
{
}
public IHaveFulfilledSubscriptionRequirements WithMessageHandler <T>(IHandlerResolver handlerResolver) where T : Message
{
var thing = _subscriptionConfig.SubscriptionType == SubscriptionType.PointToPoint
? PointToPointHandler <T>()
: TopicHandler <T>();
Bus.SerialisationRegister.AddSerialiser <T>(_serialisationFactory.GetSerialiser <T>());
if (!handlerResolver.ResolveHandlers <T>().Any())
{
throw new HandlerNotRegisteredWithContainerException(string.Format("IHandler<{0}> is not regsistered in the container.", typeof(T).Name));
}
if (handlerResolver.ResolveHandlers <T>().Count() > 1)
{
throw new NotSupportedException(string.Format("There are more than one registration for IHandler<{0}>. JustSaying currently does not support multiple registration for IHandler<T>.", typeof(T).Name));
}
foreach (var region in Bus.Config.Regions)
{
Bus.AddMessageHandler(region,
_subscriptionConfig.QueueName,
() => handlerResolver.ResolveHandlers <T>().Single());
}
Log.Info(string.Format("Added a message handler - Topic: {0}, QueueName: {1}, HandlerName: IHandler<{2}>", _subscriptionConfig.Topic, _subscriptionConfig.QueueName, typeof(T)));
return(thing);
}
public IHaveFulfilledSubscriptionRequirements WithMessageHandler <T>(IHandlerResolver handlerResolver) where T : Message
{
var thing = _subscriptionConfig.SubscriptionType == SubscriptionType.PointToPoint
? PointToPointHandler <T>()
: TopicHandler <T>();
Bus.SerialisationRegister.AddSerialiser <T>(_serialisationFactory.GetSerialiser <T>());
var resolutionContext = new HandlerResolutionContext(_subscriptionConfig.QueueName);
var proposedHandler = handlerResolver.ResolveHandler <T>(resolutionContext);
if (proposedHandler == null)
{
throw new HandlerNotRegisteredWithContainerException($"There is no handler for '{typeof(T).Name}' messages.");
}
foreach (var region in Bus.Config.Regions)
{
Bus.AddMessageHandler(region, _subscriptionConfig.QueueName, () => handlerResolver.ResolveHandler <T>(resolutionContext));
}
_log.LogInformation($"Added a message handler - Topic: {_subscriptionConfig.Topic}, QueueName: {_subscriptionConfig.QueueName}, HandlerName: IHandler<{typeof(T)}>");
return(thing);
}
public DefaultHandlerSettings(
[NotNull] IHandlerResolver handlerModule,
[NotNull] IRequestTypeResolver requestTypeResolver,
IExceptionToModelConverter exceptionToModelConverter = null)
: this(new[] { handlerModule }, requestTypeResolver, exceptionToModelConverter)
{
}
public QueryProcessor(IHandlerResolver handlerResolver,
ICacheManager cacheManager,
IOptions <CacheOptions> cacheOptions)
{
_handlerResolver = handlerResolver;
_cacheManager = cacheManager;
_cacheOptions = cacheOptions.Value;
}
public static Task DispatchSingle <TMessage>(
[NotNull] this IHandlerResolver handlerModules,
TMessage message,
CancellationToken cancellationToken)
where TMessage : class
{
return(new[] { handlerModules }.DispatchSingle(message, cancellationToken));
}
public QueryDispatcher(IHandlerResolver handlerResolver)
{
if (handlerResolver == null)
{
throw new ArgumentNullException(nameof(handlerResolver));
}
this.handlerResolver = handlerResolver;
}
/// <summary>
/// Specifies the <see cref="IHandlerResolver"/> to use.
/// </summary>
/// <param name="handlerResolver">The <see cref="IHandlerResolver"/> to use.</param>
/// <returns>
/// The current <see cref="ServicesBuilder"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="handlerResolver"/> is <see langword="null"/>.
/// </exception>
public ServicesBuilder WithHandlerResolver(IHandlerResolver handlerResolver)
{
if (handlerResolver == null)
{
throw new ArgumentNullException(nameof(handlerResolver));
}
return(WithHandlerResolver(() => handlerResolver));
}
/// <summary>
/// Initializes a new instance of the <see cref="DurableCommitDispatcher"/> class.
/// </summary>
/// <param name="eventStoreClient">An event store client.</param>
/// <param name="checkpointRepository">A checkpoint repository. Each instane of a <see cref="DurableCommitDispatcher"/>
/// should have their own instance of a <see cref="ICheckpointRepository"/>.</param>
/// <param name="handlerModule">A handler module to dispatch the commit to.</param>
/// <param name="retryPolicy">A retry policy when a <see cref="TransientException"/> occurs.
/// If none specified TransientException.None is used.</param>
/// <exception cref="System.ArgumentNullException">
/// eventStoreClient
/// or
/// checkpointRepository
/// or
/// dispatchCommit
/// </exception>
public DurableCommitDispatcher(
[NotNull] IEventStoreClient eventStoreClient,
[NotNull] ICheckpointRepository checkpointRepository,
[NotNull] IHandlerResolver handlerModule,
TransientExceptionRetryPolicy retryPolicy = null) :
this(eventStoreClient, checkpointRepository, new[] { handlerModule }, retryPolicy)
{
Guard.EnsureNotNull(handlerModule, "handlerModule");
}
public Configuration WithHandlerResolver(IHandlerResolver container)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
HandlerResolver = container;
return(this);
}
/// <inheritdoc />
void ISubscriptionBuilder <T> .Configure(
JustSayingBus bus,
IHandlerResolver resolver,
IVerifyAmazonQueues creator,
ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <TopicSubscriptionBuilder <T> >();
var subscriptionConfig = new SqsReadConfiguration(SubscriptionType.ToTopic)
{
QueueName = TopicName
};
ConfigureReads?.Invoke(subscriptionConfig);
var config = bus.Config;
subscriptionConfig.ApplyTopicNamingConvention <T>(config.TopicNamingConvention);
subscriptionConfig.ApplyQueueNamingConvention <T>(config.QueueNamingConvention);
subscriptionConfig.SubscriptionGroupName ??= subscriptionConfig.QueueName;
subscriptionConfig.PublishEndpoint = subscriptionConfig.TopicName;
subscriptionConfig.Validate();
var queueWithStartup = creator.EnsureTopicExistsWithQueueSubscribed(
config.Region,
bus.SerializationRegister,
subscriptionConfig,
config.MessageSubjectProvider);
bus.AddStartupTask(queueWithStartup.StartupTask);
bus.AddQueue(subscriptionConfig.SubscriptionGroupName, queueWithStartup.Queue);
logger.LogInformation(
"Created SQS topic subscription on topic '{TopicName}' and queue '{QueueName}'.",
subscriptionConfig.TopicName,
subscriptionConfig.QueueName);
var resolutionContext = new HandlerResolutionContext(subscriptionConfig.QueueName);
var proposedHandler = resolver.ResolveHandler <T>(resolutionContext);
if (proposedHandler == null)
{
throw new HandlerNotRegisteredWithContainerException(
$"There is no handler for '{typeof(T)}' messages.");
}
bus.AddMessageHandler(subscriptionConfig.QueueName,
() => resolver.ResolveHandler <T>(resolutionContext));
logger.LogInformation(
"Added a message handler for message type for '{MessageType}' on topic '{TopicName}' and queue '{QueueName}'.",
typeof(T),
subscriptionConfig.TopicName,
subscriptionConfig.QueueName);
}
internal ServiceBusEventBus(ISubscriptionClient subscriptionClient, ITopicClient topicClient, ServiceBusOptions serviceBusOptions,
ISubscriptionManager subscriptionManager, IHandlerResolver handlerResolver, ILogger <ServiceBusEventBus> logger)
{
_subscriptionClient = subscriptionClient ?? throw new ArgumentNullException(nameof(subscriptionClient));
_topicClient = topicClient ?? throw new ArgumentNullException(nameof(topicClient));
_serviceBusOptions = serviceBusOptions ?? throw new ArgumentNullException(nameof(serviceBusOptions));
_subscriptionManager = subscriptionManager ?? throw new ArgumentNullException(nameof(subscriptionManager));
_handlerResolver = handlerResolver ?? throw new ArgumentNullException(nameof(handlerResolver));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public CommandSender(IHandlerResolver handlerResolver,
IEventPublisher eventPublisher,
IEventFactory eventFactory,
IOptions<Options> options)
{
_handlerResolver = handlerResolver;
_eventPublisher = eventPublisher;
_eventFactory = eventFactory;
_options = options.Value;
}
public AkkaCommandBus(IHandlerResolver concurrentEventBusProxy, IBusHelper busHelper, IAuthenticationTokenHelper <TAuthenticationToken> authenticationTokenHelper, ICorrelationIdHelper correlationIdHelper, IDependencyResolver dependencyResolver, ILogger logger)
{
ConcurrentEventBusProxy = concurrentEventBusProxy;
Logger = logger;
BusHelper = busHelper;
AuthenticationTokenHelper = authenticationTokenHelper;
CorrelationIdHelper = correlationIdHelper;
DependencyResolver = dependencyResolver;
EventWaits = new ConcurrentDictionary <Guid, IList <IEvent <TAuthenticationToken> > >();
}
public ResolvedEventDispatcher(
IEventStoreConnection eventStore,
ISerializer serializer,
ICheckpointRepository checkpoints,
[NotNull] IHandlerResolver handlerResolver,
Action onCaughtUp = null,
string streamId = null,
UserCredentials userCredentials = null)
: this(eventStore, serializer, checkpoints, handlerResolver.DispatchResolvedEvent, onCaughtUp, streamId, userCredentials)
{
}
private static Task DispatchDomainEvent <TDomainEvent>(
IHandlerResolver handlerModule,
ICommit commit,
int version,
EventMessage eventMessage,
CancellationToken cancellationToken)
where TDomainEvent : class
{
var message = NEventStoreMessage.Create <TDomainEvent>(eventMessage, commit, version);
return(handlerModule.Dispatch(message, cancellationToken));
}
/// <inheritdoc />
void ISubscriptionBuilder <T> .Configure(JustSayingFluently bus, IHandlerResolver resolver)
{
var queue = bus.WithSqsPointToPointSubscriber()
.IntoQueue(QueueName);
if (ConfigureReads != null)
{
queue.ConfigureSubscriptionWith(ConfigureReads);
}
queue.WithMessageHandler <T>(resolver);
}
public CommandSenderAsync(IHandlerResolver handlerResolver,
IEventPublisherAsync eventPublisherAsync,
IEventFactory eventFactory,
IEventStore eventStore,
ICommandStore commandStore)
{
_handlerResolver = handlerResolver;
_eventPublisherAsync = eventPublisherAsync;
_eventFactory = eventFactory;
_eventStore = eventStore;
_commandStore = commandStore;
}
public CommandSender(IHandlerResolver handlerResolver,
IEventPublisher eventPublisher,
IEventFactory eventFactory,
IEventStore eventStore,
ICommandStore commandStore)
{
_eventPublisher = eventPublisher;
_eventFactory = eventFactory;
_eventStore = eventStore;
_commandStore = commandStore;
_handlerResolver = handlerResolver;
}
/// <inheritdoc />
void ISubscriptionBuilder <T> .Configure(JustSayingFluently bus, IHandlerResolver resolver)
{
var topic = bus.WithSqsTopicSubscriber()
.IntoQueue(TopicName);
if (ConfigureReads != null)
{
topic.ConfigureSubscriptionWith(ConfigureReads);
}
topic.WithMessageHandler <T>(resolver);
}
public IMediator Build()
{
if (this._resolver == null)
{
this._resolver = new BasicHandlerResolver(handler => (IHandler)Activator.CreateInstance(handler));
}
var handlersFactory = new HandlersFactory(this._handlers, this._defaultHandler);
var mediator = new Mediator(handlersFactory);
return(mediator);
}
/// <inheritdoc />
void ISubscriptionBuilder <T> .Configure(
JustSayingBus bus,
IHandlerResolver resolver,
IVerifyAmazonQueues creator,
ILoggerFactory loggerFactory)
{
var logger = loggerFactory.CreateLogger <QueueSubscriptionBuilder <T> >();
var subscriptionConfig = new SqsReadConfiguration(SubscriptionType.PointToPoint)
{
QueueName = QueueName
};
ConfigureReads?.Invoke(subscriptionConfig);
var config = bus.Config;
subscriptionConfig.ApplyTopicNamingConvention <T>(config.TopicNamingConvention);
subscriptionConfig.ApplyQueueNamingConvention <T>(config.QueueNamingConvention);
subscriptionConfig.SubscriptionGroupName ??= subscriptionConfig.QueueName;
subscriptionConfig.Validate();
var queue = creator.EnsureQueueExists(config.Region, subscriptionConfig);
bus.AddStartupTask(
queue.Queue.EnsureQueueAndErrorQueueExistAndAllAttributesAreUpdatedAsync(subscriptionConfig));
bus.AddQueue(subscriptionConfig.SubscriptionGroupName, queue.Queue);
logger.LogInformation(
"Created SQS subscriber for message type '{MessageType}' on queue '{QueueName}'.",
typeof(T),
subscriptionConfig.QueueName);
var resolutionContext = new HandlerResolutionContext(subscriptionConfig.QueueName);
var proposedHandler = resolver.ResolveHandler <T>(resolutionContext);
if (proposedHandler == null)
{
throw new HandlerNotRegisteredWithContainerException(
$"There is no handler for '{typeof(T)}' messages.");
}
bus.AddMessageHandler(subscriptionConfig.QueueName,
() => resolver.ResolveHandler <T>(resolutionContext));
logger.LogInformation(
"Added a message handler for message type for '{MessageType}' on topic '{TopicName}' and queue '{QueueName}'.",
typeof(T),
subscriptionConfig.TopicName,
subscriptionConfig.QueueName);
}
public CommandSender(IHandlerResolver handlerResolver,
IEventPublisher eventPublisher,
IEventFactory eventFactory,
IEventStore eventStore,
ICommandStore commandStore,
IOptions <EventOptions> options = null)
{
_eventPublisher = eventPublisher;
_eventFactory = eventFactory;
_eventStore = eventStore;
_commandStore = commandStore;
_handlerResolver = handlerResolver;
_supportTransactions = options?.Value.SupportTransactions ?? false;
}
public CommandSender(IHandlerResolver handlerResolver,
IEventPublisher eventPublisher,
IEventFactory eventFactory,
IDomainStore domainStore,
IValidationService validationService,
IOptions <Options> options)
{
_handlerResolver = handlerResolver;
_eventPublisher = eventPublisher;
_eventFactory = eventFactory;
_domainStore = domainStore;
_validationService = validationService;
_options = options.Value;
}
private static Task DispatchDomainEvent <TDomainEvent>(
IHandlerResolver handlerResolver,
[NotNull] ISerializer serializer,
TDomainEvent domainEvent,
IDictionary <string, object> headers,
ResolvedEvent resolvedEvent,
bool isSubscribedToAll,
CancellationToken cancellationToken)
where TDomainEvent : class
{
var message = GetEventStoreMessage.Create(domainEvent, headers, resolvedEvent, isSubscribedToAll);
return(handlerResolver.Dispatch(message, cancellationToken));
}
public CommandSender(IHandlerResolver handlerResolver,
IEventPublisher eventPublisher,
IObjectFactory objectFactory,
IStoreProvider storeProvider,
IValidationService validationService,
IOptions <Options> options)
{
_handlerResolver = handlerResolver;
_eventPublisher = eventPublisher;
_objectFactory = objectFactory;
_storeProvider = storeProvider;
_validationService = validationService;
_options = options.Value;
}
public ScenarioBuilder(IHandlerResolver module, MidFunc middleware, string name)
{
_module = module;
_name = name;
_given = new object[0];
_runGiven = async () =>
{
foreach(var @event in _given.Select(WrapInEnvelopeIfNecessary))
{
var task = (Task) DispatchDomainEventMethod.MakeGenericMethod(@event.GetType())
.Invoke(null, new object[] {_module, @event, new CancellationToken(),});
await task;
}
};
_runWhen = async () =>
{
using(var client = middleware.Terminate().CreateClient())
{
_when = await _request();
_results = (HttpResponse) await client.SendAsync(_when);
}
};
_runThen = () =>
{
var response = (HttpResponse)_results;
var didNotPass = from assertion in _assertions
let result = assertion.Compile()(response)
where !result
select assertion;
didNotPass.ScenarioFailedIfAny();
};
_assertions = new List<Expression<Func<HttpResponse, bool>>>();
_timer = new Stopwatch();
}
public static Query.IGiven ForQuery(IHandlerResolver handlerResolver, MidFunc middleware, [CallerMemberName] string scenarioName = null)
{
return new Query.ScenarioBuilder(handlerResolver, middleware, scenarioName);
}
public QueryTests()
{
_module = new SomeModule();
_resolver = new HandlerResolver(_module);
}
