public static SslPolicy MakeSslPolicy(SslResource sslResource, SslProvider sslProvider, string protocols, string ciphers)
{
IDictionary <string, string> config = new Dictionary <string, string>();
config[SslSystemSettings.netty_ssl_provider.name()] = sslProvider.name();
SslPolicyConfig policyConfig = new SslPolicyConfig("default");
File baseDirectory = sslResource.PrivateKey().ParentFile;
(new File(baseDirectory, "trusted")).mkdirs();
(new File(baseDirectory, "revoked")).mkdirs();
config[policyConfig.BaseDirectory.name()] = baseDirectory.Path;
config[policyConfig.PrivateKey.name()] = sslResource.PrivateKey().Path;
config[policyConfig.PublicCertificate.name()] = sslResource.PublicCertificate().Path;
config[policyConfig.TrustedDir.name()] = sslResource.TrustedDirectory().Path;
config[policyConfig.RevokedDir.name()] = sslResource.RevokedDirectory().Path;
config[policyConfig.VerifyHostname.name()] = "false";
if (!string.ReferenceEquals(protocols, null))
{
config[policyConfig.TlsVersions.name()] = protocols;
}
if (!string.ReferenceEquals(ciphers, null))
{
config[policyConfig.Ciphers.name()] = ciphers;
}
SslPolicyLoader sslPolicyFactory = SslPolicyLoader.create(Config.fromSettings(config).build(), NullLogProvider.Instance);
return(sslPolicyFactory.GetPolicy("default"));
}
private static SslContext CreateSslContext(SslPolicyLoader sslPolicyFactory, Config config)
{
try
{
string policyName = config.Get(GraphDatabaseSettings.bolt_ssl_policy);
if (string.ReferenceEquals(policyName, null))
{
throw new System.ArgumentException("No SSL policy has been configured for Bolt server");
}
return(sslPolicyFactory.GetPolicy(policyName).nettyServerContext());
}
catch (Exception e)
{
throw new Exception("Failed to initialize SSL encryption support, which is required to start this connector. " + "Error was: " + e.Message, e);
}
}
private NettyServer.ProtocolInitializer CreateProtocolInitializer(BoltConnector connector, BoltProtocolFactory boltProtocolFactory, TransportThrottleGroup throttleGroup, Log log)
{
SslContext sslCtx;
bool requireEncryption;
BoltConnector.EncryptionLevel encryptionLevel = _config.get(connector.EncryptionLevel);
SslPolicyLoader sslPolicyLoader = _dependencyResolver.resolveDependency(typeof(SslPolicyLoader));
switch (encryptionLevel)
{
case BoltConnector.EncryptionLevel.REQUIRED:
// Encrypted connections are mandatory, a self-signed certificate may be generated.
requireEncryption = true;
sslCtx = CreateSslContext(sslPolicyLoader, _config);
break;
case BoltConnector.EncryptionLevel.OPTIONAL:
// Encrypted connections are optional, a self-signed certificate may be generated.
requireEncryption = false;
sslCtx = CreateSslContext(sslPolicyLoader, _config);
break;
case BoltConnector.EncryptionLevel.DISABLED:
// Encryption is turned off, no self-signed certificate will be generated.
requireEncryption = false;
sslCtx = null;
break;
default:
// In the unlikely event that we happen to fall through to the default option here,
// there is a mismatch between the BoltConnector.EncryptionLevel enum and the options
// handled in this switch statement. In this case, we'll log a warning and default to
// disabling encryption, since this mirrors the functionality introduced in 3.0.
log.Warn("Unhandled encryption level %s - assuming DISABLED.", encryptionLevel.name());
requireEncryption = false;
sslCtx = null;
break;
}
ListenSocketAddress listenAddress = _config.get(connector.ListenAddress);
return(new SocketTransport(connector.Key(), listenAddress, sslCtx, requireEncryption, _logService.InternalLogProvider, throttleGroup, boltProtocolFactory, _connectionTracker));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = 120_000) public void shouldBeAbleToStartAndStoreWithoutSuccessfulJoin()
public virtual void ShouldBeAbleToStartAndStoreWithoutSuccessfulJoin()
{
// given
IDictionary <string, string> @params = stringMap();
SslPolicyConfig policyConfig = new SslPolicyConfig("default");
@params[neo4j_home.name()] = _home.AbsolutePath;
@params[policyConfig.BaseDirectory.name()] = "certificates/default";
JobScheduler jobScheduler = JobSchedulerFactory.createInitialisedScheduler();
PlatformModule platformModule = new PlatformModule(TestDirectory.storeDir(), Config.defaults(), ENTERPRISE, newDependencies());
AbstractEditionModule editionModule = new EnterpriseEditionModule(platformModule);
// Random members that does not exists, discovery will never succeed
string initialHosts = "localhost:" + PortAuthority.allocatePort() + ",localhost:" + PortAuthority.allocatePort();
Config config = config();
config.augment(initial_discovery_members, initialHosts);
// Setup SslPolicy
config.augment(neo4j_home.name(), _home.AbsolutePath);
config.Augment(policyConfig.BaseDirectory.name(), "certificates/default");
SslPolicyLoader sslPolicyLoader = SslPolicyLoader.create(config, NullLogProvider.Instance);
RemoteMembersResolver remoteMembersResolver = ResolutionResolverFactory.ChooseResolver(config, platformModule.Logging);
// then
SslPolicy sslPolicy = sslPolicyLoader.GetPolicy("default");
Monitors monitors = new Monitors();
SecureHazelcastCoreTopologyService service = new SecureHazelcastCoreTopologyService(config, sslPolicy, new MemberId(System.Guid.randomUUID()), jobScheduler, NullLogProvider.Instance, NullLogProvider.Instance, remoteMembersResolver, new TopologyServiceNoRetriesStrategy(), monitors);
try
{
service.Init();
service.Start();
service.Stop();
}
catch (Exception)
{
fail("Caught an Exception");
}
}
//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);
}
//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 EnterpriseCoreEditionModule(final org.neo4j.graphdb.factory.module.PlatformModule platformModule, final org.neo4j.causalclustering.discovery.DiscoveryServiceFactory discoveryServiceFactory)
public EnterpriseCoreEditionModule(PlatformModule platformModule, DiscoveryServiceFactory discoveryServiceFactory)
{
//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;
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.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));
//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;
CoreMonitor.register(logging.InternalLogProvider, logging.UserLogProvider, platformModule.Monitors);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.File dataDir = config.get(org.neo4j.graphdb.factory.GraphDatabaseSettings.data_directory);
File dataDir = Config.get(GraphDatabaseSettings.data_directory);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.causalclustering.core.state.ClusterStateDirectory clusterStateDirectory = new org.neo4j.causalclustering.core.state.ClusterStateDirectory(dataDir, databaseLayout.databaseDirectory(), false);
ClusterStateDirectory clusterStateDirectory = new ClusterStateDirectory(dataDir, databaseLayout.DatabaseDirectory(), false);
try
{
clusterStateDirectory.Initialize(fileSystem);
}
catch (ClusterStateException e)
{
throw new Exception(e);
}
dependencies.SatisfyDependency(clusterStateDirectory);
AvailabilityGuard globalGuard = GetGlobalAvailabilityGuard(platformModule.Clock, logging, platformModule.Config);
ThreadToTransactionBridgeConflict = dependencies.SatisfyDependency(new ThreadToStatementContextBridge(globalGuard));
LogProvider = logging.InternalLogProvider;
//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));
WatcherServiceFactoryConflict = directory => CreateFileSystemWatcherService(fileSystem, directory, logging, platformModule.JobScheduler, Config, FileWatcherFileNameFilter());
dependencies.SatisfyDependencies(WatcherServiceFactoryConflict);
LogFiles logFiles = BuildLocalDatabaseLogFiles(platformModule, fileSystem, databaseLayout);
LocalDatabase localDatabase = new LocalDatabase(databaseLayout, new StoreFiles(fileSystem, platformModule.PageCache), logFiles, platformModule.DataSourceManager, databaseHealthSupplier, globalGuard, LogProvider);
IdentityModule identityModule = new IdentityModule(platformModule, clusterStateDirectory.Get());
ClusteringModule clusteringModule = GetClusteringModule(platformModule, discoveryServiceFactory, clusterStateDirectory, identityModule, dependencies, databaseLayout);
// We need to satisfy the dependency here to keep users of it, such as BoltKernelExtension, happy.
dependencies.SatisfyDependency(SslPolicyLoader.create(Config, LogProvider));
PipelineWrapper clientPipelineWrapper = PipelineWrapperFactory().forClient(Config, dependencies, LogProvider, CausalClusteringSettings.SslPolicy);
PipelineWrapper serverPipelineWrapper = PipelineWrapperFactory().forServer(Config, dependencies, LogProvider, CausalClusteringSettings.SslPolicy);
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);
_topologyService = clusteringModule.TopologyService();
long logThresholdMillis = Config.get(CausalClusteringSettings.UnknownAddressLoggingThrottle).toMillis();
SupportedProtocolCreator supportedProtocolCreator = new SupportedProtocolCreator(Config, LogProvider);
ApplicationSupportedProtocols supportedRaftProtocols = supportedProtocolCreator.CreateSupportedRaftProtocol();
ICollection <ModifierSupportedProtocols> supportedModifierProtocols = supportedProtocolCreator.CreateSupportedModifierProtocols();
ApplicationProtocolRepository applicationProtocolRepository = new ApplicationProtocolRepository(Org.Neo4j.causalclustering.protocol.Protocol_ApplicationProtocols.values(), supportedRaftProtocols);
ModifierProtocolRepository modifierProtocolRepository = new ModifierProtocolRepository(Org.Neo4j.causalclustering.protocol.Protocol_ModifierProtocols.values(), supportedModifierProtocols);
ProtocolInstallerRepository <Org.Neo4j.causalclustering.protocol.ProtocolInstaller_Orientation_Client> protocolInstallerRepository = new ProtocolInstallerRepository <Org.Neo4j.causalclustering.protocol.ProtocolInstaller_Orientation_Client>(asList(new RaftProtocolClientInstallerV2.Factory(clientPipelineBuilderFactory, LogProvider), new RaftProtocolClientInstallerV1.Factory(clientPipelineBuilderFactory, LogProvider)), Org.Neo4j.causalclustering.protocol.ModifierProtocolInstaller_Fields.AllClientInstallers);
Duration handshakeTimeout = Config.get(CausalClusteringSettings.HandshakeTimeout);
HandshakeClientInitializer channelInitializer = new HandshakeClientInitializer(applicationProtocolRepository, modifierProtocolRepository, protocolInstallerRepository, clientPipelineBuilderFactory, handshakeTimeout, LogProvider, platformModule.Logging.UserLogProvider);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.causalclustering.messaging.SenderService raftSender = new org.neo4j.causalclustering.messaging.SenderService(channelInitializer, logProvider);
SenderService raftSender = new SenderService(channelInitializer, LogProvider);
life.Add(raftSender);
this._clientInstalledProtocols = raftSender.installedProtocols;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.causalclustering.logging.MessageLogger<org.neo4j.causalclustering.identity.MemberId> messageLogger = createMessageLogger(config, life, identityModule.myself());
MessageLogger <MemberId> messageLogger = CreateMessageLogger(Config, life, identityModule.Myself());
RaftOutbound raftOutbound = new RaftOutbound(_topologyService, raftSender, clusteringModule.ClusterIdentity(), LogProvider, logThresholdMillis);
Outbound <MemberId, Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage> loggingOutbound = new LoggingOutbound <MemberId, Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage>(raftOutbound, identityModule.Myself(), messageLogger);
_consensusModule = new ConsensusModule(identityModule.Myself(), platformModule, loggingOutbound, clusterStateDirectory.Get(), _topologyService);
dependencies.SatisfyDependency(_consensusModule.raftMachine());
_replicationModule = new ReplicationModule(_consensusModule.raftMachine(), identityModule.Myself(), platformModule, Config, loggingOutbound, clusterStateDirectory.Get(), fileSystem, LogProvider, globalGuard, localDatabase);
_coreStateMachinesModule = new CoreStateMachinesModule(identityModule.Myself(), platformModule, clusterStateDirectory.Get(), Config, _replicationModule.Replicator, _consensusModule.raftMachine(), dependencies, localDatabase);
IdContextFactoryConflict = IdContextFactoryBuilder.of(_coreStateMachinesModule.idTypeConfigurationProvider, platformModule.JobScheduler).withIdGenerationFactoryProvider(ignored => _coreStateMachinesModule.idGeneratorFactory).withFactoryWrapper(generator => new FreeIdFilteredIdGeneratorFactory(generator, _coreStateMachinesModule.freeIdCondition)).build();
// TODO: this is broken, coreStateMachinesModule.tokenHolders should be supplier, somehow...
this.TokenHoldersProviderConflict = databaseName => _coreStateMachinesModule.tokenHolders;
this.LocksSupplierConflict = _coreStateMachinesModule.locksSupplier;
this.CommitProcessFactoryConflict = _coreStateMachinesModule.commitProcessFactory;
this.AccessCapabilityConflict = new LeaderCanWrite(_consensusModule.raftMachine());
InstalledProtocolHandler serverInstalledProtocolHandler = new InstalledProtocolHandler();
this._coreServerModule = new CoreServerModule(identityModule, platformModule, _consensusModule, _coreStateMachinesModule, clusteringModule, _replicationModule, localDatabase, databaseHealthSupplier, clusterStateDirectory.Get(), clientPipelineBuilderFactory, serverPipelineBuilderFactory, backupServerPipelineBuilderFactory, serverInstalledProtocolHandler);
TypicallyConnectToRandomReadReplicaStrategy defaultStrategy = new TypicallyConnectToRandomReadReplicaStrategy(2);
defaultStrategy.Inject(_topologyService, Config, LogProvider, identityModule.Myself());
UpstreamDatabaseStrategySelector catchupStrategySelector = CreateUpstreamDatabaseStrategySelector(identityModule.Myself(), Config, LogProvider, _topologyService, defaultStrategy);
Org.Neo4j.causalclustering.catchup.CatchupAddressProvider_PrioritisingUpstreamStrategyBasedAddressProvider catchupAddressProvider = new Org.Neo4j.causalclustering.catchup.CatchupAddressProvider_PrioritisingUpstreamStrategyBasedAddressProvider(_consensusModule.raftMachine(), _topologyService, catchupStrategySelector);
RaftServerModule.CreateAndStart(platformModule, _consensusModule, identityModule, _coreServerModule, localDatabase, serverPipelineBuilderFactory, messageLogger, catchupAddressProvider, supportedRaftProtocols, supportedModifierProtocols, serverInstalledProtocolHandler);
_serverInstalledProtocols = serverInstalledProtocolHandler.installedProtocols;
EditionInvariants(platformModule, dependencies, Config, logging, life);
life.Add(_coreServerModule.membershipWaiterLifecycle);
}
