Ejemplo n.º 1
0
        private static ChildInitializer ChildInitializer(FileSystemAbstraction fileSystem, GraphDatabaseAPI graphDb)
        {
            ApplicationSupportedProtocols catchupProtocols  = new ApplicationSupportedProtocols(CATCHUP, emptyList());
            ModifierSupportedProtocols    modifierProtocols = new ModifierSupportedProtocols(COMPRESSION, emptyList());

            ApplicationProtocolRepository catchupRepository  = new ApplicationProtocolRepository(Protocol_ApplicationProtocols.values(), catchupProtocols);
            ModifierProtocolRepository    modifierRepository = new ModifierProtocolRepository(Protocol_ModifierProtocols.values(), singletonList(modifierProtocols));

            System.Func <CheckPointer>       checkPointer = () => graphDb.DependencyResolver.resolveDependency(typeof(CheckPointer));
            System.Func <bool>               availability = () => graphDb.DependencyResolver.resolveDependency(typeof(DatabaseAvailabilityGuard)).Available;
            System.Func <NeoStoreDataSource> dataSource   = () => graphDb.DependencyResolver.resolveDependency(typeof(NeoStoreDataSource));
            LogProvider logProvider = NullLogProvider.Instance;

            Org.Neo4j.Storageengine.Api.StoreId kernelStoreId = dataSource().StoreId;
            StoreId storeId = new StoreId(kernelStoreId.CreationTime, kernelStoreId.RandomId, kernelStoreId.UpgradeTime, kernelStoreId.UpgradeId);

            CheckPointerService         checkPointerService  = new CheckPointerService(checkPointer, createInitialisedScheduler(), Group.CHECKPOINT);
            RegularCatchupServerHandler catchupServerHandler = new RegularCatchupServerHandler(new Monitors(), logProvider, () => storeId, dataSource, availability, fileSystem, null, checkPointerService);

            NettyPipelineBuilderFactory pipelineBuilder = new NettyPipelineBuilderFactory(VoidPipelineWrapperFactory.VOID_WRAPPER);

            CatchupProtocolServerInstaller.Factory catchupProtocolServerInstaller = new CatchupProtocolServerInstaller.Factory(pipelineBuilder, logProvider, catchupServerHandler);

            ProtocolInstallerRepository <Org.Neo4j.causalclustering.protocol.ProtocolInstaller_Orientation_Server> protocolInstallerRepository = new ProtocolInstallerRepository <Org.Neo4j.causalclustering.protocol.ProtocolInstaller_Orientation_Server>(singletonList(catchupProtocolServerInstaller), Org.Neo4j.causalclustering.protocol.ModifierProtocolInstaller_Fields.AllServerInstallers);

            return(new HandshakeServerInitializer(catchupRepository, modifierRepository, protocolInstallerRepository, pipelineBuilder, logProvider));
        }
Ejemplo n.º 2
0
 internal StoreCopyRequestHandler(CatchupServerProtocol protocol, System.Func <NeoStoreDataSource> dataSource, CheckPointerService checkPointerService, StoreFileStreamingProtocol storeFileStreamingProtocol, FileSystemAbstraction fs, LogProvider logProvider)
 {
     this._protocol   = protocol;
     this._dataSource = dataSource;
     this._storeFileStreamingProtocol = storeFileStreamingProtocol;
     this._fs  = fs;
     this._log = logProvider.GetLog(typeof(StoreCopyRequestHandler));
     this._checkPointerService = checkPointerService;
 }
Ejemplo n.º 3
0
 public GetIndexSnapshotRequestHandler(CatchupServerProtocol protocol, System.Func <NeoStoreDataSource> dataSource, CheckPointerService checkPointerService, StoreFileStreamingProtocol storeFileStreamingProtocol, FileSystemAbstraction fs, LogProvider logProvider) : base(protocol, dataSource, checkPointerService, storeFileStreamingProtocol, fs, logProvider)
 {
 }
Ejemplo n.º 4
0
 internal static bool IsTransactionWithinReach(long transactionId, CheckPointerService checkPointerService)
 {
     return(checkPointerService.LastCheckPointedTransactionId() >= transactionId);
 }
Ejemplo n.º 5
0
 private void InitializeInstanceFields()
 {
     _checkPointer        = new FakeCheckPointer(this);
     _checkPointerService = new CheckPointerService(() => _checkPointer, _jobScheduler, Group.CHECKPOINT);
 }
