public void Register(StandardComponents standardComponents)
{
_leaderInputQueue = QueuedHandler.CreateQueuedHandler(_leaderMainBus, "Projections Leader",
standardComponents.QueueStatsManager);
_leaderOutputBus = new InMemoryBus("ProjectionManagerAndCoreCoordinatorOutput");
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.RestartSubsystem>(this);
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.ComponentStarted>(this);
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.ComponentStopped>(this);
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.IODispatcherDrained>(this);
_leaderMainBus.Subscribe <SystemMessage.SystemCoreReady>(this);
_leaderMainBus.Subscribe <SystemMessage.StateChangeMessage>(this);
var projectionsStandardComponents = new ProjectionsStandardComponents(
_projectionWorkerThreadCount,
_runProjections,
_leaderOutputBus,
_leaderInputQueue,
_leaderMainBus,
_faultOutOfOrderProjections,
_compilationTimeout,
_executionTimeout);
CreateAwakerService(standardComponents);
_coreQueues =
ProjectionCoreWorkersNode.CreateCoreWorkers(standardComponents, projectionsStandardComponents);
_queueMap = _coreQueues.ToDictionary(v => v.Key, v => (IPublisher)v.Value);
ProjectionManagerNode.CreateManagerService(standardComponents, projectionsStandardComponents, _queueMap,
_projectionsQueryExpiry);
projectionsStandardComponents.LeaderMainBus.Subscribe <CoreProjectionStatusMessage.Stopped>(this);
projectionsStandardComponents.LeaderMainBus.Subscribe <CoreProjectionStatusMessage.Started>(this);
}
public ProjectionCoreService(
Guid workerId,
IPublisher inputQueue,
IPublisher publisher,
ReaderSubscriptionDispatcher subscriptionDispatcher,
ITimeProvider timeProvider,
IODispatcher ioDispatcher,
ISingletonTimeoutScheduler timeoutScheduler, ProjectionsStandardComponents configuration)
{
_workerId = workerId;
_inputQueue = inputQueue;
_publisher = publisher;
_ioDispatcher = ioDispatcher;
_timeoutScheduler = timeoutScheduler;
_subscriptionDispatcher = subscriptionDispatcher;
_timeProvider = timeProvider;
_processingStrategySelector = new ProcessingStrategySelector(_subscriptionDispatcher);
_factory = new ProjectionStateHandlerFactory(TimeSpan.FromMilliseconds(configuration.ProjectionCompilationTimeout),
TimeSpan.FromMilliseconds(configuration.ProjectionExecutionTimeout), configuration.ProjectionRuntime);
}
public void Register(StandardComponents standardComponents)
{
_masterMainBus = new InMemoryBus("manager input bus");
_masterInputQueue = new QueuedHandler(_masterMainBus, "Projections Master");
_masterOutputBus = new InMemoryBus("ProjectionManagerAndCoreCoordinatorOutput");
var projectionsStandardComponents = new ProjectionsStandardComponents(
_projectionWorkerThreadCount,
_runProjections,
_masterOutputBus,
_masterInputQueue,
_masterMainBus);
CreateAwakerService(standardComponents);
_coreQueues = ProjectionCoreWorkersNode.CreateCoreWorkers(standardComponents, projectionsStandardComponents);
_queueMap = _coreQueues.ToDictionary(v => v.Key, v => (IPublisher)v.Value);
ProjectionManagerNode.CreateManagerService(standardComponents, projectionsStandardComponents, _queueMap);
_masterOutputBus.Subscribe(standardComponents.MainQueue.WidenFrom <ProjectionManagementMessage.RequestSystemProjections, Message>());
}
public virtual void Setup()
{
_consumer = new TestHandler <Message>();
_bus = new InMemoryBus("temp");
_bus.Subscribe(_consumer);
ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000);
var ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus), true);
_readerService = new EventReaderCoreService(_bus, ioDispatcher, 10, writerCheckpoint,
runHeadingReader: true, faultOutOfOrderProjections: true);
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(_bus);
_timeoutScheduler = new TimeoutScheduler();
_workerId = Guid.NewGuid();
var guardBus = new GuardBusToTriggerFixingIfUsed();
var configuration = new ProjectionsStandardComponents(1, ProjectionType.All, guardBus, guardBus, guardBus, true,
500, 250);
_service = new ProjectionCoreService(
_workerId, _bus, _bus, _subscriptionDispatcher, new RealTimeProvider(), ioDispatcher, _timeoutScheduler, configuration);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher
.CreateSubscriber <EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionDeleted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ReaderAssignedReader>());
var instanceCorrelationId = Guid.NewGuid();
_readerService.Handle(new ReaderCoreServiceMessage.StartReader(instanceCorrelationId));
_service.Handle(new ProjectionCoreServiceMessage.StartCore(instanceCorrelationId));
}
private void SetUpCoreServices(
Guid workerId,
IBus bus,
IPublisher inputQueue,
InMemoryBus output_,
ISingletonTimeoutScheduler timeoutScheduler)
{
var output = (output_ ?? inputQueue);
ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000);
var readerService = new EventReaderCoreService(
output,
_ioDispatcher,
10,
writerCheckpoint,
runHeadingReader: true, faultOutOfOrderProjections: true);
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(inputQueue);
bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CheckpointSuggested>());
bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CommittedEventReceived>());
bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.EofReached>());
bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionEofReached>());
bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionDeleted>());
bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ProgressChanged>());
bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.SubscriptionStarted>());
bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.NotAuthorized>());
bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ReaderAssignedReader>());
var ioDispatcher = new IODispatcher(output, new PublishEnvelope(inputQueue), true);
// var coreServiceCommandReader = new ProjectionCoreServiceCommandReader(
// output,
// ioDispatcher,
// workerId.ToString("N"));
var guardBus = new GuardBusToTriggerFixingIfUsed();
var configuration = new ProjectionsStandardComponents(1, ProjectionType.All, guardBus, guardBus, guardBus, true,
500, 250);
var coreService = new ProjectionCoreService(
workerId,
inputQueue,
output,
_subscriptionDispatcher,
_timeProvider,
ioDispatcher,
timeoutScheduler, configuration);
bus.Subscribe <CoreProjectionManagementMessage.CreateAndPrepare>(coreService);
bus.Subscribe <CoreProjectionManagementMessage.CreatePrepared>(coreService);
bus.Subscribe <CoreProjectionManagementMessage.Dispose>(coreService);
bus.Subscribe <CoreProjectionManagementMessage.Start>(coreService);
bus.Subscribe <CoreProjectionManagementMessage.LoadStopped>(coreService);
bus.Subscribe <CoreProjectionManagementMessage.Stop>(coreService);
bus.Subscribe <CoreProjectionManagementMessage.Kill>(coreService);
bus.Subscribe <CoreProjectionManagementMessage.GetState>(coreService);
bus.Subscribe <CoreProjectionManagementMessage.GetResult>(coreService);
bus.Subscribe <CoreProjectionProcessingMessage.CheckpointCompleted>(coreService);
bus.Subscribe <CoreProjectionProcessingMessage.CheckpointLoaded>(coreService);
bus.Subscribe <CoreProjectionProcessingMessage.PrerecordedEventsLoaded>(coreService);
bus.Subscribe <CoreProjectionProcessingMessage.RestartRequested>(coreService);
bus.Subscribe <CoreProjectionProcessingMessage.Failed>(coreService);
bus.Subscribe <ClientMessage.ReadStreamEventsForwardCompleted>(ioDispatcher.ForwardReader);
bus.Subscribe <ClientMessage.ReadStreamEventsBackwardCompleted>(ioDispatcher.BackwardReader);
bus.Subscribe <ClientMessage.WriteEventsCompleted>(ioDispatcher.Writer);
bus.Subscribe <ClientMessage.DeleteStreamCompleted>(ioDispatcher.StreamDeleter);
bus.Subscribe <IODispatcherDelayedMessage>(ioDispatcher.Awaker);
bus.Subscribe <IODispatcherDelayedMessage>(ioDispatcher);
bus.Subscribe <ProjectionCoreServiceMessage.StartCore>(coreService);
bus.Subscribe <ProjectionCoreServiceMessage.StopCore>(coreService);
bus.Subscribe <ReaderCoreServiceMessage.StartReader>(readerService);
bus.Subscribe <ReaderCoreServiceMessage.StopReader>(readerService);
bus.Subscribe <ProjectionCoreServiceMessage.CoreTick>(coreService);
bus.Subscribe <ReaderSubscriptionMessage.CommittedEventDistributed>(readerService);
bus.Subscribe <ReaderSubscriptionMessage.EventReaderEof>(readerService);
bus.Subscribe <ReaderSubscriptionMessage.EventReaderPartitionEof>(readerService);
bus.Subscribe <ReaderSubscriptionMessage.EventReaderPartitionDeleted>(readerService);
bus.Subscribe <ReaderSubscriptionMessage.EventReaderNotAuthorized>(readerService);
bus.Subscribe <ReaderSubscriptionMessage.EventReaderIdle>(readerService);
bus.Subscribe <ReaderSubscriptionMessage.EventReaderStarting>(readerService);
bus.Subscribe <ReaderSubscriptionManagement.Pause>(readerService);
bus.Subscribe <ReaderSubscriptionManagement.Resume>(readerService);
bus.Subscribe <ReaderSubscriptionManagement.Subscribe>(readerService);
bus.Subscribe <ReaderSubscriptionManagement.Unsubscribe>(readerService);
if (output_ != null)
{
bus.Subscribe(new UnwrapEnvelopeHandler());
output_.Subscribe(Forwarder.Create <CoreProjectionStatusMessage.StateReport>(GetInputQueue()));
output_.Subscribe(Forwarder.Create <CoreProjectionStatusMessage.ResultReport>(GetInputQueue()));
output_.Subscribe(Forwarder.Create <CoreProjectionStatusMessage.StatisticsReport>(GetInputQueue()));
output_.Subscribe(Forwarder.Create <CoreProjectionStatusMessage.Started>(GetInputQueue()));
output_.Subscribe(Forwarder.Create <CoreProjectionStatusMessage.Stopped>(GetInputQueue()));
output_.Subscribe(Forwarder.Create <CoreProjectionStatusMessage.Faulted>(GetInputQueue()));
output_.Subscribe(Forwarder.Create <CoreProjectionStatusMessage.Prepared>(GetInputQueue()));
output_.Subscribe(
Forwarder.Create <ProjectionManagementMessage.Command.ControlMessage>(GetInputQueue()));
output_.Subscribe(Forwarder.Create <AwakeServiceMessage.SubscribeAwake>(GetInputQueue()));
output_.Subscribe(Forwarder.Create <AwakeServiceMessage.UnsubscribeAwake>(GetInputQueue()));
output_.Subscribe(Forwarder.Create <Message>(inputQueue)); // forward all
var forwarder = new RequestResponseQueueForwarder(
inputQueue: inputQueue,
externalRequestQueue: GetInputQueue());
// forwarded messages
output_.Subscribe <ClientMessage.ReadEvent>(forwarder);
output_.Subscribe <ClientMessage.ReadStreamEventsBackward>(forwarder);
output_.Subscribe <ClientMessage.ReadStreamEventsForward>(forwarder);
output_.Subscribe <ClientMessage.ReadAllEventsForward>(forwarder);
output_.Subscribe <ClientMessage.WriteEvents>(forwarder);
}
}