static ComposableMessageHandler composable( int queueSize, int maxBatch, Function<Runnable,ContinuousJob> jobSchedulerFactory, LogProvider logProvider ) { return delegate -> new BatchingMessageHandler( delegate, queueSize, maxBatch, jobSchedulerFactory, logProvider ); } @Override
static void createAndStart( PlatformModule platformModule, ConsensusModule consensusModule, IdentityModule identityModule, CoreServerModule coreServerModule, LocalDatabase localDatabase, NettyPipelineBuilderFactory pipelineBuilderFactory, MessageLogger<MemberId> messageLogger, CatchupAddressProvider.PrioritisingUpstreamStrategyBasedAddressProvider addressProvider, ApplicationSupportedProtocols supportedApplicationProtocol, Collection<ModifierSupportedProtocols> supportedModifierProtocols, ChannelInboundHandler installedProtocolsHandler ) { new RaftServerModule( platformModule, consensusModule, identityModule, coreServerModule, localDatabase, pipelineBuilderFactory, messageLogger, addressProvider, supportedApplicationProtocol, supportedModifierProtocols, installedProtocolsHandler ); }
public void disableCatchupServer() throws Throwable { ((EnterpriseCoreEditionModule) editionModule).disableCatchupServer(); } }
protected ClusteringModule getClusteringModule( PlatformModule platformModule, DiscoveryServiceFactory discoveryServiceFactory, ClusterStateDirectory clusterStateDirectory, IdentityModule identityModule, Dependencies dependencies ) { return new ClusteringModule( discoveryServiceFactory, identityModule.myself(), platformModule, clusterStateDirectory.get() ); }
private CatchUpClient createCatchupClient( NettyPipelineBuilderFactory clientPipelineBuilderFactory ) { SupportedProtocolCreator supportedProtocolCreator = new SupportedProtocolCreator( config, logProvider ); ApplicationSupportedProtocols supportedCatchupProtocols = supportedProtocolCreator.createSupportedCatchupProtocol(); Collection<ModifierSupportedProtocols> supportedModifierProtocols = supportedProtocolCreator.createSupportedModifierProtocols(); Duration handshakeTimeout = config.get( CausalClusteringSettings.handshake_timeout ); long inactivityTimeoutMillis = platformModule.config.get( CausalClusteringSettings.catch_up_client_inactivity_timeout ).toMillis(); CatchUpClient catchUpClient = new CatchupClientBuilder( supportedCatchupProtocols, supportedModifierProtocols, clientPipelineBuilderFactory, handshakeTimeout, inactivityTimeoutMillis, logProvider, systemClock() ).build(); platformModule.life.add( catchUpClient ); return catchUpClient; }
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 ); }
public Role getRole() { return getDependencyResolver().resolveDependency( RaftMachine.class ).currentRole(); }
private RaftServerModule( PlatformModule platformModule, ConsensusModule consensusModule, IdentityModule identityModule, CoreServerModule coreServerModule, LocalDatabase localDatabase, NettyPipelineBuilderFactory pipelineBuilderFactory, MessageLogger<MemberId> messageLogger, CatchupAddressProvider.PrioritisingUpstreamStrategyBasedAddressProvider catchupAddressProvider, ApplicationSupportedProtocols supportedApplicationProtocol, Collection<ModifierSupportedProtocols> supportedModifierProtocols, ChannelInboundHandler installedProtocolsHandler ) { this.platformModule = platformModule; this.consensusModule = consensusModule; this.identityModule = identityModule; this.supportedApplicationProtocol = supportedApplicationProtocol; this.localDatabase = localDatabase; this.messageLogger = messageLogger; this.logProvider = platformModule.logging.getInternalLogProvider(); this.pipelineBuilderFactory = pipelineBuilderFactory; this.catchupAddressProvider = catchupAddressProvider; this.supportedModifierProtocols = supportedModifierProtocols; LifecycleMessageHandler<ReceivedInstantClusterIdAwareMessage<?>> messageHandlerChain = createMessageHandlerChain( coreServerModule ); createRaftServer( coreServerModule, messageHandlerChain, installedProtocolsHandler ); }
public ApplicationSupportedProtocols createSupportedRaftProtocol() { return getApplicationSupportedProtocols( config.get( CausalClusteringSettings.raft_implementations ), RAFT ); }
public static ComposableMessageHandler composable( LogProvider logProvider ) { return delegate -> new ClusterBindingHandler( delegate, logProvider ); }
public static HostnameResolver chooseResolver( Config config, LogProvider logProvider, LogProvider userLogProvider ) { CausalClusteringSettings.DiscoveryType discoveryType = config.get( CausalClusteringSettings.discovery_type ); return discoveryType.getHostnameResolver( logProvider, userLogProvider ); } }
@Override public Response writable() { return db.getRole() == Role.LEADER ? positiveResponse() : negativeResponse(); } }
public CoreGraphDatabase( File storeDir, Config config, GraphDatabaseFacadeFactory.Dependencies dependencies, DiscoveryServiceFactory discoveryServiceFactory ) { Function<PlatformModule,EditionModule> factory = platformModule -> new EnterpriseCoreEditionModule( platformModule, discoveryServiceFactory ); new GraphDatabaseFacadeFactory( DatabaseInfo.CORE, factory ).initFacade( storeDir, config, dependencies, this ); }
public List<ModifierSupportedProtocols> createSupportedModifierProtocols() { ModifierSupportedProtocols supportedCompression = compressionProtocolVersions(); return Stream.of( supportedCompression ) .filter( supportedProtocols -> !supportedProtocols.versions().isEmpty() ) .collect( Collectors.toList() ); }
public CommercialCoreGraphDatabase( File storeDir, Config config, GraphDatabaseFacadeFactory.Dependencies dependencies, DiscoveryServiceFactory discoveryServiceFactory ) { Function<PlatformModule,EditionModule> factory = ( platformModule ) -> new CommercialCoreEditionModule( platformModule, discoveryServiceFactory ); new GraphDatabaseFacadeFactory( DatabaseInfo.CORE, factory ).initFacade( storeDir, config, dependencies, this ); } }
private <IMPL extends Comparable<IMPL>, T extends Protocol<IMPL>> List<IMPL> protocolsForConfig( Protocol.Category<T> category, List<IMPL> implementations, Function<IMPL,Optional<T>> finder ) { return implementations.stream() .map( impl -> Pair.of( impl, finder.apply( impl ) ) ) .peek( protocolWithImplementation -> logUnknownProtocol( category, protocolWithImplementation ) ) .map( Pair::other ) .flatMap( Streams::ofOptional ) .map( Protocol::implementation ) .collect( Collectors.toList() ); }
private void registerRecovery( final DatabaseInfo databaseInfo, LifeSupport life, final DependencyResolver dependencyResolver ) { life.addLifecycleListener( ( instance, from, to ) -> { if ( instance instanceof DatabaseAvailability && LifecycleStatus.STARTED.equals( to ) ) { doAfterRecoveryAndStartup( databaseInfo, dependencyResolver ); } } ); }
private ModifierSupportedProtocols compressionProtocolVersions() { List<String> implementations = protocolsForConfig( COMPRESSION, config.get( CausalClusteringSettings.compression_implementations ), implementation -> Protocol.ModifierProtocols.find( COMPRESSION, implementation ) ); return new ModifierSupportedProtocols( COMPRESSION, implementations ); }
public ApplicationSupportedProtocols createSupportedCatchupProtocol() { return getApplicationSupportedProtocols( config.get( CausalClusteringSettings.catchup_implementations ), CATCHUP ); }