public virtual void Register(IHandlerRegistrar handlerRegistrar, Func <Type, IEnumerable <Type> > resolveMessageHandlerInterface, bool skipCommandHandlers, params Type[] typesFromAssemblyContainingMessages)
{
foreach (Type typesFromAssemblyContainingMessage in typesFromAssemblyContainingMessages)
{
Assembly executorsAssembly = typesFromAssemblyContainingMessage.Assembly;
var executorTypes = executorsAssembly
.GetTypes()
.Select(type => new { Type = type, Interfaces = resolveMessageHandlerInterface(type) })
.Where(type => type.Interfaces != null && type.Interfaces.Any());
foreach (var executorType in executorTypes)
{
foreach (Type @interface in executorType.Interfaces)
{
Type safeExecutorType = executorType.Type;
if (typesFromAssemblyContainingMessage.IsGenericType && typesFromAssemblyContainingMessage.Name == typeof(DtoCommandHandler <,>).Name)
{
if (skipCommandHandlers)
{
continue;
}
Type[] genericArguments = typesFromAssemblyContainingMessage.GetGenericArguments().Take(2).ToArray();
safeExecutorType = safeExecutorType.MakeGenericType(genericArguments.Take(2).ToArray());
}
InvokeHandler(@interface, handlerRegistrar, resolveMessageHandlerInterface, safeExecutorType);
}
}
}
}
private void InvokeHandler(Type @interface, IHandlerRegistrar registrar, Type executorType)
{
var commandType = @interface.GetGenericArguments()[0];
var registerExecutorMethod = registrar
.GetType()
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Where(mi => mi.Name == "RegisterHandler")
.Where(mi => mi.IsGenericMethod)
.Where(mi => mi.GetGenericArguments().Length == 1)
.Single(mi => mi.GetParameters().Length == 1)
.MakeGenericMethod(commandType);
var del = new Func <dynamic, Task>(x =>
{
dynamic handler = _serviceLocator.GetService(executorType);
if (handler == null)
{
throw new InvalidOperationException($"Cannot finds handler: {executorType}");
}
return(handler.Handle(x));
});
registerExecutorMethod.Invoke(registrar, new object[] { del });
}
private static void InvokeHandler(Type @interface, IHandlerRegistrar registrar, Type executorType, ServiceProvider serviceProvider)
{
var commandType = @interface.GetGenericArguments()[0];
var registerExecutorMethod = registrar
.GetType()
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Where(mi => mi.Name == "RegisterHandler")
.Where(mi => mi.IsGenericMethod)
.Where(mi => mi.GetGenericArguments().Length == 1)
.Single(mi => mi.GetParameters().Length == 1)
.MakeGenericMethod(commandType);
Func <dynamic, CancellationToken, Task> del;
if (IsCancellable(@interface))
{
del = (x, token) =>
{
dynamic handler = serviceProvider.GetService(executorType);
return(handler.Handle(x, token));
};
}
else
{
del = (x, token) =>
{
dynamic handler = serviceProvider.GetService(executorType);
return(handler.Handle(x));
};
}
registerExecutorMethod.Invoke(registrar, new object[] { del });
}
public SimpleEventService()
{
var factory = new DefaultEventHandlerFactory();
var eventBus = new InMemoryEventBus(factory);
_registrar = factory;
_publisher = new EventPublisher(eventBus);
}
public BusRegistrar(IServiceProvider services, IHandlerRegistrar handlerRegistrar)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
_services = services;
_handlerRegistrar = handlerRegistrar;
}
public WebHookManager(IRegisteredEventStore registeredEventStore,
IHandlerRegistrar eventHandlerRegistrar,
IWebHookSearchService webHookSearchService,
IWebHookSender webHookSender,
IBackgroundJobClient backgroundJobClient)
{
_registeredEventStore = registeredEventStore;
_eventHandlerRegistrar = eventHandlerRegistrar;
_webHookSearchService = webHookSearchService;
_webHookSender = webHookSender;
_backgroundJobClient = backgroundJobClient;
}
public DefaultEventBusSubscriptionsManager(IHandlerRegistrar eventHandlerRegistrar,
RegisteredEventService registeredEventService,
ISubscriptionService subscriptionService,
ISubscriptionSearchService subscriptionSearchService,
IEventBusProviderService eventBusFactory)
{
_eventHandlerRegistrar = eventHandlerRegistrar;
_registeredEventService = registeredEventService;
_subscriptionService = subscriptionService;
_subscriptionSearchService = subscriptionSearchService;
_eventBusFactory = eventBusFactory;
}
/// <summary>
/// Extract the <see cref="IHandlerRegistrar.RegisterHandler{TMessage}"/> method from the provided <paramref name="bus"/>
/// Create an <see cref="Action"/> around the provided <paramref name="executorType"/>
/// Then register the created <see cref="Action"/> using the extracted <see cref="IHandlerRegistrar.RegisterHandler{TMessage}"/> method
/// </summary>
/// <param name="executorType">The <see cref="Type"/> of the event handler that will do the handling</param>
protected virtual void InvokeHandler(Type @interface, IHandlerRegistrar bus, Func <Type, IEnumerable <Type> > resolveMessageHandlerInterface, Type executorType)
{
MethodInfo registerExecutorMethod = null;
MethodInfo originalRegisterExecutorMethod = bus
.GetType()
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Where(mi => mi.Name == "RegisterHandler")
.Where(mi => mi.IsGenericMethod)
.Where(mi => mi.GetGenericArguments().Count() == 1)
.Single(mi => mi.GetParameters().Count() == 2);
IList <Type> interfaceGenericArguments = @interface.GetGenericArguments().ToList();
if (interfaceGenericArguments.Count == 2)
{
Type commandType = interfaceGenericArguments[1];
registerExecutorMethod = BuildExecutorMethod(originalRegisterExecutorMethod, executorType, commandType);
}
else
{
foreach (Type commandType in interfaceGenericArguments)
{
try
{
registerExecutorMethod = BuildExecutorMethod(originalRegisterExecutorMethod, executorType, commandType);
break;
}
catch (VerificationException)
{
}
catch (ArgumentException)
{
}
}
}
if (registerExecutorMethod == null)
{
throw new InvalidOperationException("No executor method could be compiled for " + @interface.FullName);
}
HandlerDelegate handlerDelegate = BuildDelegateAction(executorType, resolveMessageHandlerInterface);
InvokeHandlerDelegate(registerExecutorMethod, bus, handlerDelegate);
}
private void InvokeHandler(Type eventType, IHandlerRegistrar registrar)
{
var registerExecutorMethod = registrar
.GetType()
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Where(mi => mi.Name == nameof(IHandlerRegistrar.RegisterHandler))
.Where(mi => mi.IsGenericMethod)
.Where(mi => mi.GetGenericArguments().Length == 1)
.Single(mi => mi.GetParameters().Length == 1)
.MakeGenericMethod(eventType);
Func <DomainEvent, CancellationToken, Task> del = (x, token) =>
{
return(HandleEvent(x, token));
};
registerExecutorMethod.Invoke(registrar, new object[] { del });
}
private static void InvokeHandler(Type @interface, IHandlerRegistrar bus, Type executorType)
{
var commandType = @interface.GenericTypeArguments[0];
var registerExecutorMethod = bus
.GetType().GetRuntimeMethods()
.Where(mi => mi.Name == "RegisterMessageHandler")
.Where(mi => mi.IsGenericMethod)
.Where(mi => mi.GetGenericArguments().Count() == 1)
.Single(mi => mi.GetParameters().Count() == 1)
.MakeGenericMethod(commandType);
var del = new Action <dynamic>(x =>
{
dynamic handler = _container.Resolve(@interface);
handler.Handle(x);
});
registerExecutorMethod.Invoke(bus, new object[] { del });
}
private void InvokeHandler(Type @interface, IHandlerRegistrar registrar, Type executorType)
{
var messageType = @interface.GetGenericArguments()[0];
var registerExecutorMethod = registrar
.GetType()
.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Where(mi => mi.Name == "RegisterHandler")
.Where(mi => mi.IsGenericMethod)
.Where(mi => mi.GetGenericArguments().Length == 1)
.Single(mi => mi.GetParameters().Length == 1)
.MakeGenericMethod(messageType);
Func <object, CancellationToken, Task> func;
if (IsCancellable(@interface))
{
var methodname = executorType.GetImplementationNameOfInterfaceMethod(@interface, "Handle", messageType,
typeof(CancellationToken));
func = (msg, token) =>
{
var handler = _serviceLocator.GetService(executorType) ??
throw new HandlerNotResolvedException(executorType.Name);
return((Task)(handler.Invoke(methodname, msg, token) ??
throw new ResolvedHandlerMethodNotFoundException(executorType.Name)));
};
}
else
{
var methodname = executorType.GetImplementationNameOfInterfaceMethod(@interface, "Handle", messageType);
func = (msg, token) =>
{
var handler = _serviceLocator.GetService(executorType) ??
throw new HandlerNotResolvedException(executorType.Name);
return((Task)(handler.Invoke(methodname, msg) ??
throw new ResolvedHandlerMethodNotFoundException(executorType.Name)));
};
}
registerExecutorMethod.Invoke(registrar, new object[] { func });
}
private void InvokeHandler(Type @interface, IHandlerRegistrar bus, Type executorType)
{
var commandType = @interface.GetGenericArguments()[0];
var registerExecutorMethod = bus.GetType()
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Where(mi => mi.Name == "RegisterHandler")
.Where(mi => mi.IsGenericMethod)
.Where(mi => mi.GetGenericArguments().Count() == 1)
.Single(mi => mi.GetParameters().Count() == 1)
.MakeGenericMethod(commandType);
Action <dynamic> action;
if (@interface.GetGenericTypeDefinition() == CommandHandlerType)
{
action = command =>
{
Type transType = typeof(TransactionalHandler <>).MakeGenericType(command.GetType());
////dynamic b = serviceLocator.Resolve(typeof(TransactionalHandler<CreateSiteCommand>));
dynamic transactionalHandler = this.serviceLocator.Resolve(transType);
transactionalHandler.Handle(command);
};
}
else if (@interface.GetGenericTypeDefinition() == EventHandlerType)
{
action = rootEvent =>
{
dynamic handler = this.serviceLocator.Resolve(executorType);
handler.Handle(rootEvent);
};
}
else
{
throw new IndexOutOfRangeException();
}
registerExecutorMethod.Invoke(bus, new object[] { action });
}
private void InvokeHandler(Type @interface, IHandlerRegistrar bus, Type executorType) {
var commandType = @interface.GetGenericArguments()[0];
var registerExecutorMethod = bus
.GetType()
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Where(mi => mi.Name == "RegisterHandler")
.Where(mi => mi.IsGenericMethod)
.Where(mi => mi.GetGenericArguments().Count() == 1)
.Single(mi => mi.GetParameters().Count() == 1)
.MakeGenericMethod(commandType);
var del = new Action<dynamic>(x =>
{
dynamic handler = _serviceLocator.GetService(executorType);
handler.Handle(x);
});
registerExecutorMethod.Invoke(bus, new object[] { del });
}
private void InvokeHandler(Type @interface, IHandlerRegistrar bus, Type executorType)
{
var commandType = @interface.GetGenericArguments()[0];
var registerExecutorMethod = bus
.GetType()
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Where(mi => mi.Name == "RegisterHandler")
.Where(mi => mi.IsGenericMethod)
.Where(mi => mi.GetGenericArguments().Count() == 1)
.Single(mi => mi.GetParameters().Count() == 1)
.MakeGenericMethod(commandType);
var del = new Action <dynamic>(x =>
{
dynamic handler = _serviceLocator.GetService(executorType);
handler.Handle(x);
});
registerExecutorMethod.Invoke(bus, new object[] { del });
}
private DefaultEventBusSubscriptionsManager GetEventBusSubscriptionsManager(IHandlerRegistrar handlerRegistrar, ISubscriptionService subscriptionService)
{
var registeredEventServiceMock = new Mock <RegisteredEventService>(Mock.Of <IPlatformMemoryCache>());
var eventTypes = new List <PlatformEventInfo>
{
new PlatformEventInfo {
Id = typeof(FakeEvent).FullName, Type = typeof(FakeEvent)
}
};
registeredEventServiceMock.Setup(x => x.GetAllEvents()).Returns(eventTypes);
var eventBusProviderServiceMock = new Mock <IEventBusProviderService>();
eventBusProviderServiceMock.Setup(x => x.IsProviderRegistered(It.IsAny <string>())).Returns(true);
return(new DefaultEventBusSubscriptionsManager(handlerRegistrar,
registeredEventServiceMock.Object,
subscriptionService,
Mock.Of <ISubscriptionSearchService>(),
eventBusProviderServiceMock.Object));
}
private static void InvokeHandler(Type @interface, IHandlerRegistrar bus, Type executorType)
{
var commandType = @interface.GenericTypeArguments[0];
var registerExecutorMethod = bus
.GetType().GetRuntimeMethods()
.Where(mi => mi.Name == "RegisterHandler")
.Where(mi => mi.IsGenericMethod)
.Where(mi => mi.GetGenericArguments().Count() == 1)
.Single(mi => mi.GetParameters().Count() == 1)
.MakeGenericMethod(commandType);
var del = new Func <dynamic, bool>(x =>
{
dynamic handler = _container.Resolve(@interface);
var d1 = typeof(DomainEventHandlerData <>);
Type[] typeArgs = { x.Event.GetType() };
var makeme = d1.MakeGenericType(typeArgs);
var a = DomainEventHandlerData <EventBase> .CreateDynamicInstance(makeme, x);
return(handler.Handle(a));
});
registerExecutorMethod.Invoke(bus, new object[] { del });
}
private void InvokeHandler(Type @interface, IHandlerRegistrar registrar, Type executorType)
{
var commandType = @interface.GetGenericArguments()[0];
var registerExecutorMethod = registrar
.GetType()
.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Where(mi => mi.Name == "RegisterHandler")
.Where(mi => mi.IsGenericMethod)
.Where(mi => mi.GetGenericArguments().Length == 1)
.Single(mi => mi.GetParameters().Length == 1)
.MakeGenericMethod(commandType);
Func <object, CancellationToken, Task> func;
if (IsCancellable(@interface))
{
func = (@event, token) =>
{
var handler = _serviceLocator.GetService(executorType) ??
throw new HandlerNotResolvedException(nameof(executorType));
return((Task)handler.Invoke("Handle", @event, token));
};
}
else
{
func = (@event, token) =>
{
var handler = _serviceLocator.GetService(executorType) ??
throw new HandlerNotResolvedException(nameof(executorType));
return((Task)handler.Invoke("Handle", @event));
};
}
registerExecutorMethod.Invoke(registrar, new object[] { func });
}
public ServiceLocator(IHandlerRegistrar registrar, IEventStore eventStore, InMemoryDatabase database)
{
_registrar = registrar;
_eventStore = eventStore;
_database = database;
}
protected virtual void InvokeHandlerDelegate(MethodInfo registerExecutorMethod, IHandlerRegistrar bus, HandlerDelegate handlerDelegate)
{
registerExecutorMethod.Invoke(bus, new object[] { handlerDelegate.Delegate, handlerDelegate.TargetedType });
}
public CommandBus(IHandlerRegistrar <ICommandHandler> commandHandlerRegistrar)
{
_commandHandlerRegistrar = commandHandlerRegistrar;
}
protected virtual void InvokeHandlerDelegate(MethodInfo registerExecutorMethod, IHandlerRegistrar bus, HandlerDelegate handlerDelegate)
{
bool holdMessageLock;
try
{
string messageType = registerExecutorMethod.GetParameters()[0].ParameterType.GetGenericArguments()[0].FullName;
string configuration = string.Format("{0}<{1}>.HoldMessageLock", handlerDelegate.TargetedType.FullName, messageType);
// If this cannot be parsed then assume the safe route that this must be required to hold the lock.
if (!bool.TryParse(DependencyResolver.Resolve <IConfigurationManager>().GetSetting(configuration), out holdMessageLock))
{
holdMessageLock = true;
}
}
catch
{
holdMessageLock = true;
}
registerExecutorMethod.Invoke(bus, new object[] { handlerDelegate.Delegate, handlerDelegate.TargetedType, holdMessageLock });
}
protected override void InvokeHandlerDelegate(MethodInfo registerExecutorMethod, IHandlerRegistrar bus, HandlerDelegate handlerDelegate)
{
base.InvokeHandlerDelegate(registerExecutorMethod, bus, handlerDelegate);
registerExecutorMethod.Invoke(DependencyResolver.Resolve <IAkkaEventPublisher <TAuthenticationToken> >(), new object[] { handlerDelegate.Delegate, handlerDelegate.TargetedType });
}
public EventsBus(IHandlerRegistrar <IEventHandler> eventHandlerRegistrar)
{
_eventHandlerRegistrar = eventHandlerRegistrar;
}
public QueryBus(IHandlerRegistrar <IQueryHandler> queryHandlerRegistrar)
{
_queryHandlerRegistrar = queryHandlerRegistrar;
}
