public void SetUp()
{
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher
(_bus);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CheckpointSuggested>());
_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 <ProjectionCoreServiceMessage.CoreTick>(this);
_bus.Subscribe <ReaderCoreServiceMessage.ReaderTick>(this);
_awakeReaderService = new AwakeReaderService();
_bus.Subscribe <StorageMessage.EventCommitted>(_awakeReaderService);
_bus.Subscribe <StorageMessage.TfEofAtNonCommitRecord>(_awakeReaderService);
_bus.Subscribe <AwakeReaderServiceMessage.SubscribeAwake>(_awakeReaderService);
_bus.Subscribe <AwakeReaderServiceMessage.UnsubscribeAwake>(_awakeReaderService);
_bus.Subscribe(new UnwrapEnvelopeHandler());
}
public void Setup()
{
//TODO: this became an integration test - proper ProjectionCoreService and ProjectionManager testing is required as well
_bus.Subscribe(_consumer);
_manager = new ProjectionManager(
GetInputQueue(), GetInputQueue(), GivenCoreQueues(), _timeProvider, RunProjections.All,
_initializeSystemProjections);
IPublisher inputQueue = GetInputQueue();
IPublisher publisher = GetInputQueue();
var ioDispatcher = new IODispatcher(publisher, new PublishEnvelope(inputQueue));
_bus.Subscribe <ProjectionManagementMessage.Internal.CleanupExpired>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Internal.Deleted>(_manager);
_bus.Subscribe <CoreProjectionManagementMessage.Started>(_manager);
_bus.Subscribe <CoreProjectionManagementMessage.Stopped>(_manager);
_bus.Subscribe <CoreProjectionManagementMessage.Prepared>(_manager);
_bus.Subscribe <CoreProjectionManagementMessage.Faulted>(_manager);
_bus.Subscribe <CoreProjectionManagementMessage.StateReport>(_manager);
_bus.Subscribe <CoreProjectionManagementMessage.ResultReport>(_manager);
_bus.Subscribe <CoreProjectionManagementMessage.StatisticsReport>(_manager);
_bus.Subscribe <CoreProjectionManagementMessage.SlaveProjectionReaderAssigned>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Post>(_manager);
_bus.Subscribe <ProjectionManagementMessage.UpdateQuery>(_manager);
_bus.Subscribe <ProjectionManagementMessage.GetQuery>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Delete>(_manager);
_bus.Subscribe <ProjectionManagementMessage.GetStatistics>(_manager);
_bus.Subscribe <ProjectionManagementMessage.GetState>(_manager);
_bus.Subscribe <ProjectionManagementMessage.GetResult>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Disable>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Enable>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Abort>(_manager);
_bus.Subscribe <ProjectionManagementMessage.SetRunAs>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Reset>(_manager);
_bus.Subscribe <ProjectionManagementMessage.StartSlaveProjections>(_manager);
_bus.Subscribe <ClientMessage.WriteEventsCompleted>(_manager);
_bus.Subscribe <ClientMessage.ReadStreamEventsBackwardCompleted>(_manager);
_bus.Subscribe <ClientMessage.WriteEventsCompleted>(_manager);
_bus.Subscribe <SystemMessage.StateChangeMessage>(_manager);
_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);
_awakeReaderService = new AwakeReaderService();
_bus.Subscribe <StorageMessage.EventCommitted>(_awakeReaderService);
_bus.Subscribe <StorageMessage.TfEofAtNonCommitRecord>(_awakeReaderService);
_bus.Subscribe <AwakeReaderServiceMessage.SubscribeAwake>(_awakeReaderService);
_bus.Subscribe <AwakeReaderServiceMessage.UnsubscribeAwake>(_awakeReaderService);
Given();
WhenLoop();
}
private void Given()
{
_it = new AwakeReaderService();
_eventRecord = new EventRecord(
10,
new PrepareLogRecord(
500, Guid.NewGuid(), Guid.NewGuid(), 500, 0, "Stream", 99, DateTime.UtcNow, PrepareFlags.Data,
"event", new byte[0], null));
_eventCommited = new StorageMessage.EventCommited(1000, _eventRecord);
}
private void Given()
{
_it = new AwakeReaderService();
_eventRecord = new EventRecord(
10,
new PrepareLogRecord(
500, Guid.NewGuid(), Guid.NewGuid(), 500, 0, "Stream", 99, DateTime.UtcNow, PrepareFlags.Data,
"event", new byte[0], null));
_eventCommitted = new StorageMessage.EventCommitted(1000, _eventRecord, isTfEof: true);
}
private void Given()
{
_it = new AwakeReaderService();
_eventRecord = new EventRecord(
100,
new PrepareLogRecord(
1500, Guid.NewGuid(), Guid.NewGuid(), 1500, 0, "Stream", 99, DateTime.UtcNow, PrepareFlags.Data,
"event", new byte[0], null));
_eventCommitted = new StorageMessage.EventCommitted(2000, _eventRecord, isTfEof: true);
_publisher = new InMemoryBus("bus");
_envelope = new PublishEnvelope(_publisher);
_handler = new TestHandler<TestMessage>();
_publisher.Subscribe(_handler);
_reply1 = new TestMessage(1);
_reply2 = new TestMessage(2);
_reply3 = new TestMessage(3);
_reply4 = new TestMessage(4);
_reply5 = new TestMessage(5);
_correlationId1 = Guid.NewGuid();
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, _correlationId1, "Stream", new TFPos(1000, 500), _reply1));
_correlationId2 = Guid.NewGuid();
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, _correlationId2, "Stream", new TFPos(100000, 99500), _reply2));
_correlationId3 = Guid.NewGuid();
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, _correlationId3, "Stream2", new TFPos(1000, 500), _reply3));
_correlationId4 = Guid.NewGuid();
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, _correlationId4, null, new TFPos(1000, 500), _reply4));
_correlationId5 = Guid.NewGuid();
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, _correlationId5, null, new TFPos(100000, 99500), _reply5));
}
private void Given()
{
_it = new AwakeReaderService();
_eventRecord = new EventRecord(
100,
new PrepareLogRecord(
1500, Guid.NewGuid(), Guid.NewGuid(), 1500, 0, "Stream", 99, DateTime.UtcNow, PrepareFlags.Data,
"event", new byte[0], null));
_eventCommitted = new StorageMessage.EventCommitted(2000, _eventRecord, isTfEof: true);
_publisher = new InMemoryBus("bus");
_envelope = new PublishEnvelope(_publisher);
_handler = new TestHandler <TestMessage>();
_publisher.Subscribe(_handler);
_reply1 = new TestMessage(1);
_reply2 = new TestMessage(2);
_reply3 = new TestMessage(3);
_reply4 = new TestMessage(4);
_reply5 = new TestMessage(5);
_correlationId1 = Guid.NewGuid();
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, _correlationId1, "Stream", new TFPos(1000, 500), _reply1));
_correlationId2 = Guid.NewGuid();
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, _correlationId2, "Stream", new TFPos(100000, 99500), _reply2));
_correlationId3 = Guid.NewGuid();
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, _correlationId3, "Stream2", new TFPos(1000, 500), _reply3));
_correlationId4 = Guid.NewGuid();
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, _correlationId4, null, new TFPos(1000, 500), _reply4));
_correlationId5 = Guid.NewGuid();
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, _correlationId5, null, new TFPos(100000, 99500), _reply5));
}
private void Given()
{
_it = new AwakeReaderService();
_eventRecord = new EventRecord(
100,
new PrepareLogRecord(
1500, Guid.NewGuid(), Guid.NewGuid(), 1500, 0, "Stream", 99, DateTime.UtcNow, PrepareFlags.Data,
"event", new byte[0], null));
_eventCommited = new StorageMessage.EventCommited(2000, _eventRecord);
_publisher = new InMemoryBus("bus");
_envelope = new PublishEnvelope(_publisher);
_handler = new TestHandler<TestMessage>();
_publisher.Subscribe(_handler);
_reply1 = new TestMessage(1);
_reply2 = new TestMessage(2);
_reply3 = new TestMessage(3);
_reply4 = new TestMessage(4);
_reply5 = new TestMessage(5);
_it.Handle(_eventCommited);
}
public void Setup()
{
//TODO: this became an integration test - proper ProjectionCoreService and ProjectionManager testing is required as well
_bus.Subscribe(_consumer);
_manager = new ProjectionManager(
GetInputQueue(), GetInputQueue(), GivenCoreQueues(), _timeProvider, RunProjections.All,
_initializeSystemProjections);
IPublisher inputQueue = GetInputQueue();
IPublisher publisher = GetInputQueue();
var ioDispatcher = new IODispatcher(publisher, new PublishEnvelope(inputQueue));
_bus.Subscribe<ProjectionManagementMessage.Internal.CleanupExpired>(_manager);
_bus.Subscribe<ProjectionManagementMessage.Internal.Deleted>(_manager);
_bus.Subscribe<CoreProjectionManagementMessage.Started>(_manager);
_bus.Subscribe<CoreProjectionManagementMessage.Stopped>(_manager);
_bus.Subscribe<CoreProjectionManagementMessage.Prepared>(_manager);
_bus.Subscribe<CoreProjectionManagementMessage.Faulted>(_manager);
_bus.Subscribe<CoreProjectionManagementMessage.StateReport>(_manager);
_bus.Subscribe<CoreProjectionManagementMessage.ResultReport>(_manager);
_bus.Subscribe<CoreProjectionManagementMessage.StatisticsReport>(_manager);
_bus.Subscribe<CoreProjectionManagementMessage.SlaveProjectionReaderAssigned>(_manager);
_bus.Subscribe<ProjectionManagementMessage.Post>(_manager);
_bus.Subscribe<ProjectionManagementMessage.UpdateQuery>(_manager);
_bus.Subscribe<ProjectionManagementMessage.GetQuery>(_manager);
_bus.Subscribe<ProjectionManagementMessage.Delete>(_manager);
_bus.Subscribe<ProjectionManagementMessage.GetStatistics>(_manager);
_bus.Subscribe<ProjectionManagementMessage.GetState>(_manager);
_bus.Subscribe<ProjectionManagementMessage.GetResult>(_manager);
_bus.Subscribe<ProjectionManagementMessage.Disable>(_manager);
_bus.Subscribe<ProjectionManagementMessage.Enable>(_manager);
_bus.Subscribe<ProjectionManagementMessage.Abort>(_manager);
_bus.Subscribe<ProjectionManagementMessage.SetRunAs>(_manager);
_bus.Subscribe<ProjectionManagementMessage.Reset>(_manager);
_bus.Subscribe<ProjectionManagementMessage.StartSlaveProjections>(_manager);
_bus.Subscribe<ClientMessage.WriteEventsCompleted>(_manager);
_bus.Subscribe<ClientMessage.ReadStreamEventsBackwardCompleted>(_manager);
_bus.Subscribe<ClientMessage.WriteEventsCompleted>(_manager);
_bus.Subscribe<SystemMessage.StateChangeMessage>(_manager);
_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);
_awakeReaderService = new AwakeReaderService();
_bus.Subscribe<StorageMessage.EventCommitted>(_awakeReaderService);
_bus.Subscribe<StorageMessage.TfEofAtNonCommitRecord>(_awakeReaderService);
_bus.Subscribe<AwakeReaderServiceMessage.SubscribeAwake>(_awakeReaderService);
_bus.Subscribe<AwakeReaderServiceMessage.UnsubscribeAwake>(_awakeReaderService);
Given();
WhenLoop();
}
public void it_can_ce_created()
{
var it = new AwakeReaderService();
}
public void it_can_ce_created()
{
var it = new AwakeReaderService();
}
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(
Forwarder.Create <AwakeReaderServiceMessage.SubscribeAwake>(mainQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create <AwakeReaderServiceMessage.UnsubscribeAwake>(mainQueue));
}
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()));
var awakeReaderService = new AwakeReaderService();
mainBus.Subscribe <StorageMessage.EventCommitted>(awakeReaderService);
mainBus.Subscribe <StorageMessage.TfEofAtNonCommitRecord>(awakeReaderService);
mainBus.Subscribe <AwakeReaderServiceMessage.SubscribeAwake>(awakeReaderService);
mainBus.Subscribe <AwakeReaderServiceMessage.UnsubscribeAwake>(awakeReaderService);
_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, 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(
Forwarder.Create<AwakeReaderServiceMessage.SubscribeAwake>(mainQueue));
projectionNode.CoreOutput.Subscribe(
Forwarder.Create<AwakeReaderServiceMessage.UnsubscribeAwake>(mainQueue));
}
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()));
var awakeReaderService = new AwakeReaderService();
mainBus.Subscribe<StorageMessage.EventCommitted>(awakeReaderService);
mainBus.Subscribe<StorageMessage.TfEofAtNonCommitRecord>(awakeReaderService);
mainBus.Subscribe<AwakeReaderServiceMessage.SubscribeAwake>(awakeReaderService);
mainBus.Subscribe<AwakeReaderServiceMessage.UnsubscribeAwake>(awakeReaderService);
_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());
}
}
