public CommandProcessor(
ICommandHandlerRegistry registry,
ICommandHandlerFactory factory)
{
_registry = registry;
_factory = factory;
}
public EventStoreRebuilderEngine(
IInMemoryBus bus,
ICommandProcessor commandProcessor, ICommandHandlerRegistry commandHandlerRegistry, IEventDispatcher eventDispatcher,
ITextSerializer serializer, IMetadataProvider metadataProvider,
ITracer tracer,
IEventStoreRebuilderConfig config,
IRebuilderPerfCounter perfCounter)
{
this.bus = bus;
this.serializer = serializer;
this.eventDispatcher = eventDispatcher;
this.commandProcessor = commandProcessor;
this.commandHandlerRegistry = commandHandlerRegistry;
this.config = config;
this.tracer = tracer;
this.metadataProvider = metadataProvider;
this.perfCounter = perfCounter;
this.sourceContextFactory = () =>
{
var context = new EventStoreDbContext(this.config.SourceEventStoreConnectionString);
context.Configuration.AutoDetectChangesEnabled = false;
return(context);
};
this.newContextFactory = () => new EventStoreDbContext(this.config.NewEventStoreConnectionString);
}
public static void HandleCommand <TMessage>(this ICommandHandlerRegistry registry, Action <TMessage> onEvent)
{
registry.RegisterCommand <TMessage>(x =>
{
onEvent(x);
return(Task.CompletedTask);
});
}
public CommandExecuter(ICommandHandlerRegistry registry)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
_registry = registry;
}
private static void RegisterCommandHandlers(IUnityContainer unityContainer, ICommandHandlerRegistry registry)
{
var commandHandlers = unityContainer.ResolveAll <ICommandHandler>().ToList();
foreach (var commandHandler in commandHandlers)
{
registry.Register(commandHandler);
}
}
public void BootstrapCommands(
ICommandHandlerRegistry commandHandlerRegistry,
IRepositories repositories,
Action <object> eventPublisher,
Func <object> idFactory,
IQueryDispatcher queryDispatcher)
{
commandHandlerRegistry.SetHandler <AddJourneyWithLiftsCommand>(
new AddJourneyWithLiftsCommandHandler(eventPublisher, repositories, idFactory, queryDispatcher).Execute);
}
private static void RegisterCommandHandlers(IServiceCollection services, List <ICommandHandler> commandHandlers,
ICommandHandlerRegistry sessionlessRegistry, ICommandHandlerRegistry anchorsAvailabilityRegistry)
{
var anchorsAvailabilityHandler = commandHandlers.First(x => x.GetType().GetTypeInfo().IsAssignableFrom(typeof(AnchorsAvailabilityHandler)));
anchorsAvailabilityRegistry.Register(anchorsAvailabilityHandler);
foreach (var commandHandler in commandHandlers.Where(x => x.GetType() != anchorsAvailabilityHandler.GetType()))
{
sessionlessRegistry.Register(commandHandler);
}
}
private static void RegisterCommandHandlers(IUnityContainer unityContainer, ICommandHandlerRegistry sessionlessRegistry, ICommandHandlerRegistry seatsAvailabilityRegistry)
{
var commandHandlers = unityContainer.ResolveAll <ICommandHandler>().ToList();
var seatsAvailabilityHandler = commandHandlers.First(x => x.GetType().IsAssignableFrom(typeof(SeatsAvailabilityHandler)));
seatsAvailabilityRegistry.Register(seatsAvailabilityHandler);
foreach (var commandHandler in commandHandlers.Where(x => x != seatsAvailabilityHandler))
{
sessionlessRegistry.Register(commandHandler);
}
}
public InternalCommandProcessor(
AsyncConcurrentQueue <ICommand> queue,
IServiceProvider provider,
ICommandHandlerRegistry dispatchers,
ILogger <InternalEventProcessor> logger,
IExceptionHandlerRegistry?exceptionHandlerRegistry = null)
{
_queue = queue;
_dispatchers = dispatchers;
_provider = provider;
_logger = logger;
_exceptionHandlerRegistry = exceptionHandlerRegistry;
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandBus"/> class.
/// </summary>
/// <param name="commandHandlerRegistry">The command handler registry.</param>
/// <param name="commandDispatcher">The command dispatcher.</param>
/// <param name="options">The command bus options.</param>
public CommandBus(
ICommandHandlerRegistry commandHandlerRegistry,
ICommandDispatcher commandDispatcher,
CommandBusOptions options)
{
this.CommandHandlerRegistry = commandHandlerRegistry
?? throw new ArgumentNullException(nameof(commandHandlerRegistry));
this.CommandDispatcher = commandDispatcher
?? throw new ArgumentNullException(nameof(commandDispatcher));
this.Options = options
?? throw new ArgumentNullException(nameof(options));
}
public Bootstrapper(
IEventBus eventBus,
ICommandDispatcher commandDispatcher,
ICommandHandlerRegistry commandHandlerRegistry,
IQueryDispatcher queryDispatcher,
IQueryHandlerRegistry queryHandlerRegistry,
IIdFactory idFactory)
{
_eventBus = eventBus;
_commandDispatcher = commandDispatcher;
_commandHandlerRegistry = commandHandlerRegistry;
_queryDispatcher = queryDispatcher;
_queryHandlerRegistry = queryHandlerRegistry;
_idFactory = idFactory;
}
public static void AddRange(this ICommandHandlerRegistry commandHandlerRegistry, IEnumerable <ICommandHandlerContext> commandHandlerContexts)
{
if (commandHandlerRegistry is null)
{
throw new System.ArgumentNullException(nameof(commandHandlerRegistry));
}
if (commandHandlerContexts is null)
{
throw new System.ArgumentNullException(nameof(commandHandlerContexts));
}
foreach (var commandHandlerContext in commandHandlerContexts)
{
commandHandlerRegistry.Add(commandHandlerContext);
}
}
public MassTransit(ICommandHandlerRegistry commandRegistry, IEventHandlerRegistry eventRegistry, Container container)
{
_container = container;
_serviceBus = ServiceBusFactory.New(sbc =>
{
sbc.UseRabbitMq();
sbc.ReceiveFrom("rabbitmq://192.168.10.201/mybus");
sbc.Subscribe(x =>
{
eventRegistry.GetEvents((commandType) =>
{
RegisterHandler(x, commandType);
});
});
});
}
private void Initialize()
{
var services = new ServiceCollection();
services.TryAddSingleton(_connection);
Configure(new Configuration(services));
var serviceProvider = services.BuildServiceProvider();
var logger = serviceProvider.GetService <ILogger <ServiceBuilder> >();
logger?.LogInformation("Discovering and initializing subscriptions...");
//resolve the assembly.
var assemblyResolver = serviceProvider.GetRequiredService <IAssemblyResolver>();
var assembly = assemblyResolver.Resolve();
//resolve all types in the assembly.
var typeResolver = serviceProvider.GetRequiredService <ITypeResolver>();
var types = typeResolver.ResolveTypes(assembly);
//resolve all methods in the types.
var methodResolver = serviceProvider.GetRequiredService <IMethodResolver>();
var methods = methodResolver.ResolveMethods(types);
//create CommandHandlerContexts from all methods.
var commandHandlerContextFactory = serviceProvider.GetRequiredService <ICommandHandlerContextFactory>();
var commandHandlerContexts = commandHandlerContextFactory.Create(methods);
//add all CommandHandlerContexts to the registry.
_commandHandlerRegistry = serviceProvider.GetRequiredService <ICommandHandlerRegistry>();
_commandHandlerRegistry.AddRange(commandHandlerContexts);
//instantiate all topic subscriptions.
var topicSubscriptionFactory = serviceProvider.GetRequiredService <ITopicSubscriptionFactory>();
_topicSubscriptionRegistry = serviceProvider.GetRequiredService <ITopicSubscriptionRegistry>();
foreach (var keyPair in _commandHandlerRegistry)
{
var topicSubscription = topicSubscriptionFactory.CreateSubscription(keyPair.Key, keyPair.Value);
_topicSubscriptionRegistry.Add(topicSubscription);
}
logger?.LogInformation("All subscriptions initialized successfully.");
}
public BusLifetime(Container container, IBus bus, ICommandBus commandBus, IEventBus eventBus, ICommandHandlerRegistry commandHandlerRegistry, IEventHandlerRegistry eventHandlerRegistry)
{
_container = container;
_bus = bus;
_commandBus = commandBus;
_eventBus = eventBus;
commandHandlerRegistry.GetCommands(type =>
{
var genericArguements = type.GetGenericArguments();
if (genericArguements.Count() == 1)
{
RegisterCommandHandler(genericArguements[0]);
}
else
{
RegisterCommandResponseHandler(genericArguements[0], genericArguements[1]);
}
});
eventHandlerRegistry.GetEvents(RegisterEventHandler);
}
public CommandDispatcher(IEventStore eventStore, ICommandHandlerRegistry commandHandlerRegistry)
{
_eventStore = eventStore;
_commandHandlerRegistry = commandHandlerRegistry;
}
public CommandDispatcherUnitTests()
{
_repository = Substitute.For <IEventStore>();
_commandHandlerRegistry = Substitute.For <ICommandHandlerRegistry>();
_target = new CommandDispatcher(_repository, _commandHandlerRegistry);
}
public CommandExecuter(ICommandHandlerRegistry registry)
{
if (registry == null) throw new ArgumentNullException(nameof(registry));
_registry = registry;
}
private static void RegisterCommandHandlers(IUnityContainer unityContainer, ICommandHandlerRegistry registry)
{
var commandHandlers = unityContainer.ResolveAll<ICommandHandler>().ToList();
foreach (var commandHandler in commandHandlers)
{
registry.Register(commandHandler);
}
}
public Api(ICommandHandlerRegistry command_handler_registery)
{
_command_handler_registery = command_handler_registery;
}
private static void RegisterCommandHandlers(IUnityContainer unityContainer, ICommandHandlerRegistry sessionlessRegistry, ICommandHandlerRegistry seatsAvailabilityRegistry)
{
var commandHandlers = unityContainer.ResolveAll<ICommandHandler>().ToList();
var seatsAvailabilityHandler = commandHandlers.First(x => x.GetType().IsAssignableFrom(typeof(SeatsAvailabilityHandler)));
seatsAvailabilityRegistry.Register(seatsAvailabilityHandler);
foreach (var commandHandler in commandHandlers.Where(x => x != seatsAvailabilityHandler))
{
sessionlessRegistry.Register(commandHandler);
}
}
public ApplicationService(ICommandHandlerRegistry command_handler_registery)
{
_command_handler_registery = command_handler_registery;
}
public CommandProcessor(IMessageReceiver receiver, ITextSerialiser serialiser, ICommandHandlerRegistry registry)
: base(receiver, serialiser)
{
this._registry = registry;
}
public InProcessCommandBus(ICommandHandlerRegistry command_handler_registry)
{
_command_handler_registry = command_handler_registry;
}
