public ClassicCoreSPI(PlatformModule platform, DataSourceModule dataSource, Logger msgLog, CoreAPIAvailabilityGuard availability, ThreadToStatementContextBridge threadToTransactionBridge)
{
this._platform = platform;
this._dataSource = dataSource;
this._msgLog = msgLog;
this._availability = availability;
this._threadToTransactionBridge = threadToTransactionBridge;
}
///
/// <param name="platformModule"> </param>
/// <param name="discoveryServiceFactory"> </param>
/// <param name="clusterStateDirectory"> </param>
/// <param name="identityModule"> </param>
/// <param name="dependencies"> </param>
/// <param name="databaseLayout">
/// @return </param>
protected internal virtual ClusteringModule GetClusteringModule(PlatformModule platformModule, DiscoveryServiceFactory discoveryServiceFactory, ClusterStateDirectory clusterStateDirectory, IdentityModule identityModule, Dependencies dependencies, DatabaseLayout databaseLayout)
{
SslPolicyLoader sslPolicyFactory = ( SslPolicyLoader )dependencies.SatisfyDependency(SslPolicyLoader.create(this.Config, this.LogProvider));
SslPolicy sslPolicy = sslPolicyFactory.GetPolicy(( string )this.Config.get(CausalClusteringSettings.SslPolicy));
if (discoveryServiceFactory is SecureHazelcastDiscoveryServiceFactory)
{
(( SecureHazelcastDiscoveryServiceFactory )discoveryServiceFactory).SslPolicy = sslPolicy;
}
return(new ClusteringModule(discoveryServiceFactory, identityModule.Myself(), platformModule, clusterStateDirectory.Get(), databaseLayout));
}
public ReplicationModule(RaftMachine raftMachine, MemberId myself, PlatformModule platformModule, Config config, Outbound <MemberId, Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage> outbound, File clusterStateDirectory, FileSystemAbstraction fileSystem, LogProvider logProvider, AvailabilityGuard globalAvailabilityGuard, LocalDatabase localDatabase)
{
LifeSupport life = platformModule.Life;
DurableStateStorage <GlobalSessionTrackerState> sessionTrackerStorage;
sessionTrackerStorage = life.Add(new DurableStateStorage <>(fileSystem, clusterStateDirectory, SESSION_TRACKER_NAME, new GlobalSessionTrackerState.Marshal(new MemberId.Marshal()), config.Get(CausalClusteringSettings.global_session_tracker_state_size), logProvider));
_sessionTracker = new SessionTracker(sessionTrackerStorage);
GlobalSession myGlobalSession = new GlobalSession(System.Guid.randomUUID(), myself);
LocalSessionPool sessionPool = new LocalSessionPool(myGlobalSession);
_progressTracker = new ProgressTrackerImpl(myGlobalSession);
Duration initialBackoff = config.Get(CausalClusteringSettings.replication_retry_timeout_base);
Duration upperBoundBackoff = config.Get(CausalClusteringSettings.replication_retry_timeout_limit);
TimeoutStrategy progressRetryStrategy = new ExponentialBackoffStrategy(initialBackoff, upperBoundBackoff);
long availabilityTimeoutMillis = config.Get(CausalClusteringSettings.replication_retry_timeout_base).toMillis();
_replicator = new RaftReplicator(raftMachine, myself, outbound, sessionPool, _progressTracker, progressRetryStrategy, availabilityTimeoutMillis, globalAvailabilityGuard, logProvider, localDatabase, platformModule.Monitors);
}
public ClusteringModule(DiscoveryServiceFactory discoveryServiceFactory, MemberId myself, PlatformModule platformModule, File clusterStateDirectory, DatabaseLayout databaseLayout)
{
LifeSupport life = platformModule.Life;
Config config = platformModule.Config;
LogProvider logProvider = platformModule.Logging.InternalLogProvider;
LogProvider userLogProvider = platformModule.Logging.UserLogProvider;
Dependencies dependencies = platformModule.Dependencies;
Monitors monitors = platformModule.Monitors;
FileSystemAbstraction fileSystem = platformModule.FileSystem;
RemoteMembersResolver remoteMembersResolver = chooseResolver(config, platformModule.Logging);
_topologyService = discoveryServiceFactory.CoreTopologyService(config, myself, platformModule.JobScheduler, logProvider, userLogProvider, remoteMembersResolver, ResolveStrategy(config, logProvider), monitors);
life.Add(_topologyService);
dependencies.SatisfyDependency(_topologyService); // for tests
CoreBootstrapper coreBootstrapper = new CoreBootstrapper(databaseLayout, platformModule.PageCache, fileSystem, config, logProvider, platformModule.Monitors);
SimpleStorage <ClusterId> clusterIdStorage = new SimpleFileStorage <ClusterId>(fileSystem, clusterStateDirectory, CLUSTER_ID_NAME, new ClusterId.Marshal(), logProvider);
SimpleStorage <DatabaseName> dbNameStorage = new SimpleFileStorage <DatabaseName>(fileSystem, clusterStateDirectory, DB_NAME, new DatabaseName.Marshal(), logProvider);
string dbName = config.Get(CausalClusteringSettings.database);
int minimumCoreHosts = config.Get(CausalClusteringSettings.minimum_core_cluster_size_at_formation);
Duration clusterBindingTimeout = config.Get(CausalClusteringSettings.cluster_binding_timeout);
_clusterBinder = new ClusterBinder(clusterIdStorage, dbNameStorage, _topologyService, Clocks.systemClock(), () => sleep(100), clusterBindingTimeout, coreBootstrapper, dbName, minimumCoreHosts, platformModule.Monitors);
}
///
/// <param name="platformModule"> </param>
/// <param name="procedures"> </param>
public virtual void CreateSecurityModule(PlatformModule platformModule, Procedures procedures)
{
EnterpriseEditionModule.createEnterpriseSecurityModule(this, platformModule, procedures);
}
/// <param name="platformModule"> </param>
/// <param name="discoveryServiceFactory"> </param>
internal OpenEnterpriseCoreEditionModule(PlatformModule platformModule, DiscoveryServiceFactory discoveryServiceFactory) : base(platformModule, discoveryServiceFactory)
{
}
public OpenEnterpriseEditionModule(PlatformModule platformModule) : base(platformModule)
{
}
protected internal override IdContextFactory CreateIdContextFactory(PlatformModule platformModule, FileSystemAbstraction fileSystem)
{
return(IdContextFactoryBuilder.of(new EnterpriseIdTypeConfigurationProvider(platformModule.Config), platformModule.JobScheduler).withFileSystem(fileSystem).build());
}
public EnterpriseEditionModule(PlatformModule platformModule) : base(platformModule)
{
IoLimiterConflict = new ConfigurableIOLimiter(platformModule.Config);
}
public static void CreateEnterpriseSecurityModule(AbstractEditionModule editionModule, PlatformModule platformModule, Procedures procedures)
{
SecurityProvider securityProvider;
if (platformModule.Config.get(GraphDatabaseSettings.auth_enabled))
{
SecurityModule securityModule = SetupSecurityModule(platformModule, editionModule, platformModule.Logging.getUserLog(typeof(EnterpriseEditionModule)), procedures, platformModule.Config.get(EnterpriseEditionSettings.security_module));
platformModule.Life.add(securityModule);
securityProvider = securityModule;
}
else
{
EnterpriseNoAuthSecurityProvider provider = EnterpriseNoAuthSecurityProvider.INSTANCE;
platformModule.Life.add(provider);
securityProvider = provider;
}
editionModule.SecurityProvider = securityProvider;
}
public override void CreateSecurityModule(PlatformModule platformModule, Procedures procedures)
{
EnterpriseEditionModule.CreateEnterpriseSecurityModule(this, platformModule, procedures);
}
//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 ConsensusModule(org.neo4j.causalclustering.identity.MemberId myself, final org.neo4j.graphdb.factory.module.PlatformModule platformModule, org.neo4j.causalclustering.messaging.Outbound<org.neo4j.causalclustering.identity.MemberId,RaftMessages_RaftMessage> outbound, java.io.File clusterStateDirectory, org.neo4j.causalclustering.discovery.CoreTopologyService coreTopologyService)
public ConsensusModule(MemberId myself, PlatformModule platformModule, Outbound <MemberId, RaftMessages_RaftMessage> outbound, File clusterStateDirectory, CoreTopologyService coreTopologyService)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.configuration.Config config = platformModule.config;
Config config = platformModule.Config;
//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;
LogProvider logProvider = logging.InternalLogProvider;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.causalclustering.core.state.storage.SafeChannelMarshal<org.neo4j.causalclustering.core.replication.ReplicatedContent> marshal = org.neo4j.causalclustering.messaging.marshalling.CoreReplicatedContentMarshal.marshaller();
SafeChannelMarshal <ReplicatedContent> marshal = CoreReplicatedContentMarshal.marshaller();
RaftLog underlyingLog = CreateRaftLog(config, life, fileSystem, clusterStateDirectory, marshal, logProvider, platformModule.JobScheduler);
_raftLog = new MonitoredRaftLog(underlyingLog, platformModule.Monitors);
StateStorage <TermState> termState;
StateStorage <VoteState> voteState;
StateStorage <RaftMembershipState> raftMembershipStorage;
StateStorage <TermState> durableTermState = life.Add(new DurableStateStorage <TermState>(fileSystem, clusterStateDirectory, RAFT_TERM_NAME, new TermState.Marshal(), config.Get(CausalClusteringSettings.term_state_size), logProvider));
termState = new MonitoredTermStateStorage(durableTermState, platformModule.Monitors);
voteState = life.Add(new DurableStateStorage <>(fileSystem, clusterStateDirectory, RAFT_VOTE_NAME, new VoteState.Marshal(new MemberId.Marshal()), config.Get(CausalClusteringSettings.vote_state_size), logProvider));
raftMembershipStorage = life.Add(new DurableStateStorage <>(fileSystem, clusterStateDirectory, RAFT_MEMBERSHIP_NAME, new RaftMembershipState.Marshal(), config.Get(CausalClusteringSettings.raft_membership_state_size), logProvider));
TimerService timerService = new TimerService(platformModule.JobScheduler, logProvider);
_leaderAvailabilityTimers = CreateElectionTiming(config, timerService, logProvider);
int?minimumConsensusGroupSize = config.Get(CausalClusteringSettings.minimum_core_cluster_size_at_runtime);
MemberIdSetBuilder memberSetBuilder = new MemberIdSetBuilder();
SendToMyself leaderOnlyReplicator = new SendToMyself(myself, outbound);
_raftMembershipManager = new RaftMembershipManager(leaderOnlyReplicator, memberSetBuilder, _raftLog, logProvider, minimumConsensusGroupSize.Value, _leaderAvailabilityTimers.ElectionTimeout, systemClock(), config.Get(join_catch_up_timeout).toMillis(), raftMembershipStorage);
platformModule.Dependencies.satisfyDependency(_raftMembershipManager);
life.Add(_raftMembershipManager);
_inFlightCache = InFlightCacheFactory.create(config, platformModule.Monitors);
RaftLogShippingManager logShipping = new RaftLogShippingManager(outbound, logProvider, _raftLog, timerService, systemClock(), myself, _raftMembershipManager, _leaderAvailabilityTimers.ElectionTimeout, config.Get(catchup_batch_size), config.Get(log_shipping_max_lag), _inFlightCache);
bool supportsPreVoting = config.Get(CausalClusteringSettings.enable_pre_voting);
_raftMachine = new RaftMachine(myself, termState, voteState, _raftLog, _leaderAvailabilityTimers, outbound, logProvider, _raftMembershipManager, logShipping, _inFlightCache, config.Get(refuse_to_be_leader), supportsPreVoting, platformModule.Monitors);
DurationSinceLastMessageMonitor durationSinceLastMessageMonitor = new DurationSinceLastMessageMonitor();
platformModule.Monitors.addMonitorListener(durationSinceLastMessageMonitor);
platformModule.Dependencies.satisfyDependency(durationSinceLastMessageMonitor);
string dbName = config.Get(CausalClusteringSettings.database);
life.Add(new RaftCoreTopologyConnector(coreTopologyService, _raftMachine, dbName));
life.Add(logShipping);
}
/// <param name="platformModule"> </param>
/// <param name="discoveryServiceFactory"> </param>
/// <param name="myself"> </param>
internal OpenEnterpriseReadReplicaEditionModule(PlatformModule platformModule, DiscoveryServiceFactory discoveryServiceFactory, MemberId myself) : base(platformModule, discoveryServiceFactory, myself)
{
}