Ejemplo n.º 6
0
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public EnterpriseReadReplicaEditionModule(final org.neo4j.graphdb.factory.module.PlatformModule platformModule, final org.neo4j.causalclustering.discovery.DiscoveryServiceFactory discoveryServiceFactory, org.neo4j.causalclustering.identity.MemberId myself)
        public EnterpriseReadReplicaEditionModule(PlatformModule platformModule, DiscoveryServiceFactory discoveryServiceFactory, MemberId myself)
        {
            LogService logging = platformModule.Logging;

            IoLimiterConflict = new ConfigurableIOLimiter(platformModule.Config);
            platformModule.JobScheduler.TopLevelGroupName = "ReadReplica " + myself;

            Dependencies          dependencies = platformModule.Dependencies;
            Config                config       = platformModule.Config;
            FileSystemAbstraction fileSystem   = platformModule.FileSystem;
            PageCache             pageCache    = platformModule.PageCache;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.io.layout.DatabaseLayout databaseLayout = platformModule.storeLayout.databaseLayout(config.get(org.neo4j.graphdb.factory.GraphDatabaseSettings.active_database));
            DatabaseLayout databaseLayout = platformModule.StoreLayout.databaseLayout(config.Get(GraphDatabaseSettings.active_database));

            LifeSupport life = platformModule.Life;

            ThreadToTransactionBridgeConflict = dependencies.SatisfyDependency(new ThreadToStatementContextBridge(GetGlobalAvailabilityGuard(platformModule.Clock, logging, platformModule.Config)));
            this.AccessCapabilityConflict     = new ReadOnly();

            WatcherServiceFactoryConflict = dir => CreateFileSystemWatcherService(fileSystem, dir, logging, platformModule.JobScheduler, config, FileWatcherFileNameFilter());
            dependencies.SatisfyDependencies(WatcherServiceFactoryConflict);

            ReadReplicaLockManager emptyLockManager = new ReadReplicaLockManager();

            LocksSupplierConflict = () => emptyLockManager;
            StatementLocksFactoryProviderConflict = locks => (new StatementLocksFactorySelector(locks, config, logging)).select();

            IdContextFactoryConflict = IdContextFactoryBuilder.of(new EnterpriseIdTypeConfigurationProvider(config), platformModule.JobScheduler).withFileSystem(fileSystem).build();

            TokenHoldersProviderConflict = databaseName => new TokenHolders(new DelegatingTokenHolder(new ReadOnlyTokenCreator(), Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_PROPERTY_KEY), new DelegatingTokenHolder(new ReadOnlyTokenCreator(), Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_LABEL), new DelegatingTokenHolder(new ReadOnlyTokenCreator(), Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_RELATIONSHIP_TYPE));

            File contextDirectory = platformModule.StoreLayout.storeDirectory();

            life.Add(dependencies.SatisfyDependency(new KernelData(fileSystem, pageCache, contextDirectory, config, platformModule.DataSourceManager)));

            HeaderInformationFactoryConflict = TransactionHeaderInformationFactory.DEFAULT;

            SchemaWriteGuardConflict = () =>
            {
            };

            TransactionStartTimeoutConflict = config.Get(GraphDatabaseSettings.transaction_start_timeout).toMillis();

            ConstraintSemanticsConflict = new EnterpriseConstraintSemantics();

            PublishEditionInfo(dependencies.ResolveDependency(typeof(UsageData)), platformModule.DatabaseInfo, config);
            CommitProcessFactoryConflict = ReadOnly();

            ConnectionTrackerConflict = dependencies.SatisfyDependency(CreateConnectionTracker());

            _logProvider = platformModule.Logging.InternalLogProvider;
            LogProvider userLogProvider = platformModule.Logging.UserLogProvider;

            _logProvider.getLog(this.GetType()).info(string.Format("Generated new id: {0}", myself));

            RemoteMembersResolver hostnameResolver = chooseResolver(config, platformModule.Logging);

            ConfigureDiscoveryService(discoveryServiceFactory, dependencies, config, _logProvider);

            _topologyService = discoveryServiceFactory.ReadReplicaTopologyService(config, _logProvider, platformModule.JobScheduler, myself, hostnameResolver, ResolveStrategy(config, _logProvider));

            life.Add(dependencies.SatisfyDependency(_topologyService));

            // We need to satisfy the dependency here to keep users of it, such as BoltKernelExtension, happy.
            dependencies.SatisfyDependency(SslPolicyLoader.create(config, _logProvider));

            DuplexPipelineWrapperFactory pipelineWrapperFactory = pipelineWrapperFactory();
            PipelineWrapper serverPipelineWrapper       = pipelineWrapperFactory.ForServer(config, dependencies, _logProvider, CausalClusteringSettings.ssl_policy);
            PipelineWrapper clientPipelineWrapper       = pipelineWrapperFactory.ForClient(config, dependencies, _logProvider, CausalClusteringSettings.ssl_policy);
            PipelineWrapper backupServerPipelineWrapper = pipelineWrapperFactory.ForServer(config, dependencies, _logProvider, OnlineBackupSettings.ssl_policy);

            NettyPipelineBuilderFactory clientPipelineBuilderFactory       = new NettyPipelineBuilderFactory(clientPipelineWrapper);
            NettyPipelineBuilderFactory serverPipelineBuilderFactory       = new NettyPipelineBuilderFactory(serverPipelineWrapper);
            NettyPipelineBuilderFactory backupServerPipelineBuilderFactory = new NettyPipelineBuilderFactory(backupServerPipelineWrapper);

            SupportedProtocolCreator                 supportedProtocolCreator   = new SupportedProtocolCreator(config, _logProvider);
            ApplicationSupportedProtocols            supportedCatchupProtocols  = supportedProtocolCreator.CreateSupportedCatchupProtocol();
            ICollection <ModifierSupportedProtocols> supportedModifierProtocols = supportedProtocolCreator.CreateSupportedModifierProtocols();

            ApplicationProtocolRepository applicationProtocolRepository = new ApplicationProtocolRepository(Protocol_ApplicationProtocols.values(), supportedCatchupProtocols);
            ModifierProtocolRepository    modifierProtocolRepository    = new ModifierProtocolRepository(Org.Neo4j.causalclustering.protocol.Protocol_ModifierProtocols.values(), supportedModifierProtocols);

            System.Func <CatchUpResponseHandler, ChannelInitializer <SocketChannel> > channelInitializer = handler =>
            {
                ProtocolInstallerRepository <ProtocolInstaller.Orientation.Client> protocolInstallerRepository = new ProtocolInstallerRepository <ProtocolInstaller.Orientation.Client>(singletonList(new CatchupProtocolClientInstaller.Factory(clientPipelineBuilderFactory, _logProvider, handler)), ModifierProtocolInstaller.allClientInstallers);
                Duration handshakeTimeout = config.Get(CausalClusteringSettings.handshake_timeout);
                return(new HandshakeClientInitializer(applicationProtocolRepository, modifierProtocolRepository, protocolInstallerRepository, clientPipelineBuilderFactory, handshakeTimeout, _logProvider, userLogProvider));
            };

            long inactivityTimeoutMs = config.Get(CausalClusteringSettings.catch_up_client_inactivity_timeout).toMillis();

            CatchUpClient catchUpClient = life.Add(new CatchUpClient(_logProvider, Clocks.systemClock(), inactivityTimeoutMs, channelInitializer));

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final System.Func<org.neo4j.kernel.internal.DatabaseHealth> databaseHealthSupplier = () -> platformModule.dataSourceManager.getDataSource().getDependencyResolver().resolveDependency(org.neo4j.kernel.internal.DatabaseHealth.class);
            System.Func <DatabaseHealth> databaseHealthSupplier = () => platformModule.DataSourceManager.DataSource.DependencyResolver.resolveDependency(typeof(DatabaseHealth));

            StoreFiles storeFiles = new StoreFiles(fileSystem, pageCache);
            LogFiles   logFiles   = BuildLocalDatabaseLogFiles(platformModule, fileSystem, databaseLayout, config);

            LocalDatabase localDatabase = new LocalDatabase(databaseLayout, storeFiles, logFiles, platformModule.DataSourceManager, databaseHealthSupplier, GetGlobalAvailabilityGuard(platformModule.Clock, platformModule.Logging, platformModule.Config), _logProvider);

            System.Func <TransactionCommitProcess> writableCommitProcess = () => new TransactionRepresentationCommitProcess(localDatabase.DataSource().DependencyResolver.resolveDependency(typeof(TransactionAppender)), localDatabase.DataSource().DependencyResolver.resolveDependency(typeof(StorageEngine)));

            LifeSupport txPulling    = new LifeSupport();
            int         maxBatchSize = config.Get(CausalClusteringSettings.read_replica_transaction_applier_batch_size);

            CommandIndexTracker commandIndexTracker = platformModule.Dependencies.satisfyDependency(new CommandIndexTracker());
            BatchingTxApplier   batchingTxApplier   = new BatchingTxApplier(maxBatchSize, () => localDatabase.DataSource().DependencyResolver.resolveDependency(typeof(TransactionIdStore)), writableCommitProcess, platformModule.Monitors, platformModule.Tracers.pageCursorTracerSupplier, platformModule.VersionContextSupplier, commandIndexTracker, _logProvider);

            TimerService timerService = new TimerService(platformModule.JobScheduler, _logProvider);

            ExponentialBackoffStrategy storeCopyBackoffStrategy = new ExponentialBackoffStrategy(1, config.Get(CausalClusteringSettings.store_copy_backoff_max_wait).toMillis(), TimeUnit.MILLISECONDS);

            RemoteStore remoteStore = new RemoteStore(platformModule.Logging.InternalLogProvider, fileSystem, platformModule.PageCache, new StoreCopyClient(catchUpClient, platformModule.Monitors, _logProvider, storeCopyBackoffStrategy), new TxPullClient(catchUpClient, platformModule.Monitors), new TransactionLogCatchUpFactory(), config, platformModule.Monitors);

            CopiedStoreRecovery copiedStoreRecovery = new CopiedStoreRecovery(config, platformModule.KernelExtensionFactories, platformModule.PageCache);

            txPulling.Add(copiedStoreRecovery);

            CompositeSuspendable servicesToStopOnStoreCopy = new CompositeSuspendable();

            StoreCopyProcess storeCopyProcess = new StoreCopyProcess(fileSystem, pageCache, localDatabase, copiedStoreRecovery, remoteStore, _logProvider);

            ConnectToRandomCoreServerStrategy defaultStrategy = new ConnectToRandomCoreServerStrategy();

            defaultStrategy.Inject(_topologyService, config, _logProvider, myself);

            UpstreamDatabaseStrategySelector upstreamDatabaseStrategySelector = CreateUpstreamDatabaseStrategySelector(myself, config, _logProvider, _topologyService, defaultStrategy);

            CatchupPollingProcess catchupProcess = new CatchupPollingProcess(_logProvider, localDatabase, servicesToStopOnStoreCopy, catchUpClient, upstreamDatabaseStrategySelector, timerService, config.Get(CausalClusteringSettings.pull_interval).toMillis(), batchingTxApplier, platformModule.Monitors, storeCopyProcess, databaseHealthSupplier, _topologyService);

            dependencies.SatisfyDependencies(catchupProcess);

            txPulling.Add(batchingTxApplier);
            txPulling.Add(catchupProcess);
            txPulling.Add(new WaitForUpToDateStore(catchupProcess, _logProvider));

            ExponentialBackoffStrategy retryStrategy = new ExponentialBackoffStrategy(1, 30, TimeUnit.SECONDS);

            life.Add(new ReadReplicaStartupProcess(remoteStore, localDatabase, txPulling, upstreamDatabaseStrategySelector, retryStrategy, _logProvider, platformModule.Logging.UserLogProvider, storeCopyProcess, _topologyService));

            CheckPointerService         checkPointerService  = new CheckPointerService(() => localDatabase.DataSource().DependencyResolver.resolveDependency(typeof(CheckPointer)), platformModule.JobScheduler, Group.CHECKPOINT);
            RegularCatchupServerHandler catchupServerHandler = new RegularCatchupServerHandler(platformModule.Monitors, _logProvider, localDatabase.storeId, localDatabase.dataSource, localDatabase.isAvailable, fileSystem, null, checkPointerService);

            InstalledProtocolHandler installedProtocolHandler = new InstalledProtocolHandler();               // TODO: hook into a procedure
            Server catchupServer = (new CatchupServerBuilder(catchupServerHandler)).serverHandler(installedProtocolHandler).catchupProtocols(supportedCatchupProtocols).modifierProtocols(supportedModifierProtocols).pipelineBuilder(serverPipelineBuilderFactory).userLogProvider(userLogProvider).debugLogProvider(_logProvider).listenAddress(config.Get(transaction_listen_address)).serverName("catchup-server").build();

            TransactionBackupServiceProvider transactionBackupServiceProvider = new TransactionBackupServiceProvider(_logProvider, userLogProvider, supportedCatchupProtocols, supportedModifierProtocols, backupServerPipelineBuilderFactory, catchupServerHandler, installedProtocolHandler);
            Optional <Server> backupCatchupServer = transactionBackupServiceProvider.ResolveIfBackupEnabled(config);

            servicesToStopOnStoreCopy.Add(catchupServer);
            backupCatchupServer.ifPresent(servicesToStopOnStoreCopy.add);

            life.Add(catchupServer);                 // must start last and stop first, since it handles external requests
            backupCatchupServer.ifPresent(life.add);
        }
