public DefaultDatabaseManager(PlatformModule platform, AbstractEditionModule edition, Procedures procedures, Logger log, GraphDatabaseFacade graphDatabaseFacade)
{
this._platform = platform;
this._edition = edition;
this._procedures = procedures;
this._log = log;
this._graphDatabaseFacade = graphDatabaseFacade;
}
private static Procedures SetupProcedures(PlatformModule platform, AbstractEditionModule editionModule, GraphDatabaseFacade facade)
{
File pluginDir = platform.Config.get(GraphDatabaseSettings.plugin_dir);
Log internalLog = platform.Logging.getInternalLog(typeof(Procedures));
ProcedureConfig procedureConfig = new ProcedureConfig(platform.Config);
Procedures procedures = new Procedures(facade, new SpecialBuiltInProcedures(Version.Neo4jVersion, platform.DatabaseInfo.edition.ToString()), pluginDir, internalLog, procedureConfig);
platform.Life.add(procedures);
platform.Dependencies.satisfyDependency(procedures);
procedures.RegisterType(typeof(Node), NTNode);
procedures.RegisterType(typeof(Relationship), NTRelationship);
procedures.RegisterType(typeof(Path), NTPath);
procedures.RegisterType(typeof(Geometry), NTGeometry);
procedures.RegisterType(typeof(Point), NTPoint);
// Register injected public API components
Log proceduresLog = platform.Logging.getUserLog(typeof(Procedures));
procedures.RegisterComponent(typeof(Log), ctx => proceduresLog, true);
procedures.RegisterComponent(typeof(ProcedureTransaction), new ProcedureTransactionProvider(), true);
procedures.RegisterComponent(typeof(Org.Neo4j.Procedure.TerminationGuard), new TerminationGuardProvider(), true);
// Below components are not public API, but are made available for internal
// procedures to call, and to provide temporary workarounds for the following
// patterns:
// - Batch-transaction imports (GDAPI, needs to be real and passed to background processing threads)
// - Group-transaction writes (same pattern as above, but rather than splitting large transactions,
// combine lots of small ones)
// - Bleeding-edge performance (KernelTransaction, to bypass overhead of working with Core API)
procedures.RegisterComponent(typeof(DependencyResolver), ctx => ctx.get(DEPENDENCY_RESOLVER), false);
procedures.RegisterComponent(typeof(KernelTransaction), ctx => ctx.get(KERNEL_TRANSACTION), false);
procedures.RegisterComponent(typeof(GraphDatabaseAPI), ctx => ctx.get(DATABASE_API), false);
// Security procedures
procedures.RegisterComponent(typeof(SecurityContext), ctx => ctx.get(SECURITY_CONTEXT), true);
procedures.RegisterComponent(typeof(ProcedureCallContext), ctx => ctx.get(PROCEDURE_CALL_CONTEXT), true);
// Edition procedures
try
{
editionModule.RegisterProcedures(procedures, procedureConfig);
}
catch (KernelException e)
{
internalLog.Error("Failed to register built-in edition procedures at start up: " + e.Message);
}
return(procedures);
}
public DefaultEditionModuleDatabaseContext(DefaultEditionModule editionModule, string databaseName)
{
this._databaseName = databaseName;
this._transactionStartTimeout = editionModule.TransactionStartTimeout;
this._schemaWriteGuard = editionModule.SchemaWriteGuard;
this._headerInformationFactory = editionModule.HeaderInformationFactory;
this._commitProcessFactory = editionModule.CommitProcessFactory;
this._constraintSemantics = editionModule.ConstraintSemantics;
this._ioLimiter = editionModule.IoLimiter;
this._accessCapability = editionModule.AccessCapability;
this._watcherServiceFactory = editionModule.WatcherServiceFactory;
this._idContext = editionModule.IdContextFactory.createIdContext(databaseName);
this._tokenHolders = editionModule.TokenHoldersProvider.apply(databaseName);
this._locks = editionModule.LocksSupplier.get();
this._statementLocksFactory = editionModule.StatementLocksFactoryProvider.apply(_locks);
this._transactionMonitor = editionModule.CreateTransactionMonitor();
this._editionModule = editionModule;
}
private static BoltServer CreateBoltServer(PlatformModule platform, AbstractEditionModule edition, DatabaseManager databaseManager)
{
return(new BoltServer(databaseManager, platform.JobScheduler, platform.ConnectorPortRegister, edition.ConnectionTracker, platform.UsageData, platform.Config, platform.Clock, platform.Monitors, platform.Logging, platform.Dependencies));
}
/// <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);
}