private LoadBalancingProcessor getLoadBalancingProcessor() { try { return LoadBalancingPluginLoader.load( topologyService, consensusModule.raftMachine(), logProvider, config ); } catch ( Throwable e ) { throw new RuntimeException( e ); } }
public boolean isLeader() { return consensusModule.raftMachine().currentRole() == Role.LEADER; }
public CoreLife createCoreLife( LifecycleMessageHandler<RaftMessages.ReceivedInstantClusterIdAwareMessage<?>> handler ) { return new CoreLife( consensusModule.raftMachine(), localDatabase, clusteringModule.clusterBinder(), commandApplicationProcess, coreStateMachinesModule.coreStateMachines, handler, snapshotService, downloadService ); }
private MembershipWaiterLifecycle createMembershipWaiterLifecycle() { long electionTimeout = config.get( CausalClusteringSettings.leader_election_timeout ).toMillis(); MembershipWaiter membershipWaiter = new MembershipWaiter( identityModule.myself(), jobScheduler, dbHealthSupplier, electionTimeout * 4, logProvider ); long joinCatchupTimeout = config.get( CausalClusteringSettings.join_catch_up_timeout ).toMillis(); return new MembershipWaiterLifecycle( membershipWaiter, joinCatchupTimeout, consensusModule.raftMachine(), logProvider ); }
private LifecycleMessageHandler<ReceivedInstantClusterIdAwareMessage<?>> createMessageHandlerChain( CoreServerModule coreServerModule ) { RaftMessageApplier messageApplier = new RaftMessageApplier( localDatabase, logProvider, consensusModule.raftMachine(), coreServerModule.downloadService(), coreServerModule.commandApplicationProcess(), catchupAddressProvider ); ComposableMessageHandler monitoringHandler = RaftMessageMonitoringHandler.composable( platformModule.clock, platformModule.monitors ); int queueSize = platformModule.config.get( CausalClusteringSettings.raft_in_queue_size ); int maxBatch = platformModule.config.get( CausalClusteringSettings.raft_in_queue_max_batch ); Function<Runnable, ContinuousJob> jobFactory = runnable -> new ContinuousJob( platformModule.jobScheduler.threadFactory( new JobScheduler.Group( "raft-batch-handler" ) ), runnable, logProvider ); ComposableMessageHandler batchingMessageHandler = BatchingMessageHandler.composable( queueSize, maxBatch, jobFactory, logProvider ); ComposableMessageHandler leaderAvailabilityHandler = LeaderAvailabilityHandler.composable( consensusModule.getLeaderAvailabilityTimers(), consensusModule.raftMachine()::term ); ComposableMessageHandler clusterBindingHandler = ClusterBindingHandler.composable( logProvider ); return clusterBindingHandler .compose( leaderAvailabilityHandler ) .compose( batchingMessageHandler ) .compose( monitoringHandler ) .apply( messageApplier ); } }
@Override public void registerEditionSpecificProcedures( Procedures procedures ) throws KernelException { procedures.registerProcedure( EnterpriseBuiltInDbmsProcedures.class, true ); procedures.registerProcedure( EnterpriseBuiltInProcedures.class, true ); procedures.register( new LegacyGetServersProcedure( topologyService, consensusModule.raftMachine(), config, logProvider ) ); if ( config.get( CausalClusteringSettings.multi_dc_license ) ) { procedures.register( new GetServersProcedureForMultiDC( getLoadBalancingProcessor() ) ); } else { procedures.register( new GetServersProcedureForSingleDC( topologyService, consensusModule.raftMachine(), config, logProvider ) ); } procedures.register( new GetRoutersForAllDatabasesProcedure( topologyService, config ) ); procedures.register( new GetRoutersForDatabaseProcedure( topologyService, config ) ); procedures.register( new ClusterOverviewProcedure( topologyService, logProvider ) ); procedures.register( new CoreRoleProcedure( consensusModule.raftMachine() ) ); procedures.register( new InstalledProtocolsProcedure( clientInstalledProtocols, serverInstalledProtocols ) ); procedures.registerComponent( Replicator.class, x -> replicationModule.getReplicator(), false ); procedures.registerProcedure( ReplicationBenchmarkProcedure.class ); }
long availabilityTimeoutMillis = config.get( CausalClusteringSettings.replication_retry_timeout_base ).toMillis(); replicator = new RaftReplicator( consensusModule.raftMachine(), myself, outbound,
clusterStateDirectory.get(), topologyService ); dependencies.satisfyDependency( consensusModule.raftMachine() ); consensusModule.raftMachine(), dependencies, localDatabase ); this.lockManager = coreStateMachinesModule.lockManager; this.commitProcessFactory = coreStateMachinesModule.commitProcessFactory; this.accessCapability = new LeaderCanWrite( consensusModule.raftMachine() ); new CatchupAddressProvider.PrioritisingUpstreamStrategyBasedAddressProvider( consensusModule.raftMachine(), topologyService, catchupStrategySelector ); RaftServerModule.createAndStart( platformModule, consensusModule, identityModule, coreServerModule, localDatabase, serverPipelineBuilderFactory,
this.snapshotService = new CoreSnapshotService( commandApplicationProcess, coreState, consensusModule.raftLog(), consensusModule.raftMachine() ); RaftLogPruner raftLogPruner = new RaftLogPruner( consensusModule.raftMachine(), commandApplicationProcess, platformModule.clock ); dependencies.satisfyDependency( raftLogPruner );