protected override void Create()
{
base.Create();
var db = this.TfDb;
_coreInputBus = new InMemoryBus("bus");
_coreQueue = new QueuedHandler(_coreInputBus, "ProjectionCoreQueue");
_readerInputBus = new InMemoryBus("Reader Input");
_projectionNode = new ProjectionWorkerNode(db, _coreQueue, Node.HttpService);
_projectionNode.SetupMessaging(_coreInputBus, _readerInputBus);
_forwarder = new RequestResponseQueueForwarder(inputQueue: _coreQueue, externalRequestQueue: Node.MainQueue);
// forwarded messages
_projectionNode.CoreOutput.Subscribe <ClientMessage.ReadEvent>(_forwarder);
_projectionNode.CoreOutput.Subscribe <ClientMessage.ReadEventsBackwards>(_forwarder);
_projectionNode.CoreOutput.Subscribe <ClientMessage.ReadEventsForward>(_forwarder);
_projectionNode.CoreOutput.Subscribe <ClientMessage.ReadEventsFromTF>(_forwarder);
_projectionNode.CoreOutput.Subscribe <ClientMessage.WriteEvents>(_forwarder);
_coreInputBus.Subscribe(new UnwrapEnvelopeHandler());
Node.Bus.Subscribe(Forwarder.Create <SystemMessage.BecomeShuttingDown>(_coreQueue));
Node.Bus.Subscribe(Forwarder.Create <SystemMessage.SystemInit>(_coreQueue));
Node.Bus.Subscribe(Forwarder.Create <SystemMessage.SystemStart>(_coreQueue));
_projectionNode.CoreOutput.Subscribe(Node.TimerService);
_coreInputBus.Subscribe <SystemMessage.SystemStart>(this);
}
private static void SubscribeOutputBus(
StandardComponents standardComponents,
ProjectionsStandardComponents projectionsStandardComponents,
RequestResponseQueueForwarder forwarder)
{
var managerOutput = projectionsStandardComponents.MasterOutputBus;
managerOutput.Subscribe <ClientMessage.ReadEvent>(forwarder);
managerOutput.Subscribe <ClientMessage.ReadStreamEventsBackward>(forwarder);
managerOutput.Subscribe <ClientMessage.ReadStreamEventsForward>(forwarder);
managerOutput.Subscribe <ClientMessage.WriteEvents>(forwarder);
managerOutput.Subscribe <ClientMessage.DeleteStream>(forwarder);
managerOutput.Subscribe(
Forwarder.Create <ProjectionManagementMessage.RequestSystemProjections>(standardComponents.MainQueue));
managerOutput.Subscribe(Forwarder.Create <Message>(projectionsStandardComponents.MasterInputQueue));
managerOutput.Subscribe <TimerMessage.Schedule>(standardComponents.TimerService);
managerOutput.Subscribe(Forwarder.Create <AwakeServiceMessage.SubscribeAwake>(standardComponents.MainQueue));
managerOutput.Subscribe(
Forwarder.Create <AwakeServiceMessage.UnsubscribeAwake>(standardComponents.MainQueue));
// self forward all
standardComponents.MainBus.Subscribe(
Forwarder.Create <SystemMessage.StateChangeMessage>(projectionsStandardComponents.MasterInputQueue));
standardComponents.MainBus.Subscribe(
Forwarder.Create <SystemMessage.SystemReady>(projectionsStandardComponents.MasterInputQueue));
projectionsStandardComponents.MasterMainBus.Subscribe(new UnwrapEnvelopeHandler());
}
public static void CreateManagerService(
StandardComponents standardComponents,
ProjectionsStandardComponents projectionsStandardComponents,
IDictionary <Guid, IPublisher> queues,
TimeSpan projectionQueryExpiry)
{
IQueuedHandler inputQueue = projectionsStandardComponents.MasterInputQueue;
InMemoryBus outputBus = projectionsStandardComponents.MasterOutputBus;
var ioDispatcher = new IODispatcher(outputBus, new PublishEnvelope(inputQueue));
var projectionsController = new ProjectionsController(
standardComponents.HttpForwarder,
inputQueue,
standardComponents.NetworkSendService);
var forwarder = new RequestResponseQueueForwarder(
inputQueue: projectionsStandardComponents.MasterInputQueue,
externalRequestQueue: standardComponents.MainQueue);
if (projectionsStandardComponents.RunProjections != ProjectionType.None)
{
foreach (var httpService in standardComponents.HttpServices)
{
httpService.SetupController(projectionsController);
}
}
var commandWriter = new MultiStreamMessageWriter(ioDispatcher);
var projectionManagerCommandWriter = new ProjectionManagerCommandWriter(commandWriter);
var projectionManagerResponseReader = new ProjectionManagerResponseReader(outputBus, ioDispatcher,
queues.Count);
var projectionManager = new ProjectionManager(
inputQueue,
outputBus,
queues,
new RealTimeProvider(),
projectionsStandardComponents.RunProjections,
ioDispatcher,
projectionQueryExpiry);
SubscribeMainBus(
projectionsStandardComponents.MasterMainBus,
projectionManager,
projectionsStandardComponents.RunProjections,
projectionManagerResponseReader,
ioDispatcher,
projectionManagerCommandWriter);
SubscribeOutputBus(standardComponents, projectionsStandardComponents, forwarder);
}
public static void CreateManagerService(
StandardComponents standardComponents,
ProjectionsStandardComponents projectionsStandardComponents,
IDictionary<Guid, IPublisher> queues)
{
QueuedHandler inputQueue = projectionsStandardComponents.MasterInputQueue;
InMemoryBus outputBus = projectionsStandardComponents.MasterOutputBus;
var ioDispatcher = new IODispatcher(outputBus, new PublishEnvelope(inputQueue));
var projectionsController = new ProjectionsController(
standardComponents.HttpForwarder,
inputQueue,
standardComponents.NetworkSendService);
var forwarder = new RequestResponseQueueForwarder(
inputQueue: projectionsStandardComponents.MasterInputQueue,
externalRequestQueue: standardComponents.MainQueue);
if (projectionsStandardComponents.RunProjections != ProjectionType.None)
{
foreach (var httpService in standardComponents.HttpServices)
{
httpService.SetupController(projectionsController);
}
}
var commandWriter = new MultiStreamMessageWriter(ioDispatcher);
var projectionManagerCommandWriter = new ProjectionManagerCommandWriter(commandWriter);
var projectionManagerResponseReader = new ProjectionManagerResponseReader(outputBus, ioDispatcher, queues.Count);
var projectionManager = new ProjectionManager(
inputQueue,
outputBus,
queues,
new RealTimeProvider(),
projectionsStandardComponents.RunProjections,
ioDispatcher);
SubscribeMainBus(
projectionsStandardComponents.MasterMainBus,
projectionManager,
projectionsStandardComponents.RunProjections,
projectionManagerResponseReader,
ioDispatcher,
projectionManagerCommandWriter);
SubscribeOutputBus(standardComponents, projectionsStandardComponents, forwarder);
}
private static void SubscribeOutputBus(
StandardComponents standardComponents,
ProjectionsStandardComponents projectionsStandardComponents,
RequestResponseQueueForwarder forwarder,
IODispatcher ioDispatcher)
{
var managerOutput = projectionsStandardComponents.LeaderOutputBus;
managerOutput.Subscribe <ClientMessage.ReadEvent>(forwarder);
managerOutput.Subscribe <ClientMessage.ReadStreamEventsBackward>(forwarder);
managerOutput.Subscribe <ClientMessage.ReadStreamEventsForward>(forwarder);
managerOutput.Subscribe <ClientMessage.WriteEvents>(forwarder);
managerOutput.Subscribe <ClientMessage.DeleteStream>(forwarder);
managerOutput.Subscribe(Forwarder.Create <Message>(projectionsStandardComponents.LeaderInputQueue));
managerOutput.Subscribe <ClientMessage.NotHandled>(ioDispatcher);
managerOutput.Subscribe <TimerMessage.Schedule>(standardComponents.TimerService);
managerOutput.Subscribe(Forwarder.Create <AwakeServiceMessage.SubscribeAwake>(standardComponents.MainQueue));
managerOutput.Subscribe(
Forwarder.Create <AwakeServiceMessage.UnsubscribeAwake>(standardComponents.MainQueue));
managerOutput.Subscribe <SystemMessage.SubSystemInitialized>(forwarder);
// self forward all
standardComponents.MainBus.Subscribe(
Forwarder.Create <SystemMessage.StateChangeMessage>(projectionsStandardComponents.LeaderInputQueue));
standardComponents.MainBus.Subscribe(
Forwarder.Create <SystemMessage.SystemCoreReady>(projectionsStandardComponents.LeaderInputQueue));
standardComponents.MainBus.Subscribe(
Forwarder.Create <SystemMessage.EpochWritten>(projectionsStandardComponents.LeaderInputQueue));
standardComponents.MainBus.Subscribe(
Forwarder.Create <ProjectionCoreServiceMessage.SubComponentStarted>(projectionsStandardComponents
.LeaderInputQueue));
standardComponents.MainBus.Subscribe(
Forwarder.Create <ProjectionCoreServiceMessage.SubComponentStopped>(projectionsStandardComponents
.LeaderInputQueue));
projectionsStandardComponents.LeaderMainBus.Subscribe(new UnwrapEnvelopeHandler());
}
public static Dictionary<Guid, QueuedHandler> CreateCoreWorkers(
StandardComponents standardComponents,
ProjectionsStandardComponents projectionsStandardComponents)
{
var coreTimeoutSchedulers =
CreateTimeoutSchedulers(projectionsStandardComponents.ProjectionWorkerThreadCount);
var coreQueues = new Dictionary<Guid, QueuedHandler>();
while (coreQueues.Count < projectionsStandardComponents.ProjectionWorkerThreadCount)
{
var coreInputBus = new InMemoryBus("bus");
var coreQueue = new QueuedHandler(
coreInputBus,
"Projection Core #" + coreQueues.Count,
groupName: "Projection Core");
var workerId = Guid.NewGuid();
var projectionNode = new ProjectionWorkerNode(
workerId,
standardComponents.Db,
coreQueue,
standardComponents.TimeProvider,
coreTimeoutSchedulers[coreQueues.Count],
projectionsStandardComponents.RunProjections);
projectionNode.SetupMessaging(coreInputBus);
var forwarder = new RequestResponseQueueForwarder(
inputQueue: coreQueue,
externalRequestQueue: standardComponents.MainQueue);
// forwarded messages
var coreOutput = projectionNode.CoreOutput;
coreOutput.Subscribe<ClientMessage.ReadEvent>(forwarder);
coreOutput.Subscribe<ClientMessage.ReadStreamEventsBackward>(forwarder);
coreOutput.Subscribe<ClientMessage.ReadStreamEventsForward>(forwarder);
coreOutput.Subscribe<ClientMessage.ReadAllEventsForward>(forwarder);
coreOutput.Subscribe<ClientMessage.WriteEvents>(forwarder);
coreOutput.Subscribe<ClientMessage.DeleteStream>(forwarder);
if (projectionsStandardComponents.RunProjections >= ProjectionType.System)
{
var slaveProjectionResponseWriter = projectionNode.SlaveProjectionResponseWriter;
coreOutput.Subscribe<PartitionMeasuredOutput>(slaveProjectionResponseWriter);
coreOutput.Subscribe<PartitionProcessingProgressOutput>(slaveProjectionResponseWriter);
coreOutput.Subscribe<PartitionProcessingResultOutput>(slaveProjectionResponseWriter);
coreOutput.Subscribe<ReaderSubscriptionManagement.SpoolStreamReading>(slaveProjectionResponseWriter);
coreOutput.Subscribe(
Forwarder.Create<AwakeServiceMessage.SubscribeAwake>(standardComponents.MainQueue));
coreOutput.Subscribe(
Forwarder.Create<AwakeServiceMessage.UnsubscribeAwake>(standardComponents.MainQueue));
}
coreOutput.Subscribe<TimerMessage.Schedule>(standardComponents.TimerService);
coreOutput.Subscribe(Forwarder.Create<Message>(coreQueue)); // forward all
coreInputBus.Subscribe(new UnwrapEnvelopeHandler());
coreQueues.Add(workerId, coreQueue);
}
var queues = coreQueues.Select(v => v.Value).Cast<IPublisher>().ToArray();
var coordinator = new ProjectionCoreCoordinator(
projectionsStandardComponents.RunProjections,
coreTimeoutSchedulers,
queues,
projectionsStandardComponents.MasterOutputBus,
new PublishEnvelope(projectionsStandardComponents.MasterInputQueue, crossThread: true));
coordinator.SetupMessaging(projectionsStandardComponents.MasterMainBus);
projectionsStandardComponents.MasterMainBus.Subscribe(
Forwarder.CreateBalancing<FeedReaderMessage.ReadPage>(coreQueues.Values.Cast<IPublisher>().ToArray()));
return coreQueues;
}
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);
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(inputQueue);
var spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(GetInputQueue());
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.PartitionMeasured>());
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>());
bus.Subscribe(spoolProcessingResponseDispatcher.CreateSubscriber<PartitionProcessingResult>());
var ioDispatcher = new IODispatcher(output, new PublishEnvelope(inputQueue));
// var coreServiceCommandReader = new ProjectionCoreServiceCommandReader(
// output,
// ioDispatcher,
// workerId.ToString("N"));
var coreService = new ProjectionCoreService(
workerId,
inputQueue,
output,
_subscriptionDispatcher,
_timeProvider,
ioDispatcher,
spoolProcessingResponseDispatcher,
timeoutScheduler);
bus.Subscribe<CoreProjectionManagementMessage.CreateAndPrepare>(coreService);
bus.Subscribe<CoreProjectionManagementMessage.CreatePrepared>(coreService);
bus.Subscribe<CoreProjectionManagementMessage.CreateAndPrepareSlave>(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<ProjectionManagementMessage.SlaveProjectionsStarted>(coreService);
bus.Subscribe<ReaderCoreServiceMessage.ReaderTick>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.CommittedEventDistributed>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.EventReaderEof>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionEof>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionDeleted>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionMeasured>(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);
bus.Subscribe<ReaderSubscriptionManagement.SpoolStreamReadingCore>(readerService);
bus.Subscribe<ReaderSubscriptionManagement.CompleteSpooledStreamReading>(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<CoreProjectionManagementMessage.SlaveProjectionReaderAssigned>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.ProjectionWorkerStarted>(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<PartitionProcessingResultBase>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<ReaderSubscriptionManagement.SpoolStreamReading>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<PartitionProcessingResultOutputBase>(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);
}
}
private void SetupMessaging(
TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService, ITimeProvider timeProvider,
IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendQueue, RunProjections runProjections)
{
_coreQueues = new List<QueuedHandler>();
_managerInputBus = new InMemoryBus("manager input bus");
_managerInputQueue = new QueuedHandler(_managerInputBus, "Projections Master");
while (_coreQueues.Count < _projectionWorkerThreadCount)
{
var coreInputBus = new InMemoryBus("bus");
var coreQueue = new QueuedHandler(
coreInputBus, "Projection Core #" + _coreQueues.Count, groupName: "Projection Core");
var projectionNode = new ProjectionWorkerNode(db, coreQueue, timeProvider, runProjections);
projectionNode.SetupMessaging(coreInputBus);
var forwarder = new RequestResponseQueueForwarder(
inputQueue: coreQueue, externalRequestQueue: mainQueue);
// forwarded messages
projectionNode.CoreOutput.Subscribe<ClientMessage.ReadEvent>(forwarder);
projectionNode.CoreOutput.Subscribe<ClientMessage.ReadStreamEventsBackward>(forwarder);
projectionNode.CoreOutput.Subscribe<ClientMessage.ReadStreamEventsForward>(forwarder);
projectionNode.CoreOutput.Subscribe<ClientMessage.ReadAllEventsForward>(forwarder);
projectionNode.CoreOutput.Subscribe<ClientMessage.WriteEvents>(forwarder);
if (runProjections >= RunProjections.System)
{
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<CoreProjectionManagementMessage.StateReport>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<CoreProjectionManagementMessage.ResultReport>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<CoreProjectionManagementMessage.StatisticsReport>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<CoreProjectionManagementMessage.Started>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<CoreProjectionManagementMessage.Stopped>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<CoreProjectionManagementMessage.Faulted>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<CoreProjectionManagementMessage.Prepared>(_managerInputQueue));
}
projectionNode.CoreOutput.Subscribe(timerService);
projectionNode.CoreOutput.Subscribe(Forwarder.Create<Message>(coreQueue)); // forward all
coreInputBus.Subscribe(new UnwrapEnvelopeHandler());
_coreQueues.Add(coreQueue);
}
_managerInputBus.Subscribe(
Forwarder.CreateBalancing<FeedReaderMessage.ReadPage>(_coreQueues.Cast<IPublisher>().ToArray()));
_projectionManagerNode = ProjectionManagerNode.Create(
db, _managerInputQueue, httpForwarder, httpServices, networkSendQueue,
_coreQueues.Cast<IPublisher>().ToArray(), runProjections);
_projectionManagerNode.SetupMessaging(_managerInputBus);
{
var forwarder = new RequestResponseQueueForwarder(
inputQueue: _managerInputQueue, externalRequestQueue: mainQueue);
_projectionManagerNode.Output.Subscribe<ClientMessage.ReadEvent>(forwarder);
_projectionManagerNode.Output.Subscribe<ClientMessage.ReadStreamEventsBackward>(forwarder);
_projectionManagerNode.Output.Subscribe<ClientMessage.ReadStreamEventsForward>(forwarder);
_projectionManagerNode.Output.Subscribe<ClientMessage.WriteEvents>(forwarder);
_projectionManagerNode.Output.Subscribe(
Forwarder.Create<ProjectionManagementMessage.RequestSystemProjections>(mainQueue));
_projectionManagerNode.Output.Subscribe(Forwarder.Create<Message>(_managerInputQueue));
_projectionManagerNode.Output.Subscribe(timerService);
// self forward all
mainBus.Subscribe(Forwarder.Create<SystemMessage.StateChangeMessage>(_managerInputQueue));
_managerInputBus.Subscribe(new UnwrapEnvelopeHandler());
}
}
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 coreService = new ProjectionCoreService(
workerId,
inputQueue,
output,
_subscriptionDispatcher,
_timeProvider,
ioDispatcher,
timeoutScheduler);
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);
}
}
public static Dictionary <Guid, IQueuedHandler> CreateCoreWorkers(
StandardComponents standardComponents,
ProjectionsStandardComponents projectionsStandardComponents)
{
var coreTimeoutSchedulers =
CreateTimeoutSchedulers(projectionsStandardComponents.ProjectionWorkerThreadCount);
var coreQueues = new Dictionary <Guid, IQueuedHandler>();
while (coreQueues.Count < projectionsStandardComponents.ProjectionWorkerThreadCount)
{
var coreInputBus = new InMemoryBus("bus");
var coreQueue = QueuedHandler.CreateQueuedHandler(coreInputBus,
"Projection Core #" + coreQueues.Count,
groupName: "Projection Core");
var workerId = Guid.NewGuid();
var projectionNode = new ProjectionWorkerNode(
workerId,
standardComponents.Db,
coreQueue,
standardComponents.TimeProvider,
coreTimeoutSchedulers[coreQueues.Count],
projectionsStandardComponents.RunProjections);
projectionNode.SetupMessaging(coreInputBus);
var forwarder = new RequestResponseQueueForwarder(
inputQueue: coreQueue,
externalRequestQueue: standardComponents.MainQueue);
// forwarded messages
var coreOutput = projectionNode.CoreOutput;
coreOutput.Subscribe <ClientMessage.ReadEvent>(forwarder);
coreOutput.Subscribe <ClientMessage.ReadStreamEventsBackward>(forwarder);
coreOutput.Subscribe <ClientMessage.ReadStreamEventsForward>(forwarder);
coreOutput.Subscribe <ClientMessage.ReadAllEventsForward>(forwarder);
coreOutput.Subscribe <ClientMessage.WriteEvents>(forwarder);
coreOutput.Subscribe <ClientMessage.DeleteStream>(forwarder);
if (projectionsStandardComponents.RunProjections >= ProjectionType.System)
{
var slaveProjectionResponseWriter = projectionNode.SlaveProjectionResponseWriter;
coreOutput.Subscribe <PartitionMeasuredOutput>(slaveProjectionResponseWriter);
coreOutput.Subscribe <PartitionProcessingProgressOutput>(slaveProjectionResponseWriter);
coreOutput.Subscribe <PartitionProcessingResultOutput>(slaveProjectionResponseWriter);
coreOutput.Subscribe <ReaderSubscriptionManagement.SpoolStreamReading>(slaveProjectionResponseWriter);
coreOutput.Subscribe(
Forwarder.Create <AwakeServiceMessage.SubscribeAwake>(standardComponents.MainQueue));
coreOutput.Subscribe(
Forwarder.Create <AwakeServiceMessage.UnsubscribeAwake>(standardComponents.MainQueue));
}
coreOutput.Subscribe <TimerMessage.Schedule>(standardComponents.TimerService);
coreOutput.Subscribe(Forwarder.Create <Message>(coreQueue)); // forward all
coreInputBus.Subscribe(new UnwrapEnvelopeHandler());
coreQueues.Add(workerId, coreQueue);
}
var queues = coreQueues.Select(v => v.Value).Cast <IPublisher>().ToArray();
var coordinator = new ProjectionCoreCoordinator(
projectionsStandardComponents.RunProjections,
coreTimeoutSchedulers,
queues,
projectionsStandardComponents.MasterOutputBus,
new PublishEnvelope(projectionsStandardComponents.MasterInputQueue, crossThread: true));
coordinator.SetupMessaging(projectionsStandardComponents.MasterMainBus);
projectionsStandardComponents.MasterMainBus.Subscribe(
Forwarder.CreateBalancing <FeedReaderMessage.ReadPage>(coreQueues.Values.Cast <IPublisher>().ToArray()));
return(coreQueues);
}
private void SetupMessaging(
TFChunkDb db, QueuedHandler mainQueue, InMemoryBus mainBus, TimerService timerService,
HttpService httpService)
{
_coreQueues = new List <QueuedHandler>();
_managerInputBus = new InMemoryBus("manager input bus");
_managerInputQueue = new QueuedHandler(_managerInputBus, "ProjectionManager");
while (_coreQueues.Count < _projectionWorkerThreadCount)
{
var coreInputBus = new InMemoryBus("bus");
var coreQueue = new QueuedHandler(coreInputBus, "ProjectionCoreQueue #" + _coreQueues.Count);
var projectionNode = new ProjectionWorkerNode(db, coreQueue);
projectionNode.SetupMessaging(coreInputBus);
var forwarder = new RequestResponseQueueForwarder(
inputQueue: coreQueue, externalRequestQueue: mainQueue);
// forwarded messages
projectionNode.CoreOutput.Subscribe <ClientMessage.ReadEvent>(forwarder);
projectionNode.CoreOutput.Subscribe <ClientMessage.ReadStreamEventsBackward>(forwarder);
projectionNode.CoreOutput.Subscribe <ClientMessage.ReadStreamEventsForward>(forwarder);
projectionNode.CoreOutput.Subscribe <ClientMessage.ReadAllEventsForward>(forwarder);
projectionNode.CoreOutput.Subscribe <ClientMessage.WriteEvents>(forwarder);
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.StateReport>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.StatisticsReport>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.Started>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.Stopped>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.Faulted>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.Prepared>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(timerService);
projectionNode.CoreOutput.Subscribe(Forwarder.Create <Message>(coreQueue)); // forward all
coreInputBus.Subscribe(new UnwrapEnvelopeHandler());
_coreQueues.Add(coreQueue);
}
_projectionManagerNode = ProjectionManagerNode.Create(
db, _managerInputQueue, httpService, _coreQueues.Cast <IPublisher>().ToArray());
_projectionManagerNode.SetupMessaging(_managerInputBus);
{
var forwarder = new RequestResponseQueueForwarder(
inputQueue: _managerInputQueue, externalRequestQueue: mainQueue);
_projectionManagerNode.Output.Subscribe <ClientMessage.ReadEvent>(forwarder);
_projectionManagerNode.Output.Subscribe <ClientMessage.ReadStreamEventsBackward>(forwarder);
_projectionManagerNode.Output.Subscribe <ClientMessage.ReadStreamEventsForward>(forwarder);
_projectionManagerNode.Output.Subscribe <ClientMessage.WriteEvents>(forwarder);
_projectionManagerNode.Output.Subscribe(Forwarder.Create <Message>(_managerInputQueue));
// self forward all
mainBus.Subscribe(Forwarder.Create <SystemMessage.StateChangeMessage>(_managerInputQueue));
_managerInputBus.Subscribe(new UnwrapEnvelopeHandler());
}
}
private static void SubscribeOutputBus(
StandardComponents standardComponents,
ProjectionsStandardComponents projectionsStandardComponents,
RequestResponseQueueForwarder forwarder)
{
var managerOutput = projectionsStandardComponents.MasterOutputBus;
managerOutput.Subscribe<ClientMessage.ReadEvent>(forwarder);
managerOutput.Subscribe<ClientMessage.ReadStreamEventsBackward>(forwarder);
managerOutput.Subscribe<ClientMessage.ReadStreamEventsForward>(forwarder);
managerOutput.Subscribe<ClientMessage.WriteEvents>(forwarder);
managerOutput.Subscribe<ClientMessage.DeleteStream>(forwarder);
managerOutput.Subscribe(
Forwarder.Create<ProjectionManagementMessage.RequestSystemProjections>(standardComponents.MainQueue));
managerOutput.Subscribe(Forwarder.Create<Message>(projectionsStandardComponents.MasterInputQueue));
managerOutput.Subscribe<TimerMessage.Schedule>(standardComponents.TimerService);
managerOutput.Subscribe(Forwarder.Create<AwakeServiceMessage.SubscribeAwake>(standardComponents.MainQueue));
managerOutput.Subscribe(
Forwarder.Create<AwakeServiceMessage.UnsubscribeAwake>(standardComponents.MainQueue));
managerOutput.Subscribe<SystemMessage.SubSystemInitialized>(forwarder);
// self forward all
standardComponents.MainBus.Subscribe(
Forwarder.Create<SystemMessage.StateChangeMessage>(projectionsStandardComponents.MasterInputQueue));
standardComponents.MainBus.Subscribe(
Forwarder.Create<SystemMessage.SystemCoreReady>(projectionsStandardComponents.MasterInputQueue));
projectionsStandardComponents.MasterMainBus.Subscribe(new UnwrapEnvelopeHandler());
}
private void SetupMessaging(
TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService, ITimeProvider timeProvider,
IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendQueue, RunProjections runProjections)
{
_coreQueues = new List <QueuedHandler>();
_managerInputBus = new InMemoryBus("manager input bus");
_managerInputQueue = new QueuedHandler(_managerInputBus, "Projections Master");
while (_coreQueues.Count < _projectionWorkerThreadCount)
{
var coreInputBus = new InMemoryBus("bus");
var coreQueue = new QueuedHandler(
coreInputBus, "Projection Core #" + _coreQueues.Count, groupName: "Projection Core");
var projectionNode = new ProjectionWorkerNode(db, coreQueue, timeProvider, runProjections);
projectionNode.SetupMessaging(coreInputBus);
var forwarder = new RequestResponseQueueForwarder(
inputQueue: coreQueue, externalRequestQueue: mainQueue);
// forwarded messages
projectionNode.CoreOutput.Subscribe <ClientMessage.ReadEvent>(forwarder);
projectionNode.CoreOutput.Subscribe <ClientMessage.ReadStreamEventsBackward>(forwarder);
projectionNode.CoreOutput.Subscribe <ClientMessage.ReadStreamEventsForward>(forwarder);
projectionNode.CoreOutput.Subscribe <ClientMessage.ReadAllEventsForward>(forwarder);
projectionNode.CoreOutput.Subscribe <ClientMessage.WriteEvents>(forwarder);
if (runProjections >= RunProjections.System)
{
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.StateReport>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.ResultReport>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.StatisticsReport>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.Started>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.Stopped>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.Faulted>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.Prepared>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <CoreProjectionManagementMessage.SlaveProjectionReaderAssigned>(
_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <ProjectionManagementMessage.ControlMessage>(_managerInputQueue));
}
projectionNode.CoreOutput.Subscribe <TimerMessage.Schedule>(timerService);
projectionNode.CoreOutput.Subscribe(Forwarder.Create <Message>(coreQueue)); // forward all
coreInputBus.Subscribe(new UnwrapEnvelopeHandler());
_coreQueues.Add(coreQueue);
}
_managerInputBus.Subscribe(
Forwarder.CreateBalancing <FeedReaderMessage.ReadPage>(_coreQueues.Cast <IPublisher>().ToArray()));
_projectionManagerNode = ProjectionManagerNode.Create(
db, _managerInputQueue, httpForwarder, httpServices, networkSendQueue,
_coreQueues.Cast <IPublisher>().ToArray(), runProjections);
_projectionManagerNode.SetupMessaging(_managerInputBus);
{
var forwarder = new RequestResponseQueueForwarder(
inputQueue: _managerInputQueue, externalRequestQueue: mainQueue);
_projectionManagerNode.Output.Subscribe <ClientMessage.ReadEvent>(forwarder);
_projectionManagerNode.Output.Subscribe <ClientMessage.ReadStreamEventsBackward>(forwarder);
_projectionManagerNode.Output.Subscribe <ClientMessage.ReadStreamEventsForward>(forwarder);
_projectionManagerNode.Output.Subscribe <ClientMessage.WriteEvents>(forwarder);
_projectionManagerNode.Output.Subscribe(
Forwarder.Create <ProjectionManagementMessage.RequestSystemProjections>(mainQueue));
_projectionManagerNode.Output.Subscribe(Forwarder.Create <Message>(_managerInputQueue));
_projectionManagerNode.Output.Subscribe <TimerMessage.Schedule>(timerService);
// self forward all
mainBus.Subscribe(Forwarder.Create <SystemMessage.StateChangeMessage>(_managerInputQueue));
_managerInputBus.Subscribe(new UnwrapEnvelopeHandler());
}
}
private void SetupMessaging(
TFChunkDb db, QueuedHandler mainQueue, InMemoryBus mainBus, TimerService timerService,
HttpService httpService)
{
_coreQueues = new List<QueuedHandler>();
_managerInputBus = new InMemoryBus("manager input bus");
_managerInputQueue = new QueuedHandler(_managerInputBus, "ProjectionManager");
while (_coreQueues.Count < _projectionWorkerThreadCount)
{
var coreInputBus = new InMemoryBus("bus");
var coreQueue = new QueuedHandler(coreInputBus, "ProjectionCoreQueue #" + _coreQueues.Count);
var projectionNode = new ProjectionWorkerNode(db, coreQueue);
projectionNode.SetupMessaging(coreInputBus);
var forwarder = new RequestResponseQueueForwarder(
inputQueue: coreQueue, externalRequestQueue: mainQueue);
// forwarded messages
projectionNode.CoreOutput.Subscribe<ClientMessage.ReadEvent>(forwarder);
projectionNode.CoreOutput.Subscribe<ClientMessage.ReadStreamEventsBackward>(forwarder);
projectionNode.CoreOutput.Subscribe<ClientMessage.ReadStreamEventsForward>(forwarder);
projectionNode.CoreOutput.Subscribe<ClientMessage.ReadAllEventsForward>(forwarder);
projectionNode.CoreOutput.Subscribe<ClientMessage.WriteEvents>(forwarder);
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<ProjectionMessage.Projections.Management.StateReport>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<ProjectionMessage.Projections.Management.StatisticsReport>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<ProjectionMessage.Projections.StatusReport.Started>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<ProjectionMessage.Projections.StatusReport.Stopped>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<ProjectionMessage.Projections.StatusReport.Faulted>(_managerInputQueue));
projectionNode.CoreOutput.Subscribe(timerService);
projectionNode.CoreOutput.Subscribe(Forwarder.Create<Message>(coreQueue)); // forward all
coreInputBus.Subscribe(new UnwrapEnvelopeHandler());
_coreQueues.Add(coreQueue);
}
_projectionManagerNode = ProjectionManagerNode.Create(
db, _managerInputQueue, httpService, _coreQueues.Cast<IPublisher>().ToArray());
_projectionManagerNode.SetupMessaging(_managerInputBus);
{
var forwarder = new RequestResponseQueueForwarder(
inputQueue: _managerInputQueue, externalRequestQueue: mainQueue);
_projectionManagerNode.Output.Subscribe<ClientMessage.ReadEvent>(forwarder);
_projectionManagerNode.Output.Subscribe<ClientMessage.ReadStreamEventsBackward>(forwarder);
_projectionManagerNode.Output.Subscribe<ClientMessage.ReadStreamEventsForward>(forwarder);
_projectionManagerNode.Output.Subscribe<ClientMessage.WriteEvents>(forwarder);
_projectionManagerNode.Output.Subscribe(Forwarder.Create<Message>(_managerInputQueue));
// self forward all
mainBus.Subscribe(Forwarder.Create<SystemMessage.SystemInit>(_managerInputQueue));
mainBus.Subscribe(Forwarder.Create<SystemMessage.SystemStart>(_managerInputQueue));
mainBus.Subscribe(Forwarder.Create<SystemMessage.StateChangeMessage>(_managerInputQueue));
_managerInputBus.Subscribe(new UnwrapEnvelopeHandler());
}
}