Ejemplo n.º 7
0
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public CoreServerModule(org.neo4j.causalclustering.core.IdentityModule identityModule, final org.neo4j.graphdb.factory.module.PlatformModule platformModule, org.neo4j.causalclustering.core.consensus.ConsensusModule consensusModule, org.neo4j.causalclustering.core.state.machines.CoreStateMachinesModule coreStateMachinesModule, org.neo4j.causalclustering.core.state.ClusteringModule clusteringModule, org.neo4j.causalclustering.ReplicationModule replicationModule, org.neo4j.causalclustering.catchup.storecopy.LocalDatabase localDatabase, System.Func<org.neo4j.kernel.internal.DatabaseHealth> dbHealthSupplier, java.io.File clusterStateDirectory, org.neo4j.causalclustering.protocol.NettyPipelineBuilderFactory clientPipelineBuilderFactory, org.neo4j.causalclustering.protocol.NettyPipelineBuilderFactory serverPipelineBuilderFactory, org.neo4j.causalclustering.protocol.NettyPipelineBuilderFactory backupServerPipelineBuilderFactory, org.neo4j.causalclustering.net.InstalledProtocolHandler installedProtocolsHandler)
        public CoreServerModule(IdentityModule identityModule, PlatformModule platformModule, ConsensusModule consensusModule, CoreStateMachinesModule coreStateMachinesModule, ClusteringModule clusteringModule, ReplicationModule replicationModule, LocalDatabase localDatabase, System.Func <DatabaseHealth> dbHealthSupplier, File clusterStateDirectory, NettyPipelineBuilderFactory clientPipelineBuilderFactory, NettyPipelineBuilderFactory serverPipelineBuilderFactory, NettyPipelineBuilderFactory backupServerPipelineBuilderFactory, InstalledProtocolHandler installedProtocolsHandler)
        {
            this._identityModule          = identityModule;
            this._coreStateMachinesModule = coreStateMachinesModule;
            this._consensusModule         = consensusModule;
            this._clusteringModule        = clusteringModule;
            this._localDatabase           = localDatabase;
            this._dbHealthSupplier        = dbHealthSupplier;
            this._platformModule          = platformModule;

            this._config       = platformModule.Config;
            this._jobScheduler = platformModule.JobScheduler;

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.util.Dependencies dependencies = platformModule.dependencies;
            Dependencies dependencies = platformModule.Dependencies;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.logging.internal.LogService logging = platformModule.logging;
            LogService logging = platformModule.Logging;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.io.fs.FileSystemAbstraction fileSystem = platformModule.fileSystem;
            FileSystemAbstraction fileSystem = platformModule.FileSystem;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.lifecycle.LifeSupport life = platformModule.life;
            LifeSupport life = platformModule.Life;

            this._logProvider     = logging.InternalLogProvider;
            this._userLogProvider = logging.UserLogProvider;

            CompositeSuspendable servicesToStopOnStoreCopy = new CompositeSuspendable();

            StateStorage <long> lastFlushedStorage = platformModule.Life.add(new DurableStateStorage <long>(platformModule.FileSystem, clusterStateDirectory, LAST_FLUSHED_NAME, new LongIndexMarshal(), platformModule.Config.get(CausalClusteringSettings.last_flushed_state_size), _logProvider));

            consensusModule.RaftMembershipManager().RecoverFromIndexSupplier = lastFlushedStorage.getInitialState;

            CoreState coreState = new CoreState(coreStateMachinesModule.CoreStateMachines, replicationModule.SessionTracker, lastFlushedStorage);

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final System.Func<org.neo4j.kernel.internal.DatabaseHealth> databaseHealthSupplier = () -> platformModule.dataSourceManager.getDataSource().getDependencyResolver().resolveDependency(org.neo4j.kernel.internal.DatabaseHealth.class);
            System.Func <DatabaseHealth> databaseHealthSupplier = () => platformModule.DataSourceManager.DataSource.DependencyResolver.resolveDependency(typeof(DatabaseHealth));
            _commandApplicationProcess = new CommandApplicationProcess(consensusModule.RaftLog(), platformModule.Config.get(CausalClusteringSettings.state_machine_apply_max_batch_size), platformModule.Config.get(CausalClusteringSettings.state_machine_flush_window_size), databaseHealthSupplier, _logProvider, replicationModule.ProgressTracker, replicationModule.SessionTracker, coreState, consensusModule.InFlightCache(), platformModule.Monitors);

            platformModule.Dependencies.satisfyDependency(_commandApplicationProcess);                 // lastApplied() for CC-robustness

            this._snapshotService = new CoreSnapshotService(_commandApplicationProcess, coreState, consensusModule.RaftLog(), consensusModule.RaftMachine());

            CatchUpClient       catchUpClient = CreateCatchupClient(clientPipelineBuilderFactory);
            CoreStateDownloader downloader    = CreateCoreStateDownloader(servicesToStopOnStoreCopy, catchUpClient);

            this._downloadService = new CoreStateDownloaderService(platformModule.JobScheduler, downloader, _commandApplicationProcess, _logProvider, (new ExponentialBackoffStrategy(1, 30, SECONDS)).newTimeout(), databaseHealthSupplier, platformModule.Monitors);

            this.MembershipWaiterLifecycle = CreateMembershipWaiterLifecycle();

            SupportedProtocolCreator                 supportedProtocolCreator   = new SupportedProtocolCreator(_config, _logProvider);
            ApplicationSupportedProtocols            supportedCatchupProtocols  = supportedProtocolCreator.CreateSupportedCatchupProtocol();
            ICollection <ModifierSupportedProtocols> supportedModifierProtocols = supportedProtocolCreator.CreateSupportedModifierProtocols();

            CheckPointerService  checkPointerService  = new CheckPointerService(() => localDatabase.DataSource().DependencyResolver.resolveDependency(typeof(CheckPointer)), _jobScheduler, Group.CHECKPOINT);
            CatchupServerHandler catchupServerHandler = new RegularCatchupServerHandler(platformModule.Monitors, _logProvider, localDatabase.storeId, localDatabase.dataSource, localDatabase.isAvailable, fileSystem, _snapshotService, checkPointerService);

            _catchupServer = (new CatchupServerBuilder(catchupServerHandler)).serverHandler(installedProtocolsHandler).catchupProtocols(supportedCatchupProtocols).modifierProtocols(supportedModifierProtocols).pipelineBuilder(serverPipelineBuilderFactory).userLogProvider(_userLogProvider).debugLogProvider(_logProvider).listenAddress(_config.get(transaction_listen_address)).serverName("catchup-server").build();

            TransactionBackupServiceProvider transactionBackupServiceProvider = new TransactionBackupServiceProvider(_logProvider, _userLogProvider, supportedCatchupProtocols, supportedModifierProtocols, backupServerPipelineBuilderFactory, catchupServerHandler, installedProtocolsHandler);

            _backupServer = transactionBackupServiceProvider.ResolveIfBackupEnabled(_config);

            RaftLogPruner raftLogPruner = new RaftLogPruner(consensusModule.RaftMachine(), _commandApplicationProcess, platformModule.Clock);

            dependencies.SatisfyDependency(raftLogPruner);

            life.Add(new PruningScheduler(raftLogPruner, _jobScheduler, _config.get(CausalClusteringSettings.raft_log_pruning_frequency).toMillis(), _logProvider));

            servicesToStopOnStoreCopy.Add(this._catchupServer);
            _backupServer.ifPresent(servicesToStopOnStoreCopy.add);
        }