/// <summary>
/// Instantiate a graph database given configuration, dependencies, and a custom implementation of {@link org
/// .neo4j.kernel.impl.factory.GraphDatabaseFacade}.
/// </summary>
/// <param name="storeDir"> the directory where the Neo4j data store is located </param>
/// <param name="config"> configuration </param>
/// <param name="dependencies"> the dependencies required to construct the <seealso cref="GraphDatabaseFacade"/> </param>
/// <param name="graphDatabaseFacade"> the already created facade which needs initialisation </param>
/// <returns> the initialised <seealso cref="GraphDatabaseFacade"/> </returns>
//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 org.neo4j.kernel.impl.factory.GraphDatabaseFacade initFacade(java.io.File storeDir, org.neo4j.kernel.configuration.Config config, final Dependencies dependencies, final org.neo4j.kernel.impl.factory.GraphDatabaseFacade graphDatabaseFacade)
public virtual GraphDatabaseFacade InitFacade(File storeDir, Config config, Dependencies dependencies, GraphDatabaseFacade graphDatabaseFacade)
{
PlatformModule platform = CreatePlatform(storeDir, config, dependencies);
AbstractEditionModule edition = _editionFactory.apply(platform);
dependencies.AvailabilityGuardInstaller()(edition.GetGlobalAvailabilityGuard(platform.Clock, platform.Logging, platform.Config));
platform.Life.add(new VmPauseMonitorComponent(config, platform.Logging.getInternalLog(typeof(VmPauseMonitorComponent)), platform.JobScheduler));
Procedures procedures = SetupProcedures(platform, edition, graphDatabaseFacade);
platform.Dependencies.satisfyDependency(new NonTransactionalDbmsOperations(procedures));
Logger msgLog = platform.Logging.getInternalLog(this.GetType()).infoLogger();
DatabaseManager databaseManager = edition.CreateDatabaseManager(graphDatabaseFacade, platform, edition, procedures, msgLog);
platform.Life.add(databaseManager);
platform.Dependencies.satisfyDependency(databaseManager);
DataCollectorManager dataCollectorManager = new DataCollectorManager(platform.DataSourceManager, platform.JobScheduler, procedures, platform.Monitors, platform.Config);
platform.Life.add(dataCollectorManager);
edition.CreateSecurityModule(platform, procedures);
SecurityProvider securityProvider = edition.SecurityProvider;
platform.Dependencies.satisfyDependencies(securityProvider.AuthManager());
platform.Dependencies.satisfyDependencies(securityProvider.UserManagerSupplier());
platform.Life.add(platform.GlobalKernelExtensions);
platform.Life.add(CreateBoltServer(platform, edition, databaseManager));
platform.Dependencies.satisfyDependency(edition.GlobalTransactionCounter());
platform.Life.add(new PublishPageCacheTracerMetricsAfterStart(platform.Tracers.pageCursorTracerSupplier));
platform.Life.add(new StartupWaiter(edition.GetGlobalAvailabilityGuard(platform.Clock, platform.Logging, platform.Config), edition.TransactionStartTimeout));
platform.Dependencies.satisfyDependency(edition.SchemaWriteGuard);
platform.Life.Last = platform.EventHandlers;
edition.CreateDatabases(databaseManager, config);
string activeDatabase = config.Get(GraphDatabaseSettings.active_database);
GraphDatabaseFacade databaseFacade = databaseManager.GetDatabaseFacade(activeDatabase).orElseThrow(() => new System.InvalidOperationException(string.Format("Database {0} not found. Please check the logs for startup errors.", activeDatabase)));
Exception error = null;
try
{
platform.Life.start();
}
//JAVA TO C# CONVERTER WARNING: 'final' catch parameters are not available in C#:
//ORIGINAL LINE: catch (final Throwable throwable)
catch (Exception throwable)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
error = new Exception("Error starting " + this.GetType().FullName + ", " + platform.StoreLayout.storeDirectory(), throwable);
}
finally
{
if (error != null)
{
try
{
graphDatabaseFacade.Shutdown();
}
catch (Exception shutdownError)
{
error.addSuppressed(shutdownError);
}
}
}
if (error != null)
{
msgLog.Log("Failed to start database", error);
throw error;
}
return(databaseFacade);
}
//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);
}
