public void Register(StandardComponents standardComponents)
{
_leaderInputQueue = QueuedHandler.CreateQueuedHandler(_leaderMainBus, "Projections Leader",
standardComponents.QueueStatsManager);
_leaderOutputBus = new InMemoryBus("ProjectionManagerAndCoreCoordinatorOutput");
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.RestartSubsystem>(this);
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.ComponentStarted>(this);
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.ComponentStopped>(this);
_leaderMainBus.Subscribe <ProjectionSubsystemMessage.IODispatcherDrained>(this);
_leaderMainBus.Subscribe <SystemMessage.SystemCoreReady>(this);
_leaderMainBus.Subscribe <SystemMessage.StateChangeMessage>(this);
var projectionsStandardComponents = new ProjectionsStandardComponents(
_projectionWorkerThreadCount,
_runProjections,
_leaderOutputBus,
_leaderInputQueue,
_leaderMainBus, _faultOutOfOrderProjections);
CreateAwakerService(standardComponents);
_coreQueues =
ProjectionCoreWorkersNode.CreateCoreWorkers(standardComponents, projectionsStandardComponents);
_queueMap = _coreQueues.ToDictionary(v => v.Key, v => (IPublisher)v.Value);
ProjectionManagerNode.CreateManagerService(standardComponents, projectionsStandardComponents, _queueMap,
_projectionsQueryExpiry);
projectionsStandardComponents.LeaderMainBus.Subscribe <CoreProjectionStatusMessage.Stopped>(this);
projectionsStandardComponents.LeaderMainBus.Subscribe <CoreProjectionStatusMessage.Started>(this);
}
public MonitoringService(IQueuedHandler monitoringQueue,
IPublisher statsCollectionBus,
IPublisher mainBus,
ICheckpoint writerCheckpoint,
string dbPath,
TimeSpan statsCollectionPeriod,
IPEndPoint nodeEndpoint,
StatsStorage statsStorage,
IPEndPoint tcpEndpoint,
IPEndPoint tcpSecureEndpoint)
{
Ensure.NotNull(monitoringQueue, "monitoringQueue");
Ensure.NotNull(statsCollectionBus, "statsCollectionBus");
Ensure.NotNull(mainBus, "mainBus");
Ensure.NotNull(writerCheckpoint, "writerCheckpoint");
Ensure.NotNullOrEmpty(dbPath, "dbPath");
Ensure.NotNull(nodeEndpoint, "nodeEndpoint");
Ensure.NotNull(tcpEndpoint, "tcpEndpoint");
_monitoringQueue = monitoringQueue;
_statsCollectionBus = statsCollectionBus;
_mainBus = mainBus;
_writerCheckpoint = writerCheckpoint;
_dbPath = dbPath;
_statsStorage = statsStorage;
_statsCollectionPeriodMs = statsCollectionPeriod > TimeSpan.Zero
? (long)statsCollectionPeriod.TotalMilliseconds
: Timeout.Infinite;
_nodeStatsStream = string.Format("{0}-{1}", SystemStreams.StatsStreamPrefix, nodeEndpoint);
_tcpEndpoint = tcpEndpoint;
_tcpSecureEndpoint = tcpSecureEndpoint;
_timer = new Timer(OnTimerTick, null, Timeout.Infinite, Timeout.Infinite);
}
public virtual void TearDown()
{
Queue.Stop();
Queue = null;
Consumer.Dispose();
Consumer = null;
}
public virtual void TearDown()
{
Queue.Stop();
Queue = null;
Consumer.Dispose();
Consumer = null;
}
public void SetMainQueue(IQueuedHandler mainQueue)
{
Ensure.NotNull(mainQueue, "mainQueue");
_mainQueue = mainQueue;
_publishEnvelope = new PublishEnvelope(mainQueue);
}
public Users(IQueuedHandler queue)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
_queue = queue;
}
public ProjectionManagement(IQueuedHandler queue)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
_queue = queue;
}
public PersistentSubscriptions(IQueuedHandler queue)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
_queue = queue;
}
public SubscriptionsService(IPublisher bus, IQueuedHandler queuedHandler, IReadIndex readIndex)
{
Ensure.NotNull(bus, "bus");
Ensure.NotNull(queuedHandler, "queuedHandler");
Ensure.NotNull(readIndex, "readIndex");
_bus = bus;
_busEnvelope = new PublishEnvelope(bus);
_queuedHandler = queuedHandler;
_readIndex = readIndex;
}
public ProjectionWorkerNode(
Guid workerId,
TFChunkDb db,
IQueuedHandler inputQueue,
ITimeProvider timeProvider,
ISingletonTimeoutScheduler timeoutScheduler,
ProjectionType runProjections,
bool faultOutOfOrderProjections)
{
_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,
faultOutOfOrderProjections: faultOutOfOrderProjections);
_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 Streams(IQueuedHandler queue, IReadIndex readIndex,
int maxAppendSize)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
_queue = queue;
_readIndex = readIndex;
_maxAppendSize = maxAppendSize;
}
public static void CreateManagerService(
StandardComponents standardComponents,
ProjectionsStandardComponents projectionsStandardComponents,
IDictionary <Guid, IPublisher> queues,
TimeSpan projectionQueryExpiry)
{
IQueuedHandler inputQueue = projectionsStandardComponents.MasterInputQueue;
InMemoryBus outputBus = projectionsStandardComponents.MasterOutputBus;
var ioDispatcher = new IODispatcher(outputBus, new PublishEnvelope(inputQueue));
var projectionsController = new ProjectionsController(
standardComponents.HttpForwarder,
inputQueue,
standardComponents.NetworkSendService);
var forwarder = new RequestResponseQueueForwarder(
inputQueue: projectionsStandardComponents.MasterInputQueue,
externalRequestQueue: standardComponents.MainQueue);
if (projectionsStandardComponents.RunProjections != ProjectionType.None)
{
foreach (var httpService in standardComponents.HttpServices)
{
httpService.SetupController(projectionsController);
}
}
var commandWriter = new MultiStreamMessageWriter(ioDispatcher);
var projectionManagerCommandWriter = new ProjectionManagerCommandWriter(commandWriter);
var projectionManagerResponseReader = new ProjectionManagerResponseReader(outputBus, ioDispatcher,
queues.Count);
var projectionManager = new ProjectionManager(
inputQueue,
outputBus,
queues,
new RealTimeProvider(),
projectionsStandardComponents.RunProjections,
ioDispatcher,
projectionQueryExpiry);
SubscribeMainBus(
projectionsStandardComponents.MasterMainBus,
projectionManager,
projectionsStandardComponents.RunProjections,
projectionManagerResponseReader,
ioDispatcher,
projectionManagerCommandWriter);
SubscribeOutputBus(standardComponents, projectionsStandardComponents, forwarder);
}
public ProjectionManagement(IQueuedHandler queue, IAuthorizationProvider authorizationProvider)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
if (authorizationProvider == null)
{
throw new ArgumentNullException(nameof(authorizationProvider));
}
_queue = queue;
_authorizationProvider = authorizationProvider;
}
public ProjectionsStandardComponents(
int projectionWorkerThreadCount,
ProjectionType runProjections,
InMemoryBus masterOutputBus,
IQueuedHandler masterInputQueue,
InMemoryBus masterMainBus)
{
_projectionWorkerThreadCount = projectionWorkerThreadCount;
_runProjections = runProjections;
_masterOutputBus = masterOutputBus;
_masterInputQueue = masterInputQueue;
_masterMainBus = masterMainBus;
}
public Operations(IQueuedHandler queue, IAuthenticationProvider authenticationProvider)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
if (authenticationProvider == null)
{
throw new ArgumentNullException(nameof(authenticationProvider));
}
_queue = queue;
_authenticationProvider = authenticationProvider;
}
public ClusterVNodeStartup(
ISubsystem[] subsystems,
IQueuedHandler mainQueue,
IAuthenticationProvider internalAuthenticationProvider,
IReadIndex readIndex,
ClusterVNodeSettings vNodeSettings,
KestrelHttpService externalHttpService,
KestrelHttpService internalHttpService = null)
{
if (subsystems == null)
{
throw new ArgumentNullException(nameof(subsystems));
}
if (mainQueue == null)
{
throw new ArgumentNullException(nameof(mainQueue));
}
if (internalAuthenticationProvider == null)
{
throw new ArgumentNullException(nameof(internalAuthenticationProvider));
}
if (readIndex == null)
{
throw new ArgumentNullException(nameof(readIndex));
}
if (vNodeSettings == null)
{
throw new ArgumentNullException(nameof(vNodeSettings));
}
if (externalHttpService == null)
{
throw new ArgumentNullException(nameof(externalHttpService));
}
_subsystems = subsystems;
_mainQueue = mainQueue;
_internalAuthenticationProvider = internalAuthenticationProvider;
_readIndex = readIndex;
_vNodeSettings = vNodeSettings;
_externalHttpService = externalHttpService;
_internalHttpService = internalHttpService;
_statusCheck = new StatusCheck(this);
}
public ProjectionsStandardComponents(
int projectionWorkerThreadCount,
ProjectionType runProjections,
InMemoryBus leaderOutputBus,
IQueuedHandler leaderInputQueue,
InMemoryBus leaderMainBus,
bool faultOutOfOrderProjections)
{
_projectionWorkerThreadCount = projectionWorkerThreadCount;
_runProjections = runProjections;
_leaderOutputBus = leaderOutputBus;
_leaderInputQueue = leaderInputQueue;
_leaderMainBus = leaderMainBus;
_faultOutOfOrderProjections = faultOutOfOrderProjections;
}
public StorageWriterService(IPublisher bus,
ISubscriber subscribeToBus,
TimeSpan minFlushDelay,
TFChunkDb db,
TFChunkWriter writer,
IIndexWriter indexWriter,
IEpochManager epochManager,
QueueStatsManager queueStatsManager)
{
Ensure.NotNull(bus, "bus");
Ensure.NotNull(subscribeToBus, "subscribeToBus");
Ensure.NotNull(db, "db");
Ensure.NotNull(writer, "writer");
Ensure.NotNull(indexWriter, "indexWriter");
Ensure.NotNull(epochManager, "epochManager");
Bus = bus;
_subscribeToBus = subscribeToBus;
Db = db;
_indexWriter = indexWriter;
EpochManager = epochManager;
_minFlushDelay = minFlushDelay.TotalMilliseconds * TicksPerMs;
_lastFlushDelay = 0;
_lastFlushTimestamp = _watch.ElapsedTicks;
Writer = writer;
Writer.Open();
_writerBus = new InMemoryBus("StorageWriterBus", watchSlowMsg: false);
StorageWriterQueue = QueuedHandler.CreateQueuedHandler(new AdHocHandler <Message>(CommonHandle),
"StorageWriterQueue",
queueStatsManager,
true,
TimeSpan.FromMilliseconds(500));
_tasks.Add(StorageWriterQueue.Start());
SubscribeToMessage <SystemMessage.SystemInit>();
SubscribeToMessage <SystemMessage.StateChangeMessage>();
SubscribeToMessage <SystemMessage.WriteEpoch>();
SubscribeToMessage <SystemMessage.WaitForChaserToCatchUp>();
SubscribeToMessage <StorageMessage.WritePrepares>();
SubscribeToMessage <StorageMessage.WriteDelete>();
SubscribeToMessage <StorageMessage.WriteTransactionStart>();
SubscribeToMessage <StorageMessage.WriteTransactionData>();
SubscribeToMessage <StorageMessage.WriteTransactionEnd>();
SubscribeToMessage <StorageMessage.WriteCommit>();
}
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);
_timerTickCorrelationId = Guid.NewGuid();
}
public Streams(IQueuedHandler queue, IAuthenticationProvider authenticationProvider, IReadIndex readIndex,
int maxAppendSize)
{
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
if (authenticationProvider == null)
{
throw new ArgumentNullException(nameof(authenticationProvider));
}
_queue = queue;
_readIndex = readIndex;
_authenticationProvider = authenticationProvider;
_maxAppendSize = maxAppendSize;
}
public ProjectionsStandardComponents(
int projectionWorkerThreadCount,
ProjectionType runProjections,
IBus leaderOutputBus,
IQueuedHandler leaderInputQueue,
IBus leaderMainBus,
bool faultOutOfOrderProjections, int projectionCompilationTimeout, int projectionExecutionTimeout)
{
ProjectionWorkerThreadCount = projectionWorkerThreadCount;
RunProjections = runProjections;
LeaderOutputBus = leaderOutputBus;
LeaderInputQueue = leaderInputQueue;
LeaderMainBus = leaderMainBus;
FaultOutOfOrderProjections = faultOutOfOrderProjections;
ProjectionCompilationTimeout = projectionCompilationTimeout;
ProjectionExecutionTimeout = projectionExecutionTimeout;
}
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 ProjectionWorkerNode(
Guid workerId,
TFChunkDb db,
IQueuedHandler inputQueue,
ITimeProvider timeProvider,
ISingletonTimeoutScheduler timeoutScheduler,
ProjectionType runProjections,
bool faultOutOfOrderProjections,
IPublisher leaderOutputBus,
ProjectionsStandardComponents configuration)
{
_runProjections = runProjections;
Ensure.NotNull(db, "db");
_coreOutput = new InMemoryBus("Core Output");
_leaderOutputBus = leaderOutputBus;
IPublisher publisher = CoreOutput;
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(publisher);
_ioDispatcher = new IODispatcher(publisher, new PublishEnvelope(inputQueue), true);
_eventReaderCoreService = new EventReaderCoreService(
publisher,
_ioDispatcher,
10,
db.Config.WriterCheckpoint,
runHeadingReader: runProjections >= ProjectionType.System,
faultOutOfOrderProjections: faultOutOfOrderProjections);
_feedReaderService = new FeedReaderService(_subscriptionDispatcher, timeProvider);
if (runProjections >= ProjectionType.System)
{
_projectionCoreService = new ProjectionCoreService(
workerId,
inputQueue,
publisher,
_subscriptionDispatcher,
timeProvider,
_ioDispatcher,
timeoutScheduler,
configuration);
}
}
public StandardComponents(
TFChunkDb db,
IQueuedHandler mainQueue,
ISubscriber mainBus,
TimerService timerService,
ITimeProvider timeProvider,
IHttpForwarder httpForwarder,
HttpService[] httpServices,
IPublisher networkSendService)
{
_db = db;
_mainQueue = mainQueue;
_mainBus = mainBus;
_timerService = timerService;
_timeProvider = timeProvider;
_httpForwarder = httpForwarder;
_httpServices = httpServices;
_networkSendService = networkSendService;
}
public void Register(StandardComponents standardComponents)
{
_masterMainBus = new InMemoryBus("manager input bus");
_masterInputQueue = QueuedHandler.CreateQueuedHandler(_masterMainBus, "Projections Master");
_masterOutputBus = new InMemoryBus("ProjectionManagerAndCoreCoordinatorOutput");
var projectionsStandardComponents = new ProjectionsStandardComponents(
_projectionWorkerThreadCount,
_runProjections,
_masterOutputBus,
_masterInputQueue,
_masterMainBus);
CreateAwakerService(standardComponents);
_coreQueues = ProjectionCoreWorkersNode.CreateCoreWorkers(standardComponents, projectionsStandardComponents);
_queueMap = _coreQueues.ToDictionary(v => v.Key, v => (IPublisher)v.Value);
ProjectionManagerNode.CreateManagerService(standardComponents, projectionsStandardComponents, _queueMap, _projectionsQueryExpiry);
projectionsStandardComponents.MasterMainBus.Subscribe <CoreProjectionStatusMessage.Stopped>(this);
}
public virtual void SetUp()
{
Consumer = new WaitingConsumer(0);
Queue = _queuedHandlerFactory(Consumer, "waiting_queue", TimeSpan.FromMilliseconds(5000));
}
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;
_nodeInfo = vNodeSettings.NodeInfo;
_mainBus = new InMemoryBus("MainBus");
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),
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");
_controller.SetMainQueue(_mainQueue);
//SELF
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(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", 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,
_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();
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, 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);
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);
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,
() => readIndex.LastCommitPosition); // subscribes internally
AddTasks(storageWriter.Tasks);
monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageWriter);
var storageReader = new StorageReaderService(_mainQueue, _mainBus, readIndex, vNodeSettings.ReaderThreadsCount, db.Config.WriterCheckpoint);
_mainBus.Subscribe <SystemMessage.SystemInit>(storageReader);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageReader);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(storageReader);
monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageReader);
var indexCommitterService = new IndexCommitterService(readIndex.IndexCommitter, _mainQueue, db.Config.ReplicationCheckpoint, db.Config.WriterCheckpoint, vNodeSettings.CommitAckCount);
AddTask(indexCommitterService.Task);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(indexCommitterService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(indexCommitterService);
_mainBus.Subscribe <StorageMessage.CommitAck>(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);
AddTask(storageChaser.Task);
#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
if (!vNodeSettings.DisableInsecureTCP)
{
var extTcpService = new TcpService(_mainQueue, _nodeInfo.ExternalTcp, _workersHandler,
TcpServiceType.External, TcpSecurityType.Normal, new ClientTcpDispatcher(),
vNodeSettings.ExtTcpHeartbeatInterval, vNodeSettings.ExtTcpHeartbeatTimeout,
_internalAuthenticationProvider, null, vNodeSettings.ConnectionPendingSendBytesThreshold);
_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, vNodeSettings.ConnectionPendingSendBytesThreshold);
_mainBus.Subscribe <SystemMessage.SystemInit>(extSecTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(extSecTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(extSecTcpService);
}
if (!isSingleNode)
{
// INTERNAL TCP
if (!vNodeSettings.DisableInsecureTCP)
{
var intTcpService = new TcpService(_mainQueue, _nodeInfo.InternalTcp, _workersHandler,
TcpServiceType.Internal, TcpSecurityType.Normal,
new InternalTcpDispatcher(),
vNodeSettings.IntTcpHeartbeatInterval, vNodeSettings.IntTcpHeartbeatTimeout,
_internalAuthenticationProvider, null, ESConsts.UnrestrictedPendingSendBytes);
_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, ESConsts.UnrestrictedPendingSendBytes);
_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, _workersHandler);
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.GossipAdvertiseInfo.AdvertiseExternalIPAs,
vNodeSettings.GossipAdvertiseInfo.AdvertiseExternalHttpPortAs, 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.GossipAdvertiseInfo.AdvertiseInternalIPAs,
vNodeSettings.GossipAdvertiseInfo.AdvertiseInternalHttpPortAs, 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.PrepareTimeout,
vNodeSettings.CommitTimeout,
vNodeSettings.BetterOrdering);
_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.CommitReplicated>(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(perSubscrQueue, 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 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);
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);
if (!isSingleNode)
{
// MASTER REPLICATION
var masterReplicationService = new MasterReplicationService(_mainQueue, gossipInfo.InstanceId, db, _workersHandler,
epochManager, vNodeSettings.ClusterNodeCount);
AddTask(masterReplicationService.Task);
_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 || vNodeSettings.GossipOnSingleNode)
{
// 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);
}
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 = isSingleNode ? new [] { _externalHttpService } : new [] { _internalHttpService, _externalHttpService };
subsystem.Register(new StandardComponents(db, _mainQueue, _mainBus, _timerService, _timeProvider, httpSendService, http, _workersHandler));
}
}
}
public virtual void SetUp()
{
Consumer = new WaitingConsumer(0);
Queue = _queuedHandlerFactory(Consumer, "waiting_queue", TimeSpan.FromMilliseconds(5000));
}
public virtual void SetUp()
{
Consumer = new NoopConsumer();
Queue = _queuedHandlerFactory(Consumer, "test_name", TimeSpan.FromMilliseconds(5000));
}
public virtual void SetUp()
{
Consumer = new NoopConsumer();
Queue = _queuedHandlerFactory(Consumer, "test_name", TimeSpan.FromMilliseconds(5000));
}
