public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestHandler<ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus));
_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.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ReaderAssignedReader>());
_bus.Subscribe(_ioDispatcher.BackwardReader);
_bus.Subscribe(_ioDispatcher.ForwardReader);
_bus.Subscribe(_ioDispatcher.Writer);
_bus.Subscribe(_ioDispatcher);
IProjectionStateHandler projectionStateHandler = new FakeProjectionStateHandler();
_projectionConfig = new ProjectionConfig(null, 5, 10, 1000, 250, true, true, false, false, false);
var version = new ProjectionVersion(1, 0, 0);
var projectionProcessingStrategy = new ContinuousProjectionProcessingStrategy(
"projection", version, projectionStateHandler, _projectionConfig,
projectionStateHandler.GetSourceDefinition(), null, _subscriptionDispatcher);
_coreProjection = projectionProcessingStrategy.Create(
Guid.NewGuid(), _bus, SystemAccount.Principal, _bus, _ioDispatcher, _subscriptionDispatcher,
new RealTimeProvider());
_coreProjection.Start();
}
public IAuthenticationProvider BuildAuthenticationProvider(IPublisher mainQueue, IBus mainBus, IPublisher workersQueue, InMemoryBus[] workerBusses)
{
var passwordHashAlgorithm = new Rfc2898PasswordHashAlgorithm();
var dispatcher = new IODispatcher(mainQueue, new PublishEnvelope(workersQueue, crossThread: true));
foreach (var bus in workerBusses) {
bus.Subscribe(dispatcher.ForwardReader);
bus.Subscribe(dispatcher.BackwardReader);
bus.Subscribe(dispatcher.Writer);
bus.Subscribe(dispatcher.StreamDeleter);
bus.Subscribe(dispatcher);
}
// USER MANAGEMENT
var ioDispatcher = new IODispatcher(mainQueue, new PublishEnvelope(mainQueue));
mainBus.Subscribe(ioDispatcher.BackwardReader);
mainBus.Subscribe(ioDispatcher.ForwardReader);
mainBus.Subscribe(ioDispatcher.Writer);
mainBus.Subscribe(ioDispatcher.StreamDeleter);
mainBus.Subscribe(ioDispatcher);
var userManagement = new UserManagementService(mainQueue, ioDispatcher, passwordHashAlgorithm, skipInitializeStandardUsersCheck: false);
mainBus.Subscribe<UserManagementMessage.Create>(userManagement);
mainBus.Subscribe<UserManagementMessage.Update>(userManagement);
mainBus.Subscribe<UserManagementMessage.Enable>(userManagement);
mainBus.Subscribe<UserManagementMessage.Disable>(userManagement);
mainBus.Subscribe<UserManagementMessage.Delete>(userManagement);
mainBus.Subscribe<UserManagementMessage.ResetPassword>(userManagement);
mainBus.Subscribe<UserManagementMessage.ChangePassword>(userManagement);
mainBus.Subscribe<UserManagementMessage.Get>(userManagement);
mainBus.Subscribe<UserManagementMessage.GetAll>(userManagement);
mainBus.Subscribe<SystemMessage.BecomeMaster>(userManagement);
return new InternalAuthenticationProvider(dispatcher, passwordHashAlgorithm, ESConsts.CachedPrincipalCount);
}
public 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));
_readerService = new EventReaderCoreService(_bus, ioDispatcher, 10, writerCheckpoint, runHeadingReader: true);
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(_bus);
_spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(_bus);
_timeoutScheduler = new TimeoutScheduler();
_workerId = Guid.NewGuid();
_service = new ProjectionCoreService(
_workerId, _bus, _bus, _subscriptionDispatcher, new RealTimeProvider(), ioDispatcher,
_spoolProcessingResponseDispatcher, _timeoutScheduler);
_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>());
_readerService.Handle(new Messages.ReaderCoreServiceMessage.StartReader());
_service.Handle(new ProjectionCoreServiceMessage.StartCore());
}
public override sealed IProjectionProcessingPhase[] CreateProcessingPhases(
IPublisher publisher, Guid projectionCorrelationId, PartitionStateCache partitionStateCache,
Action updateStatistics, CoreProjection coreProjection, ProjectionNamesBuilder namingBuilder,
ITimeProvider timeProvider, IODispatcher ioDispatcher,
CoreProjectionCheckpointWriter coreProjectionCheckpointWriter)
{
var definesFold = _sourceDefinition.DefinesFold;
var readerStrategy = CreateReaderStrategy(timeProvider);
var zeroCheckpointTag = readerStrategy.PositionTagger.MakeZeroCheckpointTag();
var checkpointManager = CreateCheckpointManager(
projectionCorrelationId, publisher, ioDispatcher, namingBuilder, coreProjectionCheckpointWriter,
definesFold, readerStrategy);
var resultWriter = CreateFirstPhaseResultWriter(
checkpointManager as IEmittedEventWriter, zeroCheckpointTag, namingBuilder);
var firstPhase = CreateFirstProcessingPhase(
publisher, projectionCorrelationId, partitionStateCache, updateStatistics, coreProjection,
_subscriptionDispatcher, zeroCheckpointTag, checkpointManager, readerStrategy, resultWriter);
return CreateProjectionProcessingPhases(
publisher, projectionCorrelationId, namingBuilder, partitionStateCache, coreProjection, ioDispatcher,
firstPhase);
}
public IEventReader CreatePausedEventReader(
Guid eventReaderId, IPublisher publisher, IODispatcher ioDispatcher, CheckpointTag checkpointTag,
bool stopOnEof, int? stopAfterNEvents)
{
return new AllStreamsCatalogEventReader(
ioDispatcher, publisher, eventReaderId, _runAs, checkpointTag.CatalogPosition + 1, _timeProvider, stopOnEof: stopOnEof);
}
protected override IProjectionProcessingPhase[] CreateProjectionProcessingPhases(
IPublisher publisher, Guid projectionCorrelationId, ProjectionNamesBuilder namingBuilder,
PartitionStateCache partitionStateCache, CoreProjection coreProjection, IODispatcher ioDispatcher,
IProjectionProcessingPhase firstPhase)
{
var coreProjectionCheckpointWriter =
new CoreProjectionCheckpointWriter(
namingBuilder.MakeCheckpointStreamName(), ioDispatcher, _projectionVersion, _name);
var checkpointManager2 = new DefaultCheckpointManager(
publisher, projectionCorrelationId, _projectionVersion, _projectionConfig.RunAs, ioDispatcher,
_projectionConfig, _name, new PhasePositionTagger(1), namingBuilder, GetUseCheckpoints(), false,
_sourceDefinition.DefinesFold, coreProjectionCheckpointWriter);
IProjectionProcessingPhase writeResultsPhase;
if (GetProducesRunningResults()
|| !string.IsNullOrEmpty(_sourceDefinition.CatalogStream) && _sourceDefinition.ByStreams)
writeResultsPhase = new WriteQueryEofProjectionProcessingPhase(
1, namingBuilder.GetResultStreamName(), coreProjection, partitionStateCache, checkpointManager2,
checkpointManager2);
else
writeResultsPhase = new WriteQueryResultProjectionProcessingPhase(
1, namingBuilder.GetResultStreamName(), coreProjection, partitionStateCache, checkpointManager2,
checkpointManager2);
return new[] {firstPhase, writeResultsPhase};
}
protected override IProjectionProcessingPhase[] CreateProjectionProcessingPhases(
IPublisher publisher, Guid projectionCorrelationId, ProjectionNamesBuilder namingBuilder,
PartitionStateCache partitionStateCache, CoreProjection coreProjection, IODispatcher ioDispatcher,
IProjectionProcessingPhase firstPhase)
{
return new[] {firstPhase};
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
WriterCheckpoint = new InMemoryCheckpoint(0);
ChaserCheckpoint = new InMemoryCheckpoint(0);
Bus = new InMemoryBus("bus");
IODispatcher = new IODispatcher(Bus, new PublishEnvelope(Bus));
Db = new TFChunkDb(new TFChunkDbConfig(PathName,
new VersionedPatternFileNamingStrategy(PathName, "chunk-"),
10000,
0,
WriterCheckpoint,
ChaserCheckpoint,
new InMemoryCheckpoint(-1),
new InMemoryCheckpoint(-1)));
Db.Open();
// create db
Writer = new TFChunkWriter(Db);
Writer.Open();
WriteTestScenario();
Writer.Close();
Writer = null;
WriterCheckpoint.Flush();
ChaserCheckpoint.Write(WriterCheckpoint.Read());
ChaserCheckpoint.Flush();
var readers = new ObjectPool<ITransactionFileReader>("Readers", 2, 5, () => new TFChunkReader(Db, Db.Config.WriterCheckpoint));
var lowHasher = new XXHashUnsafe();
var highHasher = new Murmur3AUnsafe();
TableIndex = new TableIndex(GetFilePathFor("index"), lowHasher, highHasher,
() => new HashListMemTable(PTableVersions.Index64Bit, MaxEntriesInMemTable * 2),
() => new TFReaderLease(readers),
PTableVersions.Index64Bit,
MaxEntriesInMemTable);
ReadIndex = new ReadIndex(new NoopPublisher(),
readers,
TableIndex,
0,
additionalCommitChecks: true,
metastreamMaxCount: MetastreamMaxCount,
hashCollisionReadLimit: Opts.HashCollisionReadLimitDefault);
ReadIndex.Init(ChaserCheckpoint.Read());
// scavenge must run after readIndex is built
if (_scavenge)
{
if (_completeLastChunkOnScavenge)
Db.Manager.GetChunk(Db.Manager.ChunksCount - 1).Complete();
_scavenger = new TFChunkScavenger(Db, IODispatcher, TableIndex, ReadIndex, Guid.NewGuid(), "fakeNodeIp");
_scavenger.Scavenge(alwaysKeepScavenged: true, mergeChunks: _mergeChunks);
}
}
public IEventReader CreatePausedEventReader(
Guid eventReaderId, IPublisher publisher, IODispatcher ioDispatcher, CheckpointTag checkpointTag,
bool stopOnEof, int? stopAfterNEvents)
{
return new ExternallyFedByStreamEventReader(
publisher, eventReaderId, SystemAccount.Principal, ioDispatcher, checkpointTag.CommitPosition,
_timeProvider, resolveLinkTos: true);
}
public override IProjectionProcessingPhase[] CreateProcessingPhases(
IPublisher publisher, Guid projectionCorrelationId, PartitionStateCache partitionStateCache,
Action updateStatistics, CoreProjection coreProjection, ProjectionNamesBuilder namingBuilder,
ITimeProvider timeProvider, IODispatcher ioDispatcher,
CoreProjectionCheckpointWriter coreProjectionCheckpointWriter)
{
return new IProjectionProcessingPhase[] {_phase1, _phase2};
}
protected override ICoreProjectionCheckpointManager CreateCheckpointManager(
Guid projectionCorrelationId, IPublisher publisher, IODispatcher ioDispatcher, ProjectionNamesBuilder namingBuilder,
CoreProjectionCheckpointWriter coreProjectionCheckpointWriter, bool definesFold, IReaderStrategy readerStrategy)
{
return new NoopCheckpointManager(
publisher, projectionCorrelationId, _projectionConfig, _name, readerStrategy.PositionTagger,
namingBuilder);
}
public void Setup()
{
var fakePublisher = new FakePublisher();
_ioDispatcher = new IODispatcher(fakePublisher, new PublishEnvelope(fakePublisher));
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(new FakePublisher());
}
public IEventReader CreatePausedEventReader(
Guid eventReaderId, IPublisher publisher, IODispatcher ioDispatcher, CheckpointTag checkpointTag,
bool stopOnEof, int? stopAfterNEvents)
{
return new StreamEventReader(
publisher, eventReaderId, _runAs, _catalogStream, checkpointTag.CatalogPosition + 1, _timeProvider,
resolveLinkTos: true, stopOnEof: stopOnEof, stopAfterNEvents: stopAfterNEvents);
}
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 CoreProjectionCheckpointWriter(
string projectionCheckpointStreamId, IODispatcher ioDispatcher, ProjectionVersion projectionVersion,
string name)
{
_projectionCheckpointStreamId = projectionCheckpointStreamId;
_logger = LogManager.GetLoggerFor<CoreProjectionCheckpointWriter>();
_ioDispatcher = ioDispatcher;
_projectionVersion = projectionVersion;
_name = name;
}
public CoreProjectionCheckpointReader(
IPublisher publisher, Guid projectionCorrelationId, IODispatcher ioDispatcher, string projectionCheckpointStreamId, ProjectionVersion projectionVersion, bool useCheckpoints)
{
_publisher = publisher;
_projectionCorrelationId = projectionCorrelationId;
_ioDispatcher = ioDispatcher;
_projectionCheckpointStreamId = projectionCheckpointStreamId;
_projectionVersion = projectionVersion;
_useCheckpoints = useCheckpoints;
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_db = new TFChunkDb(new TFChunkDbConfig(PathName,
new VersionedPatternFileNamingStrategy(PathName, "chunk-"),
16 * 1024,
0,
new InMemoryCheckpoint(),
new InMemoryCheckpoint(),
new InMemoryCheckpoint(-1),
new InMemoryCheckpoint(-1)));
_db.Open();
var chunk = _db.Manager.GetChunkFor(0);
_p1 = LogRecord.SingleWrite(0, Guid.NewGuid(), Guid.NewGuid(), "es-to-scavenge", ExpectedVersion.Any, "et1",
new byte[] { 0, 1, 2 }, new byte[] { 5, 7 });
_res1 = chunk.TryAppend(_p1);
_c1 = LogRecord.Commit(_res1.NewPosition, Guid.NewGuid(), _p1.LogPosition, 0);
_cres1 = chunk.TryAppend(_c1);
_p2 = LogRecord.SingleWrite(_cres1.NewPosition,
Guid.NewGuid(), Guid.NewGuid(), "es-to-scavenge", ExpectedVersion.Any, "et1",
new byte[] { 0, 1, 2 }, new byte[] { 5, 7 });
_res2 = chunk.TryAppend(_p2);
_c2 = LogRecord.Commit(_res2.NewPosition, Guid.NewGuid(), _p2.LogPosition, 1);
_cres2 = chunk.TryAppend(_c2);
_p3 = LogRecord.SingleWrite(_cres2.NewPosition,
Guid.NewGuid(), Guid.NewGuid(), "es-to-scavenge", ExpectedVersion.Any, "et1",
new byte[] { 0, 1, 2 }, new byte[] { 5, 7 });
_res3 = chunk.TryAppend(_p3);
_c3 = LogRecord.Commit(_res3.NewPosition, Guid.NewGuid(), _p3.LogPosition, 2);
_cres3 = chunk.TryAppend(_c3);
chunk.Complete();
_db.Config.WriterCheckpoint.Write(chunk.ChunkHeader.ChunkEndPosition);
_db.Config.WriterCheckpoint.Flush();
_db.Config.ChaserCheckpoint.Write(chunk.ChunkHeader.ChunkEndPosition);
_db.Config.ChaserCheckpoint.Flush();
var bus = new InMemoryBus("Bus");
var ioDispatcher = new IODispatcher(bus, new PublishEnvelope(bus));
var scavenger = new TFChunkScavenger(_db, ioDispatcher, new FakeTableIndex(),
new FakeReadIndex(x => x == "es-to-scavenge"), Guid.NewGuid(), "fakeNodeIp");
scavenger.Scavenge(alwaysKeepScavenged: true, mergeChunks: false);
_scavengedChunk = _db.Manager.GetChunk(0);
}
public MultiStreamMultiOutputCheckpointManager(
IPublisher publisher, Guid projectionCorrelationId, ProjectionVersion projectionVersion, IPrincipal runAs,
IODispatcher ioDispatcher, ProjectionConfig projectionConfig, string name, PositionTagger positionTagger,
ProjectionNamesBuilder namingBuilder, bool useCheckpoints, bool producesRunningResults, bool definesFold,
CoreProjectionCheckpointWriter coreProjectionCheckpointWriter)
: base(
publisher, projectionCorrelationId, projectionVersion, runAs, ioDispatcher, projectionConfig, name,
positionTagger, namingBuilder, useCheckpoints, producesRunningResults, definesFold,
coreProjectionCheckpointWriter)
{
_positionTagger = positionTagger;
}
protected EventReader(
IODispatcher ioDispatcher, IPublisher publisher, Guid eventReaderCorrelationId, IPrincipal readAs,
bool stopOnEof, int? stopAfterNEvents)
{
if (publisher == null) throw new ArgumentNullException("publisher");
if (eventReaderCorrelationId == Guid.Empty)
throw new ArgumentException("eventReaderCorrelationId");
_publisher = publisher;
EventReaderCorrelationId = eventReaderCorrelationId;
_readAs = readAs;
_stopOnEof = stopOnEof;
_stopAfterNEvents = stopAfterNEvents;
}
protected override void Given()
{
_ioDispatcher = new IODispatcher(_node.Node.MainQueue, new PublishEnvelope(_node.Node.MainQueue));
_node.Node.MainBus.Subscribe(_ioDispatcher.BackwardReader);
_node.Node.MainBus.Subscribe(_ioDispatcher.ForwardReader);
_node.Node.MainBus.Subscribe(_ioDispatcher.Writer);
_node.Node.MainBus.Subscribe(_ioDispatcher.StreamDeleter);
_node.Node.MainBus.Subscribe(_ioDispatcher.Awaker);
_node.Node.MainBus.Subscribe(_ioDispatcher);
_projectionNamesBuilder = ProjectionNamesBuilder.CreateForTest(_projectionName);
_emittedStreamsTracker = new EmittedStreamsTracker(_ioDispatcher, new ProjectionConfig(null, 1000, 1000 * 1000, 100, 500, true, true, false, false, false, _trackEmittedStreams), _projectionNamesBuilder);
_emittedStreamsDeleter = new EmittedStreamsDeleter(_ioDispatcher, _projectionNamesBuilder.GetEmittedStreamsName(), _projectionNamesBuilder.GetEmittedStreamsCheckpointName());
}
protected void SetUpProvider()
{
_ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus));
_bus.Subscribe(_ioDispatcher.BackwardReader);
_bus.Subscribe(_ioDispatcher.ForwardReader);
_bus.Subscribe(_ioDispatcher.Writer);
_bus.Subscribe(_ioDispatcher.StreamDeleter);
_bus.Subscribe(_ioDispatcher);
PasswordHashAlgorithm passwordHashAlgorithm = new StubPasswordHashAlgorithm();
_internalAuthenticationProvider = new InternalAuthenticationProvider(_ioDispatcher, passwordHashAlgorithm, 1000);
_bus.Subscribe(_internalAuthenticationProvider);
}
public void setup()
{
_timeProvider = new FakeTimeProvider();
_queues = new Dictionary<Guid, IPublisher> {{Guid.NewGuid(), new FakePublisher()}};
_timeoutSchedulers = ProjectionCoreWorkersNode.CreateTimeoutSchedulers(_queues.Count);
var fakePublisher = new FakePublisher();
new ProjectionCoreCoordinator(
ProjectionType.All,
_timeoutSchedulers,
_queues.Values.ToArray(),
fakePublisher,
new NoopEnvelope());
_ioDispatcher = new IODispatcher(fakePublisher, new PublishEnvelope(fakePublisher));
}
public ProjectionWorkerNode(
Guid workerId,
TFChunkDb db,
QueuedHandler inputQueue,
ITimeProvider timeProvider,
ISingletonTimeoutScheduler timeoutScheduler,
ProjectionType runProjections)
{
_runProjections = runProjections;
Ensure.NotNull(db, "db");
_coreOutput = new InMemoryBus("Core Output");
IPublisher publisher = CoreOutput;
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(publisher);
_spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(publisher);
_ioDispatcher = new IODispatcher(publisher, new PublishEnvelope(inputQueue));
_eventReaderCoreService = new EventReaderCoreService(
publisher,
_ioDispatcher,
10,
db.Config.WriterCheckpoint,
runHeadingReader: runProjections >= ProjectionType.System);
_feedReaderService = new FeedReaderService(_subscriptionDispatcher, timeProvider);
if (runProjections >= ProjectionType.System)
{
_projectionCoreServiceCommandReader = new ProjectionCoreServiceCommandReader(
publisher,
_ioDispatcher,
workerId.ToString("N"));
var multiStreamWriter = new MultiStreamMessageWriter(_ioDispatcher);
_slaveProjectionResponseWriter = new SlaveProjectionResponseWriter(multiStreamWriter);
_projectionCoreService = new ProjectionCoreService(
workerId,
inputQueue,
publisher,
_subscriptionDispatcher,
timeProvider,
_ioDispatcher,
_spoolProcessingResponseDispatcher,
timeoutScheduler);
var responseWriter = new ResponseWriter(_ioDispatcher);
_coreResponseWriter = new ProjectionCoreResponseWriter(responseWriter);
}
}
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);
}
public MasterCoreProjectionResponseReader(
IPublisher publisher,
IODispatcher ioDispatcher,
Guid workerId,
Guid masterProjectionId)
{
if (publisher == null) throw new ArgumentNullException("publisher");
if (ioDispatcher == null) throw new ArgumentNullException("ioDispatcher");
_publisher = publisher;
_ioDispatcher = ioDispatcher;
_workerId = workerId;
_masterProjectionId = masterProjectionId;
_streamId = "$projections-$" + masterProjectionId.ToString("N");
}
public TFChunkScavenger(TFChunkDb db, IODispatcher ioDispatcher, ITableIndex tableIndex, IReadIndex readIndex,
Guid scavengeId, string nodeEndpoint, long? maxChunkDataSize = null, bool unsafeIgnoreHardDeletes=false)
{
Ensure.NotNull(db, "db");
Ensure.NotNull(ioDispatcher, "ioDispatcher");
Ensure.NotNull(tableIndex, "tableIndex");
Ensure.NotNull(nodeEndpoint, "nodeEndpoint");
Ensure.NotNull(readIndex, "readIndex");
_db = db;
_ioDispatcher = ioDispatcher;
_tableIndex = tableIndex;
_scavengeId = scavengeId;
_nodeEndpoint = nodeEndpoint;
_readIndex = readIndex;
_maxChunkDataSize = maxChunkDataSize ?? db.Config.ChunkSize;
_unsafeIgnoreHardDeletes = unsafeIgnoreHardDeletes;
}
public ByStreamCatalogEventReader(
IPublisher publisher, Guid eventReaderCorrelationId, IPrincipal readAs, IODispatcher ioDispatcher,
string catalogCatalogStreamName, int catalogNextSequenceNumber, string dataStreamName,
int dataNextSequenceNumber, long? limitingCommitPosition, ITimeProvider timeProvider, bool resolveLinkTos,
int? stopAfterNEvents = null)
: base(ioDispatcher, publisher, eventReaderCorrelationId, readAs, true, stopAfterNEvents)
{
_ioDispatcher = ioDispatcher;
_catalogStreamName = catalogCatalogStreamName;
_catalogCurrentSequenceNumber = catalogNextSequenceNumber - 1;
_catalogNextSequenceNumber = catalogNextSequenceNumber;
_dataStreamName = dataStreamName;
_dataNextSequenceNumber = dataNextSequenceNumber;
_limitingCommitPosition = limitingCommitPosition;
_timeProvider = timeProvider;
_resolveLinkTos = resolveLinkTos;
}
public CoreProjection Create(
Guid projectionCorrelationId,
IPublisher inputQueue,
Guid workerId,
IPrincipal runAs,
IPublisher publisher,
IODispatcher ioDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher,
ITimeProvider timeProvider)
{
if (inputQueue == null) throw new ArgumentNullException("inputQueue");
//if (runAs == null) throw new ArgumentNullException("runAs");
if (publisher == null) throw new ArgumentNullException("publisher");
if (ioDispatcher == null) throw new ArgumentNullException("ioDispatcher");
if (timeProvider == null) throw new ArgumentNullException("timeProvider");
var namingBuilder = new ProjectionNamesBuilder(_name, GetSourceDefinition());
var coreProjectionCheckpointWriter =
new CoreProjectionCheckpointWriter(
namingBuilder.MakeCheckpointStreamName(),
ioDispatcher,
_projectionVersion,
namingBuilder.EffectiveProjectionName);
var partitionStateCache = new PartitionStateCache();
return new CoreProjection(
this,
_projectionVersion,
projectionCorrelationId,
inputQueue,
workerId,
runAs,
publisher,
ioDispatcher,
subscriptionDispatcher,
_logger,
namingBuilder,
coreProjectionCheckpointWriter,
partitionStateCache,
namingBuilder.EffectiveProjectionName,
timeProvider);
}
protected override IProjectionProcessingPhase[] CreateProjectionProcessingPhases(
IPublisher publisher,
IPublisher inputQueue,
Guid projectionCorrelationId,
ProjectionNamesBuilder namingBuilder,
PartitionStateCache partitionStateCache,
CoreProjection coreProjection,
IODispatcher ioDispatcher,
IProjectionProcessingPhase firstPhase)
{
var coreProjectionCheckpointWriter =
new CoreProjectionCheckpointWriter(
namingBuilder.MakeCheckpointStreamName(),
ioDispatcher,
_projectionVersion,
_name);
var checkpointManager2 = new DefaultCheckpointManager(
publisher,
projectionCorrelationId,
_projectionVersion,
_projectionConfig.RunAs,
ioDispatcher,
_projectionConfig,
_name,
new PhasePositionTagger(1),
namingBuilder,
GetUseCheckpoints(),
false,
_sourceDefinition.DefinesFold,
coreProjectionCheckpointWriter);
var writeResultsPhase = new WriteQueryEofProjectionProcessingPhase(
publisher,
1,
namingBuilder.GetResultStreamName(),
coreProjection,
partitionStateCache,
checkpointManager2,
checkpointManager2,
firstPhase.EmittedStreamsTracker);
return new[] {firstPhase, writeResultsPhase};
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
var dbConfig = new TFChunkDbConfig(PathName,
new VersionedPatternFileNamingStrategy(PathName, "chunk-"),
1024*1024,
0,
new InMemoryCheckpoint(0),
new InMemoryCheckpoint(0),
new InMemoryCheckpoint(-1),
new InMemoryCheckpoint(-1));
var dbCreationHelper = new TFChunkDbCreationHelper(dbConfig);
_dbResult = CreateDb(dbCreationHelper);
_keptRecords = KeptRecords(_dbResult);
_dbResult.Db.Config.WriterCheckpoint.Flush();
_dbResult.Db.Config.ChaserCheckpoint.Write(_dbResult.Db.Config.WriterCheckpoint.Read());
_dbResult.Db.Config.ChaserCheckpoint.Flush();
var indexPath = Path.Combine(PathName, "index");
var readerPool = new ObjectPool<ITransactionFileReader>(
"ReadIndex readers pool", ESConsts.PTableInitialReaderCount, ESConsts.PTableMaxReaderCount,
() => new TFChunkReader(_dbResult.Db, _dbResult.Db.Config.WriterCheckpoint));
var lowHasher = new XXHashUnsafe();
var highHasher = new Murmur3AUnsafe();
var tableIndex = new TableIndex(indexPath, lowHasher, highHasher,
() => new HashListMemTable(PTableVersions.Index64Bit, maxSize: 200),
() => new TFReaderLease(readerPool),
PTableVersions.Index64Bit,
maxSizeForMemory: 100,
maxTablesPerLevel: 2);
ReadIndex = new ReadIndex(new NoopPublisher(), readerPool, tableIndex, 100, true, _metastreamMaxCount, Opts.HashCollisionReadLimitDefault);
ReadIndex.Init(_dbResult.Db.Config.WriterCheckpoint.Read());
//var scavengeReadIndex = new ScavengeReadIndex(_dbResult.Streams, _metastreamMaxCount);
var bus = new InMemoryBus("Bus");
var ioDispatcher = new IODispatcher(bus, new PublishEnvelope(bus));
var scavenger = new TFChunkScavenger(_dbResult.Db, ioDispatcher, tableIndex, ReadIndex, Guid.NewGuid(), "fakeNodeIp",
unsafeIgnoreHardDeletes: UnsafeIgnoreHardDelete());
scavenger.Scavenge(alwaysKeepScavenged: true, mergeChunks: false);
}
public InternalAuthenticationProvider(IODispatcher ioDispatcher, PasswordHashAlgorithm passwordHashAlgorithm, int cacheSize)
{
_ioDispatcher = ioDispatcher;
_passwordHashAlgorithm = passwordHashAlgorithm;
_userPasswordsCache = new LRUCache <string, Tuple <string, IPrincipal> >(cacheSize);
}
public EmittedStreamsTracker(IODispatcher ioDispatcher, ProjectionConfig projectionConfig, ProjectionNamesBuilder projectionNamesBuilder)
{
_ioDispatcher = ioDispatcher;
_projectionConfig = projectionConfig;
_projectionNamesBuilder = projectionNamesBuilder;
}
public AllUsersReader(IODispatcher ioDispatcher)
{
_ioDispatcher = ioDispatcher;
}
public PersistentSubscriptionCheckpointWriter(string subscriptionId, IODispatcher ioDispatcher)
{
_subscriptionStateStream = "$persistentsubscription-" + subscriptionId + "-checkpoint";
_ioDispatcher = ioDispatcher;
}
public abstract IProjectionProcessingPhase[] CreateProcessingPhases(
IPublisher publisher, Guid projectionCorrelationId, PartitionStateCache partitionStateCache,
Action updateStatistics, CoreProjection coreProjection, ProjectionNamesBuilder namingBuilder,
ITimeProvider timeProvider, IODispatcher ioDispatcher,
CoreProjectionCheckpointWriter coreProjectionCheckpointWriter);
public void setup()
{
_readyHandler = new TestCheckpointManagerMessageHandler();
_fakePublisher = new FakePublisher();
_ioDispatcher = new IODispatcher(_fakePublisher, new PublishEnvelope(_fakePublisher), true);
}
public PersistentSubscriptionMessageParker(string subscriptionId, IODispatcher ioDispatcher)
{
_parkedStreamId = "$persistentsubscription-" + subscriptionId + "-parked";
_ioDispatcher = ioDispatcher;
}
public ResponseWriter(IODispatcher ioDispatcher)
{
_ioDispatcher = ioDispatcher;
_cancellationScope = new IODispatcherAsync.CancellationScope();
}
public ManagedProjection(
Guid workerId,
Guid id,
int projectionId,
string name,
bool enabledToRun,
ILogger logger,
RequestResponseDispatcher <ClientMessage.DeleteStream, ClientMessage.DeleteStreamCompleted> streamDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
IPublisher output,
ITimeProvider timeProvider,
RequestResponseDispatcher <CoreProjectionManagementMessage.GetState, CoreProjectionStatusMessage.StateReport>
getStateDispatcher,
RequestResponseDispatcher
<CoreProjectionManagementMessage.GetResult, CoreProjectionStatusMessage.ResultReport>
getResultDispatcher,
IODispatcher ioDispatcher,
bool isSlave = false,
Guid slaveMasterWorkerId = default(Guid),
Guid slaveMasterCorrelationId = default(Guid))
{
if (id == Guid.Empty)
{
throw new ArgumentException("id");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
if (output == null)
{
throw new ArgumentNullException("output");
}
if (getStateDispatcher == null)
{
throw new ArgumentNullException("getStateDispatcher");
}
if (getResultDispatcher == null)
{
throw new ArgumentNullException("getResultDispatcher");
}
if (name == "")
{
throw new ArgumentException("name");
}
_workerId = workerId;
_id = id;
_projectionId = projectionId;
_name = name;
_enabledToRun = enabledToRun;
_logger = logger ?? LogManager.GetLoggerFor <ManagedProjection>();
_streamDispatcher = streamDispatcher;
_writeDispatcher = writeDispatcher;
_readDispatcher = readDispatcher;
_output = output;
_timeProvider = timeProvider;
_isSlave = isSlave;
_slaveMasterWorkerId = slaveMasterWorkerId;
_slaveMasterCorrelationId = slaveMasterCorrelationId;
_getStateDispatcher = getStateDispatcher;
_getResultDispatcher = getResultDispatcher;
_lastAccessed = _timeProvider.Now;
_ioDispatcher = ioDispatcher;
}
public ClusterVNode(TFChunkDb db,
ClusterVNodeSettings vNodeSettings,
IGossipSeedSource gossipSeedSource,
InfoController infoController,
params ISubsystem[] subsystems)
{
Ensure.NotNull(db, "db");
Ensure.NotNull(vNodeSettings, "vNodeSettings");
Ensure.NotNull(gossipSeedSource, "gossipSeedSource");
var isSingleNode = vNodeSettings.ClusterNodeCount == 1;
_nodeInfo = vNodeSettings.NodeInfo;
_mainBus = new InMemoryBus("MainBus");
var forwardingProxy = new MessageForwardingProxy();
//start watching jitter
HistogramService.StartJitterMonitor();
if (vNodeSettings.EnableHistograms)
{
HistogramService.CreateHistograms();
}
// MISC WORKERS
_workerBuses = Enumerable.Range(0, vNodeSettings.WorkerThreads).Select(queueNum =>
new InMemoryBus(string.Format("Worker #{0} Bus", queueNum + 1),
watchSlowMsg: true,
slowMsgThreshold: TimeSpan.FromMilliseconds(200))).ToArray();
_workersHandler = new MultiQueuedHandler(
vNodeSettings.WorkerThreads,
queueNum => new QueuedHandlerThreadPool(_workerBuses[queueNum],
string.Format("Worker #{0}", queueNum + 1),
groupName: "Workers",
watchSlowMsg: true,
slowMsgThreshold: TimeSpan.FromMilliseconds(200)));
_controller = new ClusterVNodeController((IPublisher)_mainBus, _nodeInfo, db, vNodeSettings, this, forwardingProxy);
_mainQueue = new QueuedHandler(_controller, "MainQueue");
_controller.SetMainQueue(_mainQueue);
_subsystems = subsystems;
//SELF
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(this);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(this);
_mainBus.Subscribe <UserManagementMessage.UserManagementServiceInitialized>(this);
// MONITORING
var monitoringInnerBus = new InMemoryBus("MonitoringInnerBus", watchSlowMsg: false);
var monitoringRequestBus = new InMemoryBus("MonitoringRequestBus", watchSlowMsg: false);
var monitoringQueue = new QueuedHandlerThreadPool(monitoringInnerBus, "MonitoringQueue", true, TimeSpan.FromMilliseconds(100));
var monitoring = new MonitoringService(monitoringQueue,
monitoringRequestBus,
_mainQueue,
db.Config.WriterCheckpoint,
db.Config.Path,
vNodeSettings.StatsPeriod,
_nodeInfo.ExternalHttp,
vNodeSettings.StatsStorage,
_nodeInfo.ExternalTcp);
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.SystemInit, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.StateChangeMessage, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShutdown, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <ClientMessage.WriteEventsCompleted, Message>());
monitoringInnerBus.Subscribe <SystemMessage.SystemInit>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.StateChangeMessage>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.BecomeShuttingDown>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.BecomeShutdown>(monitoring);
monitoringInnerBus.Subscribe <ClientMessage.WriteEventsCompleted>(monitoring);
monitoringInnerBus.Subscribe <MonitoringMessage.GetFreshStats>(monitoring);
monitoringInnerBus.Subscribe <MonitoringMessage.GetFreshTcpConnectionStats>(monitoring);
var truncPos = db.Config.TruncateCheckpoint.Read();
if (truncPos != -1)
{
Log.Info("Truncate checkpoint is present. Truncate: {0} (0x{0:X}), Writer: {1} (0x{1:X}), Chaser: {2} (0x{2:X}), Epoch: {3} (0x{3:X})",
truncPos, db.Config.WriterCheckpoint.Read(), db.Config.ChaserCheckpoint.Read(), db.Config.EpochCheckpoint.Read());
var truncator = new TFChunkDbTruncator(db.Config);
truncator.TruncateDb(truncPos);
}
// STORAGE SUBSYSTEM
db.Open(vNodeSettings.VerifyDbHash);
var indexPath = vNodeSettings.Index ?? Path.Combine(db.Config.Path, "index");
var readerPool = new ObjectPool <ITransactionFileReader>(
"ReadIndex readers pool", ESConsts.PTableInitialReaderCount, ESConsts.PTableMaxReaderCount,
() => new TFChunkReader(db, db.Config.WriterCheckpoint));
var tableIndex = new TableIndex(indexPath,
() => new HashListMemTable(maxSize: vNodeSettings.MaxMemtableEntryCount * 2),
() => new TFReaderLease(readerPool),
maxSizeForMemory: vNodeSettings.MaxMemtableEntryCount,
maxTablesPerLevel: 2,
inMem: db.Config.InMemDb,
indexCacheDepth: vNodeSettings.IndexCacheDepth);
var hash = new XXHashUnsafe();
var readIndex = new ReadIndex(_mainQueue,
readerPool,
tableIndex,
hash,
ESConsts.StreamInfoCacheCapacity,
Application.IsDefined(Application.AdditionalCommitChecks),
Application.IsDefined(Application.InfiniteMetastreams) ? int.MaxValue : 1);
var writer = new TFChunkWriter(db);
var epochManager = new EpochManager(ESConsts.CachedEpochCount,
db.Config.EpochCheckpoint,
writer,
initialReaderCount: 1,
maxReaderCount: 5,
readerFactory: () => new TFChunkReader(db, db.Config.WriterCheckpoint));
epochManager.Init();
var storageWriter = new ClusterStorageWriterService(_mainQueue, _mainBus, vNodeSettings.MinFlushDelay,
db, writer, readIndex.IndexWriter, epochManager,
() => readIndex.LastCommitPosition); // subscribes internally
monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageWriter);
var storageReader = new StorageReaderService(_mainQueue, _mainBus, readIndex, ESConsts.StorageReaderThreadCount, db.Config.WriterCheckpoint);
_mainBus.Subscribe <SystemMessage.SystemInit>(storageReader);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageReader);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(storageReader);
monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageReader);
var chaser = new TFChunkChaser(db, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint);
var storageChaser = new StorageChaser(_mainQueue, db.Config.WriterCheckpoint, chaser, readIndex.IndexCommitter, epochManager);
#if DEBUG
QueueStatsCollector.InitializeCheckpoints(
_nodeInfo.DebugIndex, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint);
#endif
_mainBus.Subscribe <SystemMessage.SystemInit>(storageChaser);
_mainBus.Subscribe <SystemMessage.SystemStart>(storageChaser);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageChaser);
// AUTHENTICATION INFRASTRUCTURE - delegate to plugins
_internalAuthenticationProvider = vNodeSettings.AuthenticationProviderFactory.BuildAuthenticationProvider(_mainQueue, _mainBus, _workersHandler, _workerBuses);
Ensure.NotNull(_internalAuthenticationProvider, "authenticationProvider");
{
// EXTERNAL TCP
var extTcpService = new TcpService(_mainQueue, _nodeInfo.ExternalTcp, _workersHandler,
TcpServiceType.External, TcpSecurityType.Normal, new ClientTcpDispatcher(),
vNodeSettings.ExtTcpHeartbeatInterval, vNodeSettings.ExtTcpHeartbeatTimeout,
_internalAuthenticationProvider, null);
_mainBus.Subscribe <SystemMessage.SystemInit>(extTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(extTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(extTcpService);
// EXTERNAL SECURE TCP
if (_nodeInfo.ExternalSecureTcp != null)
{
var extSecTcpService = new TcpService(_mainQueue, _nodeInfo.ExternalSecureTcp, _workersHandler,
TcpServiceType.External, TcpSecurityType.Secure, new ClientTcpDispatcher(),
vNodeSettings.ExtTcpHeartbeatInterval, vNodeSettings.ExtTcpHeartbeatTimeout,
_internalAuthenticationProvider, vNodeSettings.Certificate);
_mainBus.Subscribe <SystemMessage.SystemInit>(extSecTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(extSecTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(extSecTcpService);
}
if (!isSingleNode)
{
// INTERNAL TCP
var intTcpService = new TcpService(_mainQueue, _nodeInfo.InternalTcp, _workersHandler,
TcpServiceType.Internal, TcpSecurityType.Normal,
new InternalTcpDispatcher(),
vNodeSettings.IntTcpHeartbeatInterval, vNodeSettings.IntTcpHeartbeatTimeout,
_internalAuthenticationProvider, null);
_mainBus.Subscribe <SystemMessage.SystemInit>(intTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(intTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(intTcpService);
// INTERNAL SECURE TCP
if (_nodeInfo.InternalSecureTcp != null)
{
var intSecTcpService = new TcpService(_mainQueue, _nodeInfo.InternalSecureTcp, _workersHandler,
TcpServiceType.Internal, TcpSecurityType.Secure,
new InternalTcpDispatcher(),
vNodeSettings.IntTcpHeartbeatInterval, vNodeSettings.IntTcpHeartbeatTimeout,
_internalAuthenticationProvider, vNodeSettings.Certificate);
_mainBus.Subscribe <SystemMessage.SystemInit>(intSecTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(intSecTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(intSecTcpService);
}
}
}
SubscribeWorkers(bus =>
{
var tcpSendService = new TcpSendService();
// ReSharper disable RedundantTypeArgumentsOfMethod
bus.Subscribe <TcpMessage.TcpSend>(tcpSendService);
// ReSharper restore RedundantTypeArgumentsOfMethod
});
var httpAuthenticationProviders = new List <HttpAuthenticationProvider>
{
new BasicHttpAuthenticationProvider(_internalAuthenticationProvider),
};
if (vNodeSettings.EnableTrustedAuth)
{
httpAuthenticationProviders.Add(new TrustedHttpAuthenticationProvider());
}
httpAuthenticationProviders.Add(new AnonymousHttpAuthenticationProvider());
var httpPipe = new HttpMessagePipe();
var httpSendService = new HttpSendService(httpPipe, forwardRequests: true);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(httpSendService);
_mainBus.Subscribe(new WideningHandler <HttpMessage.SendOverHttp, Message>(_workersHandler));
SubscribeWorkers(bus =>
{
bus.Subscribe <HttpMessage.HttpSend>(httpSendService);
bus.Subscribe <HttpMessage.HttpSendPart>(httpSendService);
bus.Subscribe <HttpMessage.HttpBeginSend>(httpSendService);
bus.Subscribe <HttpMessage.HttpEndSend>(httpSendService);
bus.Subscribe <HttpMessage.SendOverHttp>(httpSendService);
});
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(infoController);
var adminController = new AdminController(_mainQueue);
var pingController = new PingController();
var histogramController = new HistogramController();
var statController = new StatController(monitoringQueue, _workersHandler);
var atomController = new AtomController(httpSendService, _mainQueue, _workersHandler, vNodeSettings.DisableHTTPCaching);
var gossipController = new GossipController(_mainQueue, _workersHandler, vNodeSettings.GossipTimeout);
var persistentSubscriptionController = new PersistentSubscriptionController(httpSendService, _mainQueue, _workersHandler);
var electController = new ElectController(_mainQueue);
// HTTP SENDERS
gossipController.SubscribeSenders(httpPipe);
electController.SubscribeSenders(httpPipe);
// EXTERNAL HTTP
_externalHttpService = new HttpService(ServiceAccessibility.Public, _mainQueue, new TrieUriRouter(),
_workersHandler, vNodeSettings.LogHttpRequests, vNodeSettings.ExtHttpPrefixes);
_externalHttpService.SetupController(persistentSubscriptionController);
if (vNodeSettings.AdminOnPublic)
{
_externalHttpService.SetupController(adminController);
}
_externalHttpService.SetupController(pingController);
_externalHttpService.SetupController(infoController);
if (vNodeSettings.StatsOnPublic)
{
_externalHttpService.SetupController(statController);
}
_externalHttpService.SetupController(atomController);
if (vNodeSettings.GossipOnPublic)
{
_externalHttpService.SetupController(gossipController);
}
_externalHttpService.SetupController(histogramController);
_mainBus.Subscribe <SystemMessage.SystemInit>(_externalHttpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(_externalHttpService);
_mainBus.Subscribe <HttpMessage.PurgeTimedOutRequests>(_externalHttpService);
// INTERNAL HTTP
if (!isSingleNode)
{
_internalHttpService = new HttpService(ServiceAccessibility.Private, _mainQueue, new TrieUriRouter(),
_workersHandler, vNodeSettings.LogHttpRequests, vNodeSettings.IntHttpPrefixes);
_internalHttpService.SetupController(adminController);
_internalHttpService.SetupController(pingController);
_internalHttpService.SetupController(infoController);
_internalHttpService.SetupController(statController);
_internalHttpService.SetupController(atomController);
_internalHttpService.SetupController(gossipController);
_internalHttpService.SetupController(electController);
_internalHttpService.SetupController(histogramController);
_internalHttpService.SetupController(persistentSubscriptionController);
}
// Authentication plugin HTTP
vNodeSettings.AuthenticationProviderFactory.RegisterHttpControllers(_externalHttpService, _internalHttpService, httpSendService, _mainQueue, _workersHandler);
if (_internalHttpService != null)
{
_mainBus.Subscribe <SystemMessage.SystemInit>(_internalHttpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(_internalHttpService);
_mainBus.Subscribe <HttpMessage.PurgeTimedOutRequests>(_internalHttpService);
}
SubscribeWorkers(bus =>
{
HttpService.CreateAndSubscribePipeline(bus, httpAuthenticationProviders.ToArray());
});
// REQUEST FORWARDING
var forwardingService = new RequestForwardingService(_mainQueue, forwardingProxy, TimeSpan.FromSeconds(1));
_mainBus.Subscribe <SystemMessage.SystemStart>(forwardingService);
_mainBus.Subscribe <SystemMessage.RequestForwardingTimerTick>(forwardingService);
_mainBus.Subscribe <ClientMessage.NotHandled>(forwardingService);
_mainBus.Subscribe <ClientMessage.WriteEventsCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionStartCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionWriteCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionCommitCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.DeleteStreamCompleted>(forwardingService);
// REQUEST MANAGEMENT
var requestManagement = new RequestManagementService(_mainQueue,
vNodeSettings.PrepareAckCount,
vNodeSettings.CommitAckCount,
vNodeSettings.PrepareTimeout,
vNodeSettings.CommitTimeout);
_mainBus.Subscribe <SystemMessage.SystemInit>(requestManagement);
_mainBus.Subscribe <ClientMessage.WriteEvents>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionStart>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionWrite>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionCommit>(requestManagement);
_mainBus.Subscribe <ClientMessage.DeleteStream>(requestManagement);
_mainBus.Subscribe <StorageMessage.RequestCompleted>(requestManagement);
_mainBus.Subscribe <StorageMessage.CheckStreamAccessCompleted>(requestManagement);
_mainBus.Subscribe <StorageMessage.AlreadyCommitted>(requestManagement);
_mainBus.Subscribe <StorageMessage.CommitAck>(requestManagement);
_mainBus.Subscribe <StorageMessage.PrepareAck>(requestManagement);
_mainBus.Subscribe <StorageMessage.WrongExpectedVersion>(requestManagement);
_mainBus.Subscribe <StorageMessage.InvalidTransaction>(requestManagement);
_mainBus.Subscribe <StorageMessage.StreamDeleted>(requestManagement);
_mainBus.Subscribe <StorageMessage.RequestManagerTimerTick>(requestManagement);
// SUBSCRIPTIONS
var subscrBus = new InMemoryBus("SubscriptionsBus", true, TimeSpan.FromMilliseconds(50));
var subscrQueue = new QueuedHandlerThreadPool(subscrBus, "Subscriptions", false);
_mainBus.Subscribe(subscrQueue.WidenFrom <SystemMessage.SystemStart, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <TcpMessage.ConnectionClosed, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <ClientMessage.SubscribeToStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <ClientMessage.UnsubscribeFromStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SubscriptionMessage.PollStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SubscriptionMessage.CheckPollTimeout, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <StorageMessage.EventCommitted, Message>());
var subscription = new SubscriptionsService(_mainQueue, subscrQueue, readIndex);
subscrBus.Subscribe <SystemMessage.SystemStart>(subscription);
subscrBus.Subscribe <SystemMessage.BecomeShuttingDown>(subscription);
subscrBus.Subscribe <TcpMessage.ConnectionClosed>(subscription);
subscrBus.Subscribe <ClientMessage.SubscribeToStream>(subscription);
subscrBus.Subscribe <ClientMessage.UnsubscribeFromStream>(subscription);
subscrBus.Subscribe <SubscriptionMessage.PollStream>(subscription);
subscrBus.Subscribe <SubscriptionMessage.CheckPollTimeout>(subscription);
subscrBus.Subscribe <StorageMessage.EventCommitted>(subscription);
// PERSISTENT SUBSCRIPTIONS
// IO DISPATCHER
var ioDispatcher = new IODispatcher(_mainQueue, new PublishEnvelope(_mainQueue));
_mainBus.Subscribe <ClientMessage.ReadStreamEventsBackwardCompleted>(ioDispatcher.BackwardReader);
_mainBus.Subscribe <ClientMessage.WriteEventsCompleted>(ioDispatcher.Writer);
_mainBus.Subscribe <ClientMessage.ReadStreamEventsForwardCompleted>(ioDispatcher.ForwardReader);
_mainBus.Subscribe <ClientMessage.DeleteStreamCompleted>(ioDispatcher.StreamDeleter);
_mainBus.Subscribe(ioDispatcher);
var perSubscrBus = new InMemoryBus("PersistentSubscriptionsBus", true, TimeSpan.FromMilliseconds(50));
var perSubscrQueue = new QueuedHandlerThreadPool(perSubscrBus, "PersistentSubscriptions", false);
_mainBus.Subscribe(perSubscrQueue.WidenFrom <SystemMessage.StateChangeMessage, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <TcpMessage.ConnectionClosed, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.CreatePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.UpdatePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.DeletePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ConnectToPersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.UnsubscribeFromStream, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.PersistentSubscriptionAckEvents, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.PersistentSubscriptionNackEvents, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReplayAllParkedMessages, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReplayParkedMessage, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReadNextNPersistentMessages, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <StorageMessage.EventCommitted, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetAllPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetStreamPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <SubscriptionMessage.PersistentSubscriptionTimerTick, Message>());
//TODO CC can have multiple threads working on subscription if partition
var consumerStrategyRegistry = new PersistentSubscriptionConsumerStrategyRegistry(_mainQueue, _mainBus, vNodeSettings.AdditionalConsumerStrategies);
var persistentSubscription = new PersistentSubscriptionService(subscrQueue, readIndex, ioDispatcher, _mainQueue, consumerStrategyRegistry);
perSubscrBus.Subscribe <SystemMessage.BecomeShuttingDown>(persistentSubscription);
perSubscrBus.Subscribe <SystemMessage.BecomeMaster>(persistentSubscription);
perSubscrBus.Subscribe <SystemMessage.StateChangeMessage>(persistentSubscription);
perSubscrBus.Subscribe <TcpMessage.ConnectionClosed>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ConnectToPersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.UnsubscribeFromStream>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.PersistentSubscriptionAckEvents>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.PersistentSubscriptionNackEvents>(persistentSubscription);
perSubscrBus.Subscribe <StorageMessage.EventCommitted>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.DeletePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.CreatePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.UpdatePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReplayAllParkedMessages>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReplayParkedMessage>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReadNextNPersistentMessages>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetAllPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetStreamPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <SubscriptionMessage.PersistentSubscriptionTimerTick>(persistentSubscription);
// STORAGE SCAVENGER
var storageScavenger = new StorageScavenger(db, ioDispatcher, tableIndex, hash, readIndex,
Application.IsDefined(Application.AlwaysKeepScavenged),
_nodeInfo.ExternalHttp.ToString(), !vNodeSettings.DisableScavengeMerging, vNodeSettings.ScavengeHistoryMaxAge);
// ReSharper disable RedundantTypeArgumentsOfMethod
_mainBus.Subscribe <ClientMessage.ScavengeDatabase>(storageScavenger);
_mainBus.Subscribe <UserManagementMessage.UserManagementServiceInitialized>(storageScavenger);
// ReSharper restore RedundantTypeArgumentsOfMethod
// TIMER
_timeProvider = new RealTimeProvider();
_timerService = new TimerService(new ThreadBasedScheduler(_timeProvider));
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(_timerService);
_mainBus.Subscribe <TimerMessage.Schedule>(_timerService);
var gossipInfo = new VNodeInfo(_nodeInfo.InstanceId, _nodeInfo.DebugIndex,
vNodeSettings.GossipAdvertiseInfo.InternalTcp,
vNodeSettings.GossipAdvertiseInfo.InternalSecureTcp,
vNodeSettings.GossipAdvertiseInfo.ExternalTcp,
vNodeSettings.GossipAdvertiseInfo.ExternalSecureTcp,
vNodeSettings.GossipAdvertiseInfo.InternalHttp,
vNodeSettings.GossipAdvertiseInfo.ExternalHttp);
if (!isSingleNode)
{
// MASTER REPLICATION
var masterReplicationService = new MasterReplicationService(_mainQueue, gossipInfo.InstanceId, db, _workersHandler,
epochManager, vNodeSettings.ClusterNodeCount);
_mainBus.Subscribe <SystemMessage.SystemStart>(masterReplicationService);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(masterReplicationService);
_mainBus.Subscribe <ReplicationMessage.ReplicaSubscriptionRequest>(masterReplicationService);
_mainBus.Subscribe <ReplicationMessage.ReplicaLogPositionAck>(masterReplicationService);
monitoringInnerBus.Subscribe <ReplicationMessage.GetReplicationStats>(masterReplicationService);
// REPLICA REPLICATION
var replicaService = new ReplicaService(_mainQueue, db, epochManager, _workersHandler, _internalAuthenticationProvider,
gossipInfo, vNodeSettings.UseSsl, vNodeSettings.SslTargetHost, vNodeSettings.SslValidateServer,
vNodeSettings.IntTcpHeartbeatTimeout, vNodeSettings.ExtTcpHeartbeatInterval);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(replicaService);
_mainBus.Subscribe <ReplicationMessage.ReconnectToMaster>(replicaService);
_mainBus.Subscribe <ReplicationMessage.SubscribeToMaster>(replicaService);
_mainBus.Subscribe <ReplicationMessage.AckLogPosition>(replicaService);
_mainBus.Subscribe <StorageMessage.PrepareAck>(replicaService);
_mainBus.Subscribe <StorageMessage.CommitAck>(replicaService);
_mainBus.Subscribe <ClientMessage.TcpForwardMessage>(replicaService);
}
// ELECTIONS
var electionsService = new ElectionsService(_mainQueue, gossipInfo, vNodeSettings.ClusterNodeCount,
db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint,
epochManager, () => readIndex.LastCommitPosition, vNodeSettings.NodePriority);
electionsService.SubscribeMessages(_mainBus);
if (!isSingleNode)
{
// GOSSIP
var gossip = new NodeGossipService(_mainQueue, gossipSeedSource, gossipInfo, db.Config.WriterCheckpoint,
db.Config.ChaserCheckpoint, epochManager, () => readIndex.LastCommitPosition,
vNodeSettings.NodePriority, vNodeSettings.GossipInterval, vNodeSettings.GossipAllowedTimeDifference);
_mainBus.Subscribe <SystemMessage.SystemInit>(gossip);
_mainBus.Subscribe <GossipMessage.RetrieveGossipSeedSources>(gossip);
_mainBus.Subscribe <GossipMessage.GotGossipSeedSources>(gossip);
_mainBus.Subscribe <GossipMessage.Gossip>(gossip);
_mainBus.Subscribe <GossipMessage.GossipReceived>(gossip);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(gossip);
_mainBus.Subscribe <GossipMessage.GossipSendFailed>(gossip);
_mainBus.Subscribe <SystemMessage.VNodeConnectionEstablished>(gossip);
_mainBus.Subscribe <SystemMessage.VNodeConnectionLost>(gossip);
}
_workersHandler.Start();
_mainQueue.Start();
monitoringQueue.Start();
subscrQueue.Start();
if (subsystems != null)
{
foreach (var subsystem in subsystems)
{
var http = isSingleNode ? new [] { _externalHttpService } : new [] { _internalHttpService, _externalHttpService };
subsystem.Register(new StandardComponents(db, _mainQueue, _mainBus, _timerService, _timeProvider, httpSendService, http, _workersHandler));
}
}
}
//NOTE: this is only for slave projections (TBD)
public CoreProjection(
ProjectionProcessingStrategy projectionProcessingStrategy, ProjectionVersion version,
Guid projectionCorrelationId, IPublisher inputQueue, IPrincipal runAs, IPublisher publisher, IODispatcher ioDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher, ILogger logger, ProjectionNamesBuilder namingBuilder, CoreProjectionCheckpointWriter coreProjectionCheckpointWriter,
PartitionStateCache partitionStateCache, string effectiveProjectionName, ITimeProvider timeProvider, bool isSlaveProjection)
{
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (ioDispatcher == null)
{
throw new ArgumentNullException("ioDispatcher");
}
if (subscriptionDispatcher == null)
{
throw new ArgumentNullException("subscriptionDispatcher");
}
_projectionProcessingStrategy = projectionProcessingStrategy;
_projectionCorrelationId = projectionCorrelationId;
_inputQueue = inputQueue;
_runAs = runAs;
_name = effectiveProjectionName;
_version = version;
_stopOnEof = projectionProcessingStrategy.GetStopOnEof();
_logger = logger;
_publisher = publisher;
_partitionStateCache = partitionStateCache;
_partitionedStateState = projectionProcessingStrategy.GetIsPartitioned();
_isSlaveProjection = isSlaveProjection;
var useCheckpoints = projectionProcessingStrategy.GetUseCheckpoints();
_coreProjectionCheckpointWriter = coreProjectionCheckpointWriter;
_projectionProcessingPhases = projectionProcessingStrategy.CreateProcessingPhases(
publisher, projectionCorrelationId, partitionStateCache, UpdateStatistics, this, namingBuilder,
timeProvider, ioDispatcher, coreProjectionCheckpointWriter);
//NOTE: currently assuming the first checkpoint manager to be able to load any state
_checkpointReader = new CoreProjectionCheckpointReader(
publisher, _projectionCorrelationId, ioDispatcher, namingBuilder.MakeCheckpointStreamName(), _version,
useCheckpoints);
_enrichStatistics = projectionProcessingStrategy.EnrichStatistics;
GoToState(State.Initial);
}
public IEventReader CreatePausedEventReader(
Guid eventReaderId, IPublisher publisher, IODispatcher ioDispatcher, CheckpointTag checkpointTag,
bool stopOnEof, int?stopAfterNEvents)
{
throw new NotImplementedException();
}
public EmittedStreamsDeleter(IODispatcher ioDispatcher, string emittedStreamsId, string emittedStreamsCheckpointStreamId)
{
_ioDispatcher = ioDispatcher;
_emittedStreamsId = emittedStreamsId;
_emittedStreamsCheckpointStreamId = emittedStreamsCheckpointStreamId;
}
public void Setup()
{
//TODO: this became an integration test - proper ProjectionCoreService and ProjectionManager testing is required as well
_bus.Subscribe(_consumer);
var queues = GivenCoreQueues();
_managerMessageDispatcher = new ProjectionManagerMessageDispatcher(queues);
_manager = new ProjectionManager(
GetInputQueue(),
GetInputQueue(),
queues,
_timeProvider,
ProjectionType.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 <CoreProjectionStatusMessage.Started>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.Stopped>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.Prepared>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.Faulted>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.StateReport>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.ResultReport>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.StatisticsReport>(_manager);
_bus.Subscribe <CoreProjectionManagementMessage.SlaveProjectionReaderAssigned>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.ProjectionWorkerStarted>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Post>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.UpdateQuery>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.GetQuery>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Delete>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.GetStatistics>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.GetState>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.GetResult>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Disable>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Enable>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Abort>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.SetRunAs>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Reset>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.StartSlaveProjections>(_manager);
_bus.Subscribe <ClientMessage.WriteEventsCompleted>(_manager);
_bus.Subscribe <ClientMessage.ReadStreamEventsBackwardCompleted>(_manager);
_bus.Subscribe <ClientMessage.WriteEventsCompleted>(_manager);
_bus.Subscribe <SystemMessage.StateChangeMessage>(_manager);
_bus.Subscribe <ProjectionManagementMessage.ReaderReady>(_manager);
_bus.Subscribe(
CallbackSubscriber.Create <ProjectionManagementMessage.Starting>(
starting => _queue.Publish(new ProjectionManagementMessage.ReaderReady())));
_bus.Subscribe <PartitionProcessingResultBase>(_managerMessageDispatcher);
_bus.Subscribe <CoreProjectionManagementControlMessage>(_managerMessageDispatcher);
_bus.Subscribe <PartitionProcessingResultOutputBase>(_managerMessageDispatcher);
_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);
AwakeService = new AwakeService();
_bus.Subscribe <StorageMessage.EventCommitted>(AwakeService);
_bus.Subscribe <StorageMessage.TfEofAtNonCommitRecord>(AwakeService);
_bus.Subscribe <AwakeServiceMessage.SubscribeAwake>(AwakeService);
_bus.Subscribe <AwakeServiceMessage.UnsubscribeAwake>(AwakeService);
Given();
WhenLoop();
}
public PasswordChangeNotificationReader(IPublisher publisher, IODispatcher ioDispatcher)
{
_publisher = publisher;
_ioDispatcher = ioDispatcher;
_log = LogManager.GetLoggerFor <UserManagementService>();
}
public PersistentSubscriptionCheckpointReader(IODispatcher ioDispatcher)
{
_ioDispatcher = ioDispatcher;
}
internal PersistentSubscriptionService(IQueuedHandler queuedHandler, IReadIndex readIndex, IODispatcher ioDispatcher, IPublisher bus, PersistentSubscriptionConsumerStrategyRegistry consumerStrategyRegistry)
{
Ensure.NotNull(queuedHandler, "queuedHandler");
Ensure.NotNull(readIndex, "readIndex");
Ensure.NotNull(ioDispatcher, "ioDispatcher");
_queuedHandler = queuedHandler;
_readIndex = readIndex;
_ioDispatcher = ioDispatcher;
_bus = bus;
_consumerStrategyRegistry = consumerStrategyRegistry;
_checkpointReader = new PersistentSubscriptionCheckpointReader(_ioDispatcher);
_streamReader = new PersistentSubscriptionStreamReader(_ioDispatcher, 100);
//TODO CC configurable
_tickRequestMessage = TimerMessage.Schedule.Create(TimeSpan.FromMilliseconds(1000),
new PublishEnvelope(_bus),
new SubscriptionMessage.PersistentSubscriptionTimerTick());
}
public void Setup()
{
//TODO: this became an integration test - proper ProjectionCoreService and ProjectionManager testing is required as well
_bus.Subscribe(_consumer);
var queues = GivenCoreQueues();
_managerMessageDispatcher = new ProjectionManagerMessageDispatcher(queues);
_manager = new ProjectionManager(
GetInputQueue(),
GetInputQueue(),
queues,
_timeProvider,
ProjectionType.All,
_ioDispatcher,
TimeSpan.FromMinutes(Opts.ProjectionsQueryExpiryDefault),
_initializeSystemProjections);
IPublisher inputQueue = GetInputQueue();
IPublisher publisher = GetInputQueue();
var ioDispatcher = new IODispatcher(publisher, new PublishEnvelope(inputQueue), true);
_bus.Subscribe <ProjectionManagementMessage.Internal.CleanupExpired>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Internal.Deleted>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.Started>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.Stopped>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.Prepared>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.Faulted>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.StateReport>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.ResultReport>(_manager);
_bus.Subscribe <CoreProjectionStatusMessage.StatisticsReport>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Post>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.PostBatch>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.UpdateQuery>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.GetQuery>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Delete>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.GetStatistics>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.GetState>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.GetResult>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Disable>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Enable>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Abort>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.SetRunAs>(_manager);
_bus.Subscribe <ProjectionManagementMessage.Command.Reset>(_manager);
_bus.Subscribe <ClientMessage.WriteEventsCompleted>(_manager);
_bus.Subscribe <ClientMessage.ReadStreamEventsBackwardCompleted>(_manager);
_bus.Subscribe <ClientMessage.WriteEventsCompleted>(_manager);
_bus.Subscribe <ProjectionSubsystemMessage.StartComponents>(_manager);
_bus.Subscribe <ProjectionSubsystemMessage.StopComponents>(_manager);
_bus.Subscribe <CoreProjectionManagementControlMessage>(_managerMessageDispatcher);
_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);
AwakeService = new AwakeService();
_bus.Subscribe <StorageMessage.EventCommitted>(AwakeService);
_bus.Subscribe <StorageMessage.TfEofAtNonCommitRecord>(AwakeService);
_bus.Subscribe <AwakeServiceMessage.SubscribeAwake>(AwakeService);
_bus.Subscribe <AwakeServiceMessage.UnsubscribeAwake>(AwakeService);
Given();
WhenLoop();
}
private static void SubscribeMainBus(
ISubscriber mainBus,
ProjectionManager projectionManager,
ProjectionType runProjections,
ProjectionManagerResponseReader projectionManagerResponseReader,
IODispatcher ioDispatcher,
ProjectionManagerCommandWriter projectionManagerCommandWriter)
{
if (runProjections >= ProjectionType.System)
{
mainBus.Subscribe <ProjectionManagementMessage.Command.Post>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.PostBatch>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.UpdateQuery>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.GetQuery>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.Delete>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.GetStatistics>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.GetState>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.GetResult>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.Disable>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.Enable>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.Abort>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.SetRunAs>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.Reset>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.GetConfig>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Command.UpdateConfig>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Internal.CleanupExpired>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Internal.Deleted>(projectionManager);
mainBus.Subscribe <CoreProjectionStatusMessage.Started>(projectionManager);
mainBus.Subscribe <CoreProjectionStatusMessage.Stopped>(projectionManager);
mainBus.Subscribe <CoreProjectionStatusMessage.Faulted>(projectionManager);
mainBus.Subscribe <CoreProjectionStatusMessage.Prepared>(projectionManager);
mainBus.Subscribe <CoreProjectionStatusMessage.StateReport>(projectionManager);
mainBus.Subscribe <CoreProjectionStatusMessage.ResultReport>(projectionManager);
mainBus.Subscribe <CoreProjectionStatusMessage.StatisticsReport>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.ReaderReady>(projectionManager);
mainBus.Subscribe <ProjectionSubsystemMessage.StartComponents>(projectionManager);
mainBus.Subscribe <ProjectionSubsystemMessage.StopComponents>(projectionManager);
mainBus.Subscribe <ProjectionManagementMessage.Starting>(projectionManagerResponseReader);
}
mainBus.Subscribe <ClientMessage.WriteEventsCompleted>(projectionManager);
mainBus.Subscribe <ClientMessage.DeleteStreamCompleted>(projectionManager);
mainBus.Subscribe <ClientMessage.ReadStreamEventsBackwardCompleted>(projectionManager);
mainBus.Subscribe <ClientMessage.ReadStreamEventsForwardCompleted>(projectionManager);
mainBus.Subscribe(ioDispatcher.Awaker);
mainBus.Subscribe(ioDispatcher.BackwardReader);
mainBus.Subscribe(ioDispatcher.ForwardReader);
mainBus.Subscribe(ioDispatcher.StreamDeleter);
mainBus.Subscribe(ioDispatcher.Writer);
mainBus.Subscribe(ioDispatcher);
mainBus.Subscribe <ProjectionManagementMessage.Starting>(projectionManagerCommandWriter);
mainBus.Subscribe <CoreProjectionManagementMessage.CreatePrepared>(projectionManagerCommandWriter);
mainBus.Subscribe <CoreProjectionManagementMessage.CreateAndPrepare>(projectionManagerCommandWriter);
mainBus.Subscribe <CoreProjectionManagementMessage.LoadStopped>(projectionManagerCommandWriter);
mainBus.Subscribe <CoreProjectionManagementMessage.Start>(projectionManagerCommandWriter);
mainBus.Subscribe <CoreProjectionManagementMessage.Stop>(projectionManagerCommandWriter);
mainBus.Subscribe <CoreProjectionManagementMessage.Kill>(projectionManagerCommandWriter);
mainBus.Subscribe <CoreProjectionManagementMessage.Dispose>(projectionManagerCommandWriter);
mainBus.Subscribe <CoreProjectionManagementMessage.GetState>(projectionManagerCommandWriter);
mainBus.Subscribe <CoreProjectionManagementMessage.GetResult>(projectionManagerCommandWriter);
}
public EmittedStreamsWriter(IODispatcher ioDispatcher)
{
_ioDispatcher = ioDispatcher;
}
public ProjectionManager(
IPublisher inputQueue,
IPublisher publisher,
IDictionary <Guid, IPublisher> queueMap,
ITimeProvider timeProvider,
ProjectionType runProjections,
IODispatcher ioDispatcher,
bool initializeSystemProjections = true)
{
if (inputQueue == null)
{
throw new ArgumentNullException("inputQueue");
}
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (queueMap == null)
{
throw new ArgumentNullException("queueMap");
}
if (queueMap.Count == 0)
{
throw new ArgumentException("At least one queue is required", "queueMap");
}
_inputQueue = inputQueue;
_publisher = publisher;
_queues = queueMap.Select(v => Tuple.Create(v.Key, v.Value)).ToArray();
_workers = _queues.Select(v => v.Item1).ToArray();
_timeProvider = timeProvider;
_runProjections = runProjections;
_initializeSystemProjections = initializeSystemProjections;
_ioDispatcher = ioDispatcher;
_writeDispatcher =
new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
publisher,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_inputQueue));
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
publisher,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_inputQueue));
_streamDispatcher =
new RequestResponseDispatcher <ClientMessage.DeleteStream, ClientMessage.DeleteStreamCompleted>(
publisher,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_inputQueue));
_projections = new Dictionary <string, ManagedProjection>();
_projectionsMap = new Dictionary <Guid, string>();
_publishEnvelope = new PublishEnvelope(_inputQueue, crossThread: true);
_getStateDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetState, CoreProjectionStatusMessage.StateReport>(
_publisher,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_inputQueue));
_getResultDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetResult, CoreProjectionStatusMessage.ResultReport>(
_publisher,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_inputQueue));
}
public IEventReader CreatePausedEventReader(
IPublisher publisher, IODispatcher ioDispatcher, Guid forkedEventReaderId)
{
_eventReader = new FakeEventReader(forkedEventReaderId);
return(_eventReader);
}
public QueuedEmittedStreamsWriter(IODispatcher ioDispatcher, Guid writeQueueId)
{
_ioDispatcher = ioDispatcher;
_writeQueueId = writeQueueId;
}
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);
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);
}
}
public PlaygroundVNode(PlaygroundVNodeSettings vNodeSettings)
{
_tcpEndPoint = vNodeSettings.ExternalTcpEndPoint;
_httpEndPoint = vNodeSettings.ExternalHttpEndPoint;
_mainBus = new InMemoryBus("MainBus");
var controller = new PlaygroundVNodeController(Bus, _httpEndPoint);
_mainQueue = new QueuedHandler(controller, "MainQueue");
controller.SetMainQueue(MainQueue);
// MONITORING
var monitoringInnerBus = new InMemoryBus("MonitoringInnerBus", watchSlowMsg: false);
var monitoringQueue = new QueuedHandler(
monitoringInnerBus, "MonitoringQueue", true, TimeSpan.FromMilliseconds(100));
Bus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.SystemInit, Message>());
Bus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.StateChangeMessage, Message>());
Bus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>());
// MISC WORKERS
_workerBuses = Enumerable.Range(0, vNodeSettings.WorkerThreads).Select(queueNum =>
new InMemoryBus(string.Format("Worker #{0} Bus", queueNum + 1),
watchSlowMsg: true,
slowMsgThreshold: TimeSpan.FromMilliseconds(50))).ToArray();
var workersHandler = new MultiQueuedHandler(
vNodeSettings.WorkerThreads,
queueNum => new QueuedHandlerThreadPool(_workerBuses[queueNum],
string.Format("Worker #{0}", queueNum + 1),
groupName: "Workers",
watchSlowMsg: true,
slowMsgThreshold: TimeSpan.FromMilliseconds(50)));
// AUTHENTICATION INFRASTRUCTURE
var dispatcher = new IODispatcher(_mainBus, new PublishEnvelope(workersHandler, crossThread: true));
var passwordHashAlgorithm = new Rfc2898PasswordHashAlgorithm();
var internalAuthenticationProvider = new InternalAuthenticationProvider(dispatcher, passwordHashAlgorithm, 1000);
var passwordChangeNotificationReader = new PasswordChangeNotificationReader(_mainQueue, dispatcher);
_mainBus.Subscribe <SystemMessage.SystemStart>(passwordChangeNotificationReader);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(passwordChangeNotificationReader);
_mainBus.Subscribe(internalAuthenticationProvider);
_mainBus.Subscribe(dispatcher);
SubscribeWorkers(bus =>
{
bus.Subscribe(dispatcher.ForwardReader);
bus.Subscribe(dispatcher.BackwardReader);
bus.Subscribe(dispatcher.Writer);
bus.Subscribe(dispatcher.StreamDeleter);
bus.Subscribe(dispatcher.Awaker);
});
// TCP
var tcpService = new TcpService(
MainQueue, _tcpEndPoint, workersHandler, TcpServiceType.External, TcpSecurityType.Normal, new ClientTcpDispatcher(),
TimeSpan.FromSeconds(1), TimeSpan.FromMilliseconds(1000), internalAuthenticationProvider, null);
Bus.Subscribe <SystemMessage.SystemInit>(tcpService);
Bus.Subscribe <SystemMessage.SystemStart>(tcpService);
Bus.Subscribe <SystemMessage.BecomeShuttingDown>(tcpService);
// HTTP
{
var httpAuthenticationProviders = new HttpAuthenticationProvider[]
{
new BasicHttpAuthenticationProvider(internalAuthenticationProvider),
new TrustedHttpAuthenticationProvider(),
new AnonymousHttpAuthenticationProvider()
};
var httpPipe = new HttpMessagePipe();
var httpSendService = new HttpSendService(httpPipe, forwardRequests: false);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(httpSendService);
_mainBus.Subscribe(new WideningHandler <HttpMessage.SendOverHttp, Message>(workersHandler));
SubscribeWorkers(bus =>
{
bus.Subscribe <HttpMessage.HttpSend>(httpSendService);
bus.Subscribe <HttpMessage.HttpSendPart>(httpSendService);
bus.Subscribe <HttpMessage.HttpBeginSend>(httpSendService);
bus.Subscribe <HttpMessage.HttpEndSend>(httpSendService);
bus.Subscribe <HttpMessage.SendOverHttp>(httpSendService);
});
_httpService = new HttpService(ServiceAccessibility.Private, _mainQueue, new TrieUriRouter(),
workersHandler, vNodeSettings.HttpPrefixes);
_mainBus.Subscribe <SystemMessage.SystemInit>(_httpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(_httpService);
_mainBus.Subscribe <HttpMessage.PurgeTimedOutRequests>(_httpService);
HttpService.SetupController(new AdminController(_mainQueue));
HttpService.SetupController(new PingController());
HttpService.SetupController(new StatController(monitoringQueue, workersHandler));
HttpService.SetupController(new AtomController(httpSendService, _mainQueue, workersHandler));
HttpService.SetupController(new UsersController(httpSendService, _mainQueue, workersHandler));
SubscribeWorkers(bus => HttpService.CreateAndSubscribePipeline(bus, httpAuthenticationProviders));
}
// TIMER
_timerService = new TimerService(new ThreadBasedScheduler(new RealTimeProvider()));
Bus.Subscribe <TimerMessage.Schedule>(TimerService);
monitoringQueue.Start();
MainQueue.Start();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
WriterCheckpoint = new InMemoryCheckpoint(0);
ChaserCheckpoint = new InMemoryCheckpoint(0);
Bus = new InMemoryBus("bus");
IODispatcher = new IODispatcher(Bus, new PublishEnvelope(Bus));
Db = new TFChunkDb(new TFChunkDbConfig(PathName,
new VersionedPatternFileNamingStrategy(PathName, "chunk-"),
10000,
0,
WriterCheckpoint,
ChaserCheckpoint,
new InMemoryCheckpoint(-1),
new InMemoryCheckpoint(-1)));
Db.Open();
// create db
Writer = new TFChunkWriter(Db);
Writer.Open();
WriteTestScenario();
Writer.Close();
Writer = null;
WriterCheckpoint.Flush();
ChaserCheckpoint.Write(WriterCheckpoint.Read());
ChaserCheckpoint.Flush();
var readers = new ObjectPool <ITransactionFileReader>("Readers", 2, 5, () => new TFChunkReader(Db, Db.Config.WriterCheckpoint));
TableIndex = new TableIndex(GetFilePathFor("index"),
() => new HashListMemTable(MaxEntriesInMemTable * 2),
() => new TFReaderLease(readers),
MaxEntriesInMemTable);
var hasher = new ByLengthHasher();
ReadIndex = new ReadIndex(new NoopPublisher(),
readers,
TableIndex,
hasher,
0,
additionalCommitChecks: true,
metastreamMaxCount: MetastreamMaxCount);
ReadIndex.Init(ChaserCheckpoint.Read());
// scavenge must run after readIndex is built
if (_scavenge)
{
if (_completeLastChunkOnScavenge)
{
Db.Manager.GetChunk(Db.Manager.ChunksCount - 1).Complete();
}
_scavenger = new TFChunkScavenger(Db, IODispatcher, TableIndex, hasher, ReadIndex, Guid.NewGuid(), "fakeNodeIp");
_scavenger.Scavenge(alwaysKeepScavenged: true, mergeChunks: _mergeChunks);
}
}
public EmittedStream(
string streamId, WriterConfiguration writerConfiguration, ProjectionVersion projectionVersion,
PositionTagger positionTagger, CheckpointTag fromCheckpointPosition, IPublisher publisher, IODispatcher ioDispatcher,
IEmittedStreamContainer readyHandler, bool noCheckpoints = false)
{
if (string.IsNullOrEmpty(streamId))
{
throw new ArgumentNullException("streamId");
}
if (writerConfiguration == null)
{
throw new ArgumentNullException("writerConfiguration");
}
if (positionTagger == null)
{
throw new ArgumentNullException("positionTagger");
}
if (fromCheckpointPosition == null)
{
throw new ArgumentNullException("fromCheckpointPosition");
}
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (ioDispatcher == null)
{
throw new ArgumentNullException("ioDispatcher");
}
if (readyHandler == null)
{
throw new ArgumentNullException("readyHandler");
}
_streamId = streamId;
_metadataStreamId = SystemStreams.MetastreamOf(streamId);
_writerConfiguration = writerConfiguration;
_projectionVersion = projectionVersion;
_writeAs = writerConfiguration.WriteAs;
_positionTagger = positionTagger;
_zeroPosition = positionTagger.MakeZeroCheckpointTag();
_fromCheckpointPosition = fromCheckpointPosition;
_lastQueuedEventPosition = null;
_publisher = publisher;
_ioDispatcher = ioDispatcher;
_readyHandler = readyHandler;
_maxWriteBatchLength = writerConfiguration.MaxWriteBatchLength;
_logger = writerConfiguration.Logger;
_noCheckpoints = noCheckpoints;
}
public PasswordChangeNotificationReader(IPublisher publisher, IODispatcher ioDispatcher)
{
_publisher = publisher;
_ioDispatcher = ioDispatcher;
_log = Serilog.Log.ForContext <UserManagementService>();
}
public PersistentSubscriptionStreamReader(IODispatcher ioDispatcher, int maxPullBatchSize)
{
_ioDispatcher = ioDispatcher;
_maxPullBatchSize = maxPullBatchSize;
}
public ClusterVNode(TFChunkDb db,
ClusterVNodeSettings vNodeSettings,
IGossipSeedSource gossipSeedSource,
InfoController infoController,
params ISubsystem[] subsystems)
{
Ensure.NotNull(db, "db");
Ensure.NotNull(vNodeSettings, "vNodeSettings");
Ensure.NotNull(gossipSeedSource, "gossipSeedSource");
#if DEBUG
AddTask(_taskAddedTrigger.Task);
#endif
var isSingleNode = vNodeSettings.ClusterNodeCount == 1;
_vNodeSettings = vNodeSettings;
_nodeInfo = vNodeSettings.NodeInfo;
_certificate = vNodeSettings.Certificate;
_mainBus = new InMemoryBus("MainBus");
_httpMessageHandler = vNodeSettings.CreateHttpMessageHandler?.Invoke();
_queueStatsManager = new QueueStatsManager();
var forwardingProxy = new MessageForwardingProxy();
if (vNodeSettings.EnableHistograms)
{
HistogramService.CreateHistograms();
//start watching jitter
HistogramService.StartJitterMonitor();
}
// MISC WORKERS
_workerBuses = Enumerable.Range(0, vNodeSettings.WorkerThreads).Select(queueNum =>
new InMemoryBus(string.Format("Worker #{0} Bus", queueNum + 1),
watchSlowMsg: true,
slowMsgThreshold: TimeSpan.FromMilliseconds(200))).ToArray();
_workersHandler = new MultiQueuedHandler(
vNodeSettings.WorkerThreads,
queueNum => new QueuedHandlerThreadPool(_workerBuses[queueNum],
string.Format("Worker #{0}", queueNum + 1),
_queueStatsManager,
groupName: "Workers",
watchSlowMsg: true,
slowMsgThreshold: TimeSpan.FromMilliseconds(200)));
_subsystems = subsystems;
_controller = new ClusterVNodeController((IPublisher)_mainBus, _nodeInfo, db, vNodeSettings, this,
forwardingProxy, _subsystems);
_mainQueue = QueuedHandler.CreateQueuedHandler(_controller, "MainQueue", _queueStatsManager);
_controller.SetMainQueue(_mainQueue);
_eventStoreClusterClientCache = new EventStoreClusterClientCache(_mainQueue,
(endpoint, publisher) =>
new EventStoreClusterClient(
new UriBuilder(_vNodeSettings.GossipOverHttps ? Uri.UriSchemeHttps : Uri.UriSchemeHttp,
endpoint.Address.ToString(), endpoint.Port).Uri, publisher,
() => _httpMessageHandler));
_mainBus.Subscribe <ClusterClientMessage.CleanCache>(_eventStoreClusterClientCache);
_mainBus.Subscribe <SystemMessage.SystemInit>(_eventStoreClusterClientCache);
//SELF
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(this);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(this);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(this);
// MONITORING
var monitoringInnerBus = new InMemoryBus("MonitoringInnerBus", watchSlowMsg: false);
var monitoringRequestBus = new InMemoryBus("MonitoringRequestBus", watchSlowMsg: false);
var monitoringQueue = new QueuedHandlerThreadPool(monitoringInnerBus, "MonitoringQueue", _queueStatsManager, true,
TimeSpan.FromMilliseconds(800));
var monitoring = new MonitoringService(monitoringQueue,
monitoringRequestBus,
_mainQueue,
db.Config.WriterCheckpoint,
db.Config.Path,
vNodeSettings.StatsPeriod,
_nodeInfo.ExternalHttp,
vNodeSettings.StatsStorage,
_nodeInfo.ExternalTcp,
_nodeInfo.ExternalSecureTcp);
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.SystemInit, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.StateChangeMessage, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShutdown, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <ClientMessage.WriteEventsCompleted, Message>());
monitoringInnerBus.Subscribe <SystemMessage.SystemInit>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.StateChangeMessage>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.BecomeShuttingDown>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.BecomeShutdown>(monitoring);
monitoringInnerBus.Subscribe <ClientMessage.WriteEventsCompleted>(monitoring);
monitoringInnerBus.Subscribe <MonitoringMessage.GetFreshStats>(monitoring);
monitoringInnerBus.Subscribe <MonitoringMessage.GetFreshTcpConnectionStats>(monitoring);
var truncPos = db.Config.TruncateCheckpoint.Read();
var writerCheckpoint = db.Config.WriterCheckpoint.Read();
var chaserCheckpoint = db.Config.ChaserCheckpoint.Read();
var epochCheckpoint = db.Config.EpochCheckpoint.Read();
if (truncPos != -1)
{
Log.Information(
"Truncate checkpoint is present. Truncate: {truncatePosition} (0x{truncatePosition:X}), Writer: {writerCheckpoint} (0x{writerCheckpoint:X}), Chaser: {chaserCheckpoint} (0x{chaserCheckpoint:X}), Epoch: {epochCheckpoint} (0x{epochCheckpoint:X})",
truncPos, truncPos, writerCheckpoint, writerCheckpoint, chaserCheckpoint, chaserCheckpoint,
epochCheckpoint, epochCheckpoint);
var truncator = new TFChunkDbTruncator(db.Config);
truncator.TruncateDb(truncPos);
}
// STORAGE SUBSYSTEM
db.Open(vNodeSettings.VerifyDbHash, threads: vNodeSettings.InitializationThreads);
var indexPath = vNodeSettings.Index ?? Path.Combine(db.Config.Path, "index");
var readerPool = new ObjectPool <ITransactionFileReader>(
"ReadIndex readers pool", ESConsts.PTableInitialReaderCount, vNodeSettings.PTableMaxReaderCount,
() => new TFChunkReader(db, db.Config.WriterCheckpoint,
optimizeReadSideCache: db.Config.OptimizeReadSideCache));
var tableIndex = new TableIndex(indexPath,
new XXHashUnsafe(),
new Murmur3AUnsafe(),
() => new HashListMemTable(vNodeSettings.IndexBitnessVersion,
maxSize: vNodeSettings.MaxMemtableEntryCount * 2),
() => new TFReaderLease(readerPool),
vNodeSettings.IndexBitnessVersion,
maxSizeForMemory: vNodeSettings.MaxMemtableEntryCount,
maxTablesPerLevel: 2,
inMem: db.Config.InMemDb,
skipIndexVerify: vNodeSettings.SkipIndexVerify,
indexCacheDepth: vNodeSettings.IndexCacheDepth,
initializationThreads: vNodeSettings.InitializationThreads,
additionalReclaim: false,
maxAutoMergeIndexLevel: vNodeSettings.MaxAutoMergeIndexLevel,
pTableMaxReaderCount: vNodeSettings.PTableMaxReaderCount);
var readIndex = new ReadIndex(_mainQueue,
readerPool,
tableIndex,
ESConsts.StreamInfoCacheCapacity,
Application.IsDefined(Application.AdditionalCommitChecks),
Application.IsDefined(Application.InfiniteMetastreams) ? int.MaxValue : 1,
vNodeSettings.HashCollisionReadLimit,
vNodeSettings.SkipIndexScanOnReads,
db.Config.ReplicationCheckpoint,
db.Config.IndexCheckpoint);
_readIndex = readIndex;
var writer = new TFChunkWriter(db);
var epochManager = new EpochManager(_mainQueue,
ESConsts.CachedEpochCount,
db.Config.EpochCheckpoint,
writer,
initialReaderCount: 1,
maxReaderCount: 5,
readerFactory: () => new TFChunkReader(db, db.Config.WriterCheckpoint,
optimizeReadSideCache: db.Config.OptimizeReadSideCache));
epochManager.Init();
var storageWriter = new ClusterStorageWriterService(_mainQueue, _mainBus, vNodeSettings.MinFlushDelay,
db, writer, readIndex.IndexWriter, epochManager, _queueStatsManager,
() => readIndex.LastIndexedPosition); // subscribes internally
AddTasks(storageWriter.Tasks);
monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageWriter);
var storageReader = new StorageReaderService(_mainQueue, _mainBus, readIndex,
vNodeSettings.ReaderThreadsCount, db.Config.WriterCheckpoint, _queueStatsManager);
_mainBus.Subscribe <SystemMessage.SystemInit>(storageReader);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageReader);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(storageReader);
monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageReader);
//REPLICATION TRACKING
var replicationTracker =
new ReplicationTrackingService(_mainQueue, vNodeSettings.ClusterNodeCount, db.Config.ReplicationCheckpoint, db.Config.WriterCheckpoint);
AddTask(replicationTracker.Task);
_mainBus.Subscribe <SystemMessage.SystemInit>(replicationTracker);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(replicationTracker);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(replicationTracker);
_mainBus.Subscribe <ReplicationTrackingMessage.ReplicaWriteAck>(replicationTracker);
_mainBus.Subscribe <ReplicationTrackingMessage.WriterCheckpointFlushed>(replicationTracker);
_mainBus.Subscribe <ReplicationTrackingMessage.LeaderReplicatedTo>(replicationTracker);
_mainBus.Subscribe <SystemMessage.VNodeConnectionLost>(replicationTracker);
var indexCommitterService = new IndexCommitterService(readIndex.IndexCommitter, _mainQueue,
db.Config.WriterCheckpoint, db.Config.ReplicationCheckpoint, vNodeSettings.CommitAckCount, tableIndex, _queueStatsManager);
AddTask(indexCommitterService.Task);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(indexCommitterService);
_mainBus.Subscribe <ReplicationTrackingMessage.ReplicatedTo>(indexCommitterService);
_mainBus.Subscribe <StorageMessage.CommitAck>(indexCommitterService);
_mainBus.Subscribe <ClientMessage.MergeIndexes>(indexCommitterService);
var chaser = new TFChunkChaser(db, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint,
db.Config.OptimizeReadSideCache);
var storageChaser = new StorageChaser(_mainQueue, db.Config.WriterCheckpoint, chaser, indexCommitterService,
epochManager, _queueStatsManager);
AddTask(storageChaser.Task);
#if DEBUG
_queueStatsManager.InitializeCheckpoints(db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint);
#endif
_mainBus.Subscribe <SystemMessage.SystemInit>(storageChaser);
_mainBus.Subscribe <SystemMessage.SystemStart>(storageChaser);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageChaser);
// AUTHENTICATION INFRASTRUCTURE - delegate to plugins
_internalAuthenticationProvider =
vNodeSettings.AuthenticationProviderFactory.BuildAuthenticationProvider(_mainQueue, _mainBus,
_workersHandler, _workerBuses, vNodeSettings.LogFailedAuthenticationAttempts);
Ensure.NotNull(_internalAuthenticationProvider, "authenticationProvider");
_authorizationProvider = vNodeSettings.AuthorizationProviderFactory.Build(_mainQueue);
Ensure.NotNull(_authorizationProvider, "authorizationProvider");
AuthorizationGateway = new AuthorizationGateway(_authorizationProvider);
{
// EXTERNAL TCP
if (_nodeInfo.ExternalTcp != null && vNodeSettings.EnableExternalTCP)
{
var extTcpService = new TcpService(_mainQueue, _nodeInfo.ExternalTcp, _workersHandler,
TcpServiceType.External, TcpSecurityType.Normal, new ClientTcpDispatcher(),
vNodeSettings.ExtTcpHeartbeatInterval, vNodeSettings.ExtTcpHeartbeatTimeout,
_internalAuthenticationProvider, AuthorizationGateway, null, false, vNodeSettings.ConnectionPendingSendBytesThreshold,
vNodeSettings.ConnectionQueueSizeThreshold);
_mainBus.Subscribe <SystemMessage.SystemInit>(extTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(extTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(extTcpService);
}
// EXTERNAL SECURE TCP
if (_nodeInfo.ExternalSecureTcp != null && vNodeSettings.EnableExternalTCP)
{
var extSecTcpService = new TcpService(_mainQueue, _nodeInfo.ExternalSecureTcp, _workersHandler,
TcpServiceType.External, TcpSecurityType.Secure, new ClientTcpDispatcher(),
vNodeSettings.ExtTcpHeartbeatInterval, vNodeSettings.ExtTcpHeartbeatTimeout,
_internalAuthenticationProvider, AuthorizationGateway, vNodeSettings.Certificate, false,
vNodeSettings.ConnectionPendingSendBytesThreshold, vNodeSettings.ConnectionQueueSizeThreshold);
_mainBus.Subscribe <SystemMessage.SystemInit>(extSecTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(extSecTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(extSecTcpService);
}
if (!isSingleNode)
{
// INTERNAL TCP
if (_nodeInfo.InternalTcp != null)
{
var intTcpService = new TcpService(_mainQueue, _nodeInfo.InternalTcp, _workersHandler,
TcpServiceType.Internal, TcpSecurityType.Normal,
new InternalTcpDispatcher(),
vNodeSettings.IntTcpHeartbeatInterval, vNodeSettings.IntTcpHeartbeatTimeout,
_internalAuthenticationProvider, AuthorizationGateway, null, false, ESConsts.UnrestrictedPendingSendBytes,
ESConsts.MaxConnectionQueueSize);
_mainBus.Subscribe <SystemMessage.SystemInit>(intTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(intTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(intTcpService);
}
// INTERNAL SECURE TCP
if (_nodeInfo.InternalSecureTcp != null)
{
var intSecTcpService = new TcpService(_mainQueue, _nodeInfo.InternalSecureTcp, _workersHandler,
TcpServiceType.Internal, TcpSecurityType.Secure,
new InternalTcpDispatcher(),
vNodeSettings.IntTcpHeartbeatInterval, vNodeSettings.IntTcpHeartbeatTimeout,
_internalAuthenticationProvider, AuthorizationGateway, vNodeSettings.Certificate, true,
ESConsts.UnrestrictedPendingSendBytes,
ESConsts.MaxConnectionQueueSize);
_mainBus.Subscribe <SystemMessage.SystemInit>(intSecTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(intSecTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(intSecTcpService);
}
}
}
SubscribeWorkers(bus => {
var tcpSendService = new TcpSendService();
// ReSharper disable RedundantTypeArgumentsOfMethod
bus.Subscribe <TcpMessage.TcpSend>(tcpSendService);
// ReSharper restore RedundantTypeArgumentsOfMethod
});
var httpAuthenticationProviders = new List <IHttpAuthenticationProvider> {
new BasicHttpAuthenticationProvider(_internalAuthenticationProvider),
};
if (vNodeSettings.EnableTrustedAuth)
{
httpAuthenticationProviders.Add(new TrustedHttpAuthenticationProvider());
}
httpAuthenticationProviders.Add(new AnonymousHttpAuthenticationProvider());
var httpPipe = new HttpMessagePipe();
var httpSendService = new HttpSendService(httpPipe, forwardRequests: true);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(httpSendService);
SubscribeWorkers(bus => {
bus.Subscribe <HttpMessage.HttpSend>(httpSendService);
});
var grpcSendService = new GrpcSendService(_eventStoreClusterClientCache);
_mainBus.Subscribe(new WideningHandler <GrpcMessage.SendOverGrpc, Message>(_workersHandler));
SubscribeWorkers(bus => {
bus.Subscribe <GrpcMessage.SendOverGrpc>(grpcSendService);
});
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(infoController);
var adminController = new AdminController(_mainQueue, _workersHandler);
var pingController = new PingController();
var histogramController = new HistogramController();
var statController = new StatController(monitoringQueue, _workersHandler);
var atomController = new AtomController(_mainQueue, _workersHandler,
vNodeSettings.DisableHTTPCaching);
var gossipController = new GossipController(_mainQueue, _workersHandler, vNodeSettings.GossipTimeout,
_httpMessageHandler);
var persistentSubscriptionController =
new PersistentSubscriptionController(httpSendService, _mainQueue, _workersHandler);
// HTTP SENDERS
gossipController.SubscribeSenders(httpPipe);
// EXTERNAL HTTP
_externalHttpService = new KestrelHttpService(ServiceAccessibility.Public, _mainQueue, new TrieUriRouter(),
_workersHandler, vNodeSettings.LogHttpRequests,
vNodeSettings.GossipAdvertiseInfo.AdvertiseExternalIPAs,
vNodeSettings.GossipAdvertiseInfo.AdvertiseExternalHttpPortAs,
vNodeSettings.DisableFirstLevelHttpAuthorization,
vNodeSettings.NodeInfo.ExternalHttp);
_externalHttpService.SetupController(persistentSubscriptionController);
if (vNodeSettings.AdminOnPublic)
{
_externalHttpService.SetupController(adminController);
}
_externalHttpService.SetupController(pingController);
_externalHttpService.SetupController(infoController);
if (vNodeSettings.StatsOnPublic)
{
_externalHttpService.SetupController(statController);
}
if (vNodeSettings.EnableAtomPubOverHTTP)
{
_externalHttpService.SetupController(atomController);
}
if (vNodeSettings.GossipOnPublic)
{
_externalHttpService.SetupController(gossipController);
}
_externalHttpService.SetupController(histogramController);
_mainBus.Subscribe <SystemMessage.SystemInit>(_externalHttpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(_externalHttpService);
// Authentication plugin HTTP
vNodeSettings.AuthenticationProviderFactory.RegisterHttpControllers(_externalHttpService, httpSendService,
_mainQueue, _workersHandler);
SubscribeWorkers(KestrelHttpService.CreateAndSubscribePipeline);
// REQUEST FORWARDING
var forwardingService = new RequestForwardingService(_mainQueue, forwardingProxy, TimeSpan.FromSeconds(1));
_mainBus.Subscribe <SystemMessage.SystemStart>(forwardingService);
_mainBus.Subscribe <SystemMessage.RequestForwardingTimerTick>(forwardingService);
_mainBus.Subscribe <ClientMessage.NotHandled>(forwardingService);
_mainBus.Subscribe <ClientMessage.WriteEventsCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionStartCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionWriteCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionCommitCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.DeleteStreamCompleted>(forwardingService);
// REQUEST MANAGEMENT
var requestManagement = new RequestManagementService(
_mainQueue,
vNodeSettings.PrepareTimeout,
vNodeSettings.CommitTimeout);
_mainBus.Subscribe <SystemMessage.SystemInit>(requestManagement);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(requestManagement);
_mainBus.Subscribe <ClientMessage.WriteEvents>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionStart>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionWrite>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionCommit>(requestManagement);
_mainBus.Subscribe <ClientMessage.DeleteStream>(requestManagement);
_mainBus.Subscribe <StorageMessage.AlreadyCommitted>(requestManagement);
_mainBus.Subscribe <StorageMessage.CommitAck>(requestManagement);
_mainBus.Subscribe <StorageMessage.PrepareAck>(requestManagement);
_mainBus.Subscribe <ReplicationTrackingMessage.ReplicatedTo>(requestManagement);
_mainBus.Subscribe <ReplicationTrackingMessage.IndexedTo>(requestManagement);
_mainBus.Subscribe <StorageMessage.RequestCompleted>(requestManagement);
_mainBus.Subscribe <StorageMessage.CommitIndexed>(requestManagement);
_mainBus.Subscribe <StorageMessage.WrongExpectedVersion>(requestManagement);
_mainBus.Subscribe <StorageMessage.InvalidTransaction>(requestManagement);
_mainBus.Subscribe <StorageMessage.StreamDeleted>(requestManagement);
_mainBus.Subscribe <StorageMessage.RequestManagerTimerTick>(requestManagement);
// SUBSCRIPTIONS
var subscrBus = new InMemoryBus("SubscriptionsBus", true, TimeSpan.FromMilliseconds(50));
var subscrQueue = new QueuedHandlerThreadPool(subscrBus, "Subscriptions", _queueStatsManager, false);
_mainBus.Subscribe(subscrQueue.WidenFrom <SystemMessage.SystemStart, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <TcpMessage.ConnectionClosed, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <ClientMessage.SubscribeToStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <ClientMessage.FilteredSubscribeToStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <ClientMessage.UnsubscribeFromStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SubscriptionMessage.PollStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SubscriptionMessage.CheckPollTimeout, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <StorageMessage.EventCommitted, Message>());
var subscription = new SubscriptionsService(_mainQueue, subscrQueue, readIndex);
subscrBus.Subscribe <SystemMessage.SystemStart>(subscription);
subscrBus.Subscribe <SystemMessage.BecomeShuttingDown>(subscription);
subscrBus.Subscribe <TcpMessage.ConnectionClosed>(subscription);
subscrBus.Subscribe <ClientMessage.SubscribeToStream>(subscription);
subscrBus.Subscribe <ClientMessage.FilteredSubscribeToStream>(subscription);
subscrBus.Subscribe <ClientMessage.UnsubscribeFromStream>(subscription);
subscrBus.Subscribe <SubscriptionMessage.PollStream>(subscription);
subscrBus.Subscribe <SubscriptionMessage.CheckPollTimeout>(subscription);
subscrBus.Subscribe <StorageMessage.EventCommitted>(subscription);
// PERSISTENT SUBSCRIPTIONS
// IO DISPATCHER
var ioDispatcher = new IODispatcher(_mainQueue, new PublishEnvelope(_mainQueue));
_mainBus.Subscribe <ClientMessage.ReadStreamEventsBackwardCompleted>(ioDispatcher.BackwardReader);
_mainBus.Subscribe <ClientMessage.WriteEventsCompleted>(ioDispatcher.Writer);
_mainBus.Subscribe <ClientMessage.ReadStreamEventsForwardCompleted>(ioDispatcher.ForwardReader);
_mainBus.Subscribe <ClientMessage.DeleteStreamCompleted>(ioDispatcher.StreamDeleter);
_mainBus.Subscribe(ioDispatcher);
var perSubscrBus = new InMemoryBus("PersistentSubscriptionsBus", true, TimeSpan.FromMilliseconds(50));
var perSubscrQueue = new QueuedHandlerThreadPool(perSubscrBus, "PersistentSubscriptions", _queueStatsManager, false);
_mainBus.Subscribe(perSubscrQueue.WidenFrom <SystemMessage.StateChangeMessage, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <TcpMessage.ConnectionClosed, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.CreatePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.UpdatePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.DeletePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ConnectToPersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.UnsubscribeFromStream, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.PersistentSubscriptionAckEvents, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.PersistentSubscriptionNackEvents, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReplayParkedMessages, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReplayParkedMessage, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReadNextNPersistentMessages, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <StorageMessage.EventCommitted, Message>());
_mainBus.Subscribe(perSubscrQueue
.WidenFrom <MonitoringMessage.GetAllPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(
perSubscrQueue.WidenFrom <MonitoringMessage.GetStreamPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(perSubscrQueue
.WidenFrom <SubscriptionMessage.PersistentSubscriptionTimerTick, Message>());
//TODO CC can have multiple threads working on subscription if partition
var consumerStrategyRegistry =
new PersistentSubscriptionConsumerStrategyRegistry(_mainQueue, _mainBus,
vNodeSettings.AdditionalConsumerStrategies);
var persistentSubscription = new PersistentSubscriptionService(perSubscrQueue, readIndex, ioDispatcher,
_mainQueue, consumerStrategyRegistry);
perSubscrBus.Subscribe <SystemMessage.BecomeShuttingDown>(persistentSubscription);
perSubscrBus.Subscribe <SystemMessage.BecomeLeader>(persistentSubscription);
perSubscrBus.Subscribe <SystemMessage.StateChangeMessage>(persistentSubscription);
perSubscrBus.Subscribe <TcpMessage.ConnectionClosed>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ConnectToPersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.UnsubscribeFromStream>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.PersistentSubscriptionAckEvents>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.PersistentSubscriptionNackEvents>(persistentSubscription);
perSubscrBus.Subscribe <StorageMessage.EventCommitted>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.DeletePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.CreatePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.UpdatePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReplayParkedMessages>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReplayParkedMessage>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReadNextNPersistentMessages>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetAllPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetStreamPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <SubscriptionMessage.PersistentSubscriptionTimerTick>(persistentSubscription);
// STORAGE SCAVENGER
var scavengerLogManager = new TFChunkScavengerLogManager(_nodeInfo.ExternalHttp.ToString(),
TimeSpan.FromDays(vNodeSettings.ScavengeHistoryMaxAge), ioDispatcher);
var storageScavenger = new StorageScavenger(db,
tableIndex,
readIndex,
scavengerLogManager,
vNodeSettings.AlwaysKeepScavenged,
!vNodeSettings.DisableScavengeMerging,
unsafeIgnoreHardDeletes: vNodeSettings.UnsafeIgnoreHardDeletes);
// ReSharper disable RedundantTypeArgumentsOfMethod
_mainBus.Subscribe <ClientMessage.ScavengeDatabase>(storageScavenger);
_mainBus.Subscribe <ClientMessage.StopDatabaseScavenge>(storageScavenger);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(storageScavenger);
// ReSharper restore RedundantTypeArgumentsOfMethod
// TIMER
_timeProvider = new RealTimeProvider();
var threadBasedScheduler = new ThreadBasedScheduler(_timeProvider, _queueStatsManager);
AddTask(threadBasedScheduler.Task);
_timerService = new TimerService(threadBasedScheduler);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(_timerService);
_mainBus.Subscribe <TimerMessage.Schedule>(_timerService);
var gossipInfo = new VNodeInfo(_nodeInfo.InstanceId, _nodeInfo.DebugIndex,
vNodeSettings.GossipAdvertiseInfo.InternalTcp,
vNodeSettings.GossipAdvertiseInfo.InternalSecureTcp,
vNodeSettings.GossipAdvertiseInfo.ExternalTcp,
vNodeSettings.GossipAdvertiseInfo.ExternalSecureTcp,
vNodeSettings.GossipAdvertiseInfo.InternalHttp,
vNodeSettings.GossipAdvertiseInfo.ExternalHttp,
vNodeSettings.ReadOnlyReplica);
if (!isSingleNode)
{
// LEADER REPLICATION
var leaderReplicationService = new LeaderReplicationService(_mainQueue, gossipInfo.InstanceId, db,
_workersHandler,
epochManager, vNodeSettings.ClusterNodeCount,
vNodeSettings.UnsafeAllowSurplusNodes,
_queueStatsManager);
AddTask(leaderReplicationService.Task);
_mainBus.Subscribe <SystemMessage.SystemStart>(leaderReplicationService);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(leaderReplicationService);
_mainBus.Subscribe <ReplicationMessage.ReplicaSubscriptionRequest>(leaderReplicationService);
_mainBus.Subscribe <ReplicationMessage.ReplicaLogPositionAck>(leaderReplicationService);
_mainBus.Subscribe <ReplicationTrackingMessage.ReplicatedTo>(leaderReplicationService);
monitoringInnerBus.Subscribe <ReplicationMessage.GetReplicationStats>(leaderReplicationService);
// REPLICA REPLICATION
var replicaService = new ReplicaService(_mainQueue, db, epochManager, _workersHandler,
_internalAuthenticationProvider, AuthorizationGateway,
gossipInfo, !vNodeSettings.DisableInternalTls, true,
Certificate == null ? null : new X509Certificate2Collection(Certificate),
vNodeSettings.IntTcpHeartbeatTimeout, vNodeSettings.ExtTcpHeartbeatInterval);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(replicaService);
_mainBus.Subscribe <ReplicationMessage.ReconnectToLeader>(replicaService);
_mainBus.Subscribe <ReplicationMessage.SubscribeToLeader>(replicaService);
_mainBus.Subscribe <ReplicationMessage.AckLogPosition>(replicaService);
_mainBus.Subscribe <ClientMessage.TcpForwardMessage>(replicaService);
}
// ELECTIONS
var electionsService = new ElectionsService(_mainQueue, gossipInfo, vNodeSettings.ClusterNodeCount,
db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint,
epochManager, () => readIndex.LastIndexedPosition, vNodeSettings.NodePriority, _timeProvider);
electionsService.SubscribeMessages(_mainBus);
if (!isSingleNode || vNodeSettings.GossipOnSingleNode)
{
// GOSSIP
var gossip = new NodeGossipService(_mainQueue, gossipSeedSource, gossipInfo, db.Config.WriterCheckpoint,
db.Config.ChaserCheckpoint, epochManager, () => readIndex.LastIndexedPosition,
vNodeSettings.NodePriority, vNodeSettings.GossipInterval, vNodeSettings.GossipAllowedTimeDifference,
vNodeSettings.GossipTimeout,
vNodeSettings.DeadMemberRemovalPeriod,
_timeProvider);
_mainBus.Subscribe <SystemMessage.SystemInit>(gossip);
_mainBus.Subscribe <GossipMessage.RetrieveGossipSeedSources>(gossip);
_mainBus.Subscribe <GossipMessage.GotGossipSeedSources>(gossip);
_mainBus.Subscribe <GossipMessage.Gossip>(gossip);
_mainBus.Subscribe <GossipMessage.GossipReceived>(gossip);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(gossip);
_mainBus.Subscribe <GossipMessage.GossipSendFailed>(gossip);
_mainBus.Subscribe <GossipMessage.UpdateNodePriority>(gossip);
_mainBus.Subscribe <SystemMessage.VNodeConnectionEstablished>(gossip);
_mainBus.Subscribe <SystemMessage.VNodeConnectionLost>(gossip);
_mainBus.Subscribe <GossipMessage.GetGossipFailed>(gossip);
_mainBus.Subscribe <GossipMessage.GetGossipReceived>(gossip);
_mainBus.Subscribe <ElectionMessage.ElectionsDone>(gossip);
}
// kestrel
AddTasks(_workersHandler.Start());
AddTask(_mainQueue.Start());
AddTask(monitoringQueue.Start());
AddTask(subscrQueue.Start());
AddTask(perSubscrQueue.Start());
if (subsystems != null)
{
foreach (var subsystem in subsystems)
{
var http = new[] { _externalHttpService };
subsystem.Register(new StandardComponents(db, _mainQueue, _mainBus, _timerService, _timeProvider,
httpSendService, http, _workersHandler, _queueStatsManager));
}
}
_startup = new ClusterVNodeStartup(_subsystems, _mainQueue, _mainBus, _workersHandler, httpAuthenticationProviders, _authorizationProvider, _readIndex,
_vNodeSettings.MaxAppendSize, _externalHttpService);
_mainBus.Subscribe <SystemMessage.SystemReady>(_startup);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(_startup);
}
