From e78a95566ad948ca9c37481c409fe41187f038bd Mon Sep 17 00:00:00 2001 From: MishaDemianenko Date: Mon, 10 Sep 2018 12:00:19 +0200 Subject: [PATCH] Introduce edition database creation context. Use creation context instead of edition directly for database creation since it simplifies lifecycle and dependency management of some editions that do that for their internal components. --- .../facade/GraphDatabaseFacadeFactory.java | 3 +- .../factory/module/DataSourceModule.java | 5 +- .../DefaultEditionModuleDatabaseContext.java | 163 ++++++++++++++++++ .../module/EditionDatabaseContext.java | 71 ++++++++ .../graphdb/factory/module/EditionModule.java | 30 ++-- .../ModularDatabaseCreationContext.java | 30 ++-- 6 files changed, 273 insertions(+), 29 deletions(-) create mode 100644 community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/DefaultEditionModuleDatabaseContext.java create mode 100644 community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionDatabaseContext.java diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/facade/GraphDatabaseFacadeFactory.java b/community/neo4j/src/main/java/org/neo4j/graphdb/facade/GraphDatabaseFacadeFactory.java index 584acdc5450bc..5720abd5e6a8c 100644 --- a/community/neo4j/src/main/java/org/neo4j/graphdb/facade/GraphDatabaseFacadeFactory.java +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/facade/GraphDatabaseFacadeFactory.java @@ -178,7 +178,8 @@ public GraphDatabaseFacade initFacade( File storeDir, Config config, final Depen 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 ) ); + new StartupWaiter( edition.getGlobalAvailabilityGuard( platform.clock, platform.logging, platform.config ), + edition.getTransactionStartTimeout() ) ); platform.dependencies.satisfyDependency( edition.schemaWriteGuard ); platform.life.setLast( platform.eventHandlers ); diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/DataSourceModule.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/DataSourceModule.java index 2c2ed3dc870e6..8dbe0131ac05b 100644 --- a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/DataSourceModule.java +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/DataSourceModule.java @@ -42,11 +42,10 @@ public class DataSourceModule public DataSourceModule( String databaseName, PlatformModule platformModule, EditionModule editionModule, Procedures procedures, GraphDatabaseFacade graphDatabaseFacade ) { - platformModule.diagnosticsManager.prependProvider( platformModule.config ); - + EditionDatabaseContext editionContext = editionModule.createDatabaseContext( databaseName ); ModularDatabaseCreationContext context = - new ModularDatabaseCreationContext( databaseName, platformModule, editionModule, procedures, graphDatabaseFacade ); + new ModularDatabaseCreationContext( databaseName, platformModule, editionContext, procedures, graphDatabaseFacade ); neoStoreDataSource = new NeoStoreDataSource( context ); this.coreAPIAvailabilityGuard = context.getCoreAPIAvailabilityGuard(); diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/DefaultEditionModuleDatabaseContext.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/DefaultEditionModuleDatabaseContext.java new file mode 100644 index 0000000000000..f15105bc7229e --- /dev/null +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/DefaultEditionModuleDatabaseContext.java @@ -0,0 +1,163 @@ +/* + * Copyright (c) 2002-2018 "Neo4j," + * Neo4j Sweden AB [http://neo4j.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.graphdb.factory.module; + +import java.io.File; +import java.util.function.Function; + +import org.neo4j.graphdb.factory.module.id.DatabaseIdContext; +import org.neo4j.graphdb.factory.module.id.IdContextFactory; +import org.neo4j.io.pagecache.IOLimiter; +import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.configuration.Config; +import org.neo4j.kernel.impl.api.CommitProcessFactory; +import org.neo4j.kernel.impl.api.SchemaWriteGuard; +import org.neo4j.kernel.impl.constraints.ConstraintSemantics; +import org.neo4j.kernel.impl.core.TokenHolders; +import org.neo4j.kernel.impl.factory.AccessCapability; +import org.neo4j.kernel.impl.locking.Locks; +import org.neo4j.kernel.impl.locking.StatementLocksFactory; +import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory; +import org.neo4j.kernel.impl.transaction.stats.DatabaseTransactionStats; +import org.neo4j.kernel.impl.util.watcher.FileSystemWatcherService; +import org.neo4j.logging.internal.LogService; +import org.neo4j.time.SystemNanoClock; + +public class DefaultEditionModuleDatabaseContext implements EditionDatabaseContext +{ + private final IdContextFactory idContextFactory; + private final Function statementLocksFactoryProvider; + private final Function watcherServiceFactory; + private final String databaseName; + private final AccessCapability accessCapability; + private final IOLimiter ioLimiter; + private final ConstraintSemantics constraintSemantics; + private final CommitProcessFactory commitProcessFactory; + private final TransactionHeaderInformationFactory headerInformationFactory; + private final SchemaWriteGuard schemaWriteGuard; + private final long transactionStartTimeout; + private final Function tokenHoldersProvider; + private final Locks locks; + private final DatabaseTransactionStats transactionMonitor; + private final EditionModule editionModule; + + DefaultEditionModuleDatabaseContext( EditionModule editionModule, String databaseName ) + { + this.databaseName = databaseName; + this.transactionStartTimeout = editionModule.getTransactionStartTimeout(); + 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.idContextFactory = editionModule.idContextFactory; + this.tokenHoldersProvider = editionModule.tokenHoldersProvider; + this.locks = editionModule.locksSupplier.get(); + this.statementLocksFactoryProvider = editionModule.statementLocksFactoryProvider; + this.transactionMonitor = editionModule.createTransactionMonitor(); + this.editionModule = editionModule; + } + + @Override + public DatabaseIdContext createIdContext() + { + return idContextFactory.createIdContext( databaseName ); + } + + @Override + public TokenHolders createTokenHolders() + { + return tokenHoldersProvider.apply( databaseName ); + } + + @Override + public Function getWatcherServiceFactory() + { + return watcherServiceFactory; + } + + @Override + public AccessCapability getAccessCapability() + { + return accessCapability; + } + + @Override + public IOLimiter getIoLimiter() + { + return ioLimiter; + } + + @Override + public ConstraintSemantics getConstraintSemantics() + { + return constraintSemantics; + } + + @Override + public CommitProcessFactory getCommitProcessFactory() + { + return commitProcessFactory; + } + + @Override + public TransactionHeaderInformationFactory getHeaderInformationFactory() + { + return headerInformationFactory; + } + + @Override + public SchemaWriteGuard getSchemaWriteGuard() + { + return schemaWriteGuard; + } + + @Override + public long getTransactionStartTimeout() + { + return transactionStartTimeout; + } + + @Override + public Locks createLocks() + { + return locks; + } + + @Override + public StatementLocksFactory createStatementLocksFactory() + { + return statementLocksFactoryProvider.apply( locks ); + } + + @Override + public DatabaseTransactionStats createTransactionMonitor() + { + return transactionMonitor; + } + + @Override + public DatabaseAvailabilityGuard createDatabaseAvailabilityGuard( SystemNanoClock clock, LogService logService, Config config ) + { + return editionModule.createDatabaseAvailabilityGuard( databaseName, clock, logService, config ); + } +} diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionDatabaseContext.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionDatabaseContext.java new file mode 100644 index 0000000000000..55d194a6ce1c5 --- /dev/null +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionDatabaseContext.java @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2002-2018 "Neo4j," + * Neo4j Sweden AB [http://neo4j.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.graphdb.factory.module; + +import java.io.File; +import java.util.function.Function; + +import org.neo4j.graphdb.factory.module.id.DatabaseIdContext; +import org.neo4j.io.pagecache.IOLimiter; +import org.neo4j.kernel.availability.DatabaseAvailabilityGuard; +import org.neo4j.kernel.configuration.Config; +import org.neo4j.kernel.impl.api.CommitProcessFactory; +import org.neo4j.kernel.impl.api.SchemaWriteGuard; +import org.neo4j.kernel.impl.constraints.ConstraintSemantics; +import org.neo4j.kernel.impl.core.TokenHolders; +import org.neo4j.kernel.impl.factory.AccessCapability; +import org.neo4j.kernel.impl.locking.Locks; +import org.neo4j.kernel.impl.locking.StatementLocksFactory; +import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory; +import org.neo4j.kernel.impl.transaction.stats.DatabaseTransactionStats; +import org.neo4j.kernel.impl.util.watcher.FileSystemWatcherService; +import org.neo4j.logging.internal.LogService; +import org.neo4j.time.SystemNanoClock; + +public interface EditionDatabaseContext +{ + DatabaseIdContext createIdContext(); + + TokenHolders createTokenHolders(); + + Function getWatcherServiceFactory(); + + AccessCapability getAccessCapability(); + + IOLimiter getIoLimiter(); + + ConstraintSemantics getConstraintSemantics(); + + CommitProcessFactory getCommitProcessFactory(); + + TransactionHeaderInformationFactory getHeaderInformationFactory(); + + SchemaWriteGuard getSchemaWriteGuard(); + + long getTransactionStartTimeout(); + + Locks createLocks(); + + StatementLocksFactory createStatementLocksFactory(); + + DatabaseTransactionStats createTransactionMonitor(); + + DatabaseAvailabilityGuard createDatabaseAvailabilityGuard( SystemNanoClock clock, LogService logService, Config config ); +} diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java index bdf205baf40c2..3f44a76f17f2c 100644 --- a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java @@ -76,29 +76,29 @@ */ public abstract class EditionModule { - public IdContextFactory idContextFactory; + protected IdContextFactory idContextFactory; - public Function tokenHoldersProvider; + protected Function tokenHoldersProvider; - public Supplier locksSupplier; + protected Supplier locksSupplier; - public Function statementLocksFactoryProvider; + protected Function statementLocksFactoryProvider; - public CommitProcessFactory commitProcessFactory; + protected CommitProcessFactory commitProcessFactory; - public long transactionStartTimeout; + protected long transactionStartTimeout; - public TransactionHeaderInformationFactory headerInformationFactory; + protected TransactionHeaderInformationFactory headerInformationFactory; public SchemaWriteGuard schemaWriteGuard; - public ConstraintSemantics constraintSemantics; + protected ConstraintSemantics constraintSemantics; - public AccessCapability accessCapability; + protected AccessCapability accessCapability; public IOLimiter ioLimiter; - public Function watcherServiceFactory; + protected Function watcherServiceFactory; public AuthManager authManager; @@ -112,6 +112,11 @@ public abstract class EditionModule protected AvailabilityGuard globalAvailabilityGuard; + EditionDatabaseContext createDatabaseContext( String databaseName ) + { + return new DefaultEditionModuleDatabaseContext( this, databaseName ); + } + protected FileSystemWatcherService createFileSystemWatcherService( FileSystemAbstraction fileSystem, File databaseDirectory, LogService logging, JobScheduler jobScheduler, Config config, Predicate fileNameFilter ) { @@ -264,4 +269,9 @@ public void createDatabases( DatabaseManager databaseManager, Config config ) { databaseManager.createDatabase( config.get( GraphDatabaseSettings.active_database ) ); } + + public long getTransactionStartTimeout() + { + return transactionStartTimeout; + } } diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java index 92a741addc7e1..e8ec93919b3ed 100644 --- a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java @@ -120,53 +120,53 @@ public class ModularDatabaseCreationContext implements DatabaseCreationContext private final DatabaseLayout databaseLayout; private final DatabaseAvailability databaseAvailability; - ModularDatabaseCreationContext( String databaseName, PlatformModule platformModule, EditionModule editionModule, + ModularDatabaseCreationContext( String databaseName, PlatformModule platformModule, EditionDatabaseContext editionContext, Procedures procedures, GraphDatabaseFacade facade ) { this.databaseName = databaseName; this.config = platformModule.config; - DatabaseIdContext idContext = editionModule.idContextFactory.createIdContext( databaseName ); + DatabaseIdContext idContext = editionContext.createIdContext(); this.idGeneratorFactory = idContext.getIdGeneratorFactory(); this.idController = idContext.getIdController(); this.databaseLayout = platformModule.storeLayout.databaseLayout( databaseName ); this.logService = platformModule.logging; this.scheduler = platformModule.jobScheduler; this.globalDependencies = platformModule.dependencies; - this.tokenHolders = editionModule.tokenHoldersProvider.apply( databaseName ); + this.tokenHolders = editionContext.createTokenHolders(); this.tokenNameLookup = new NonTransactionalTokenNameLookup( tokenHolders ); - this.locks = editionModule.locksSupplier.get(); - this.statementLocksFactory = editionModule.statementLocksFactoryProvider.apply( locks ); - this.schemaWriteGuard = editionModule.schemaWriteGuard; + this.locks = editionContext.createLocks(); + this.statementLocksFactory = editionContext.createStatementLocksFactory(); + this.schemaWriteGuard = editionContext.getSchemaWriteGuard(); this.transactionEventHandlers = new TransactionEventHandlers( facade ); this.monitors = new Monitors( platformModule.monitors ); this.indexingServiceMonitor = monitors.newMonitor( IndexingService.Monitor.class ); this.physicalLogMonitor = monitors.newMonitor( LogFileCreationMonitor.class ); this.fs = platformModule.fileSystem; - this.transactionStats = editionModule.createTransactionMonitor(); + this.transactionStats = editionContext.createTransactionMonitor(); this.databaseHealth = new DatabaseHealth( platformModule.panicEventGenerator, logService.getInternalLog( DatabaseHealth.class ) ); - this.transactionHeaderInformationFactory = editionModule.headerInformationFactory; - this.commitProcessFactory = editionModule.commitProcessFactory; + this.transactionHeaderInformationFactory = editionContext.getHeaderInformationFactory(); + this.commitProcessFactory = editionContext.getCommitProcessFactory(); this.autoIndexing = new InternalAutoIndexing( platformModule.config, tokenHolders.propertyKeyTokens() ); this.indexConfigStore = new IndexConfigStore( databaseLayout, fs ); this.explicitIndexProvider = new DefaultExplicitIndexProvider(); this.pageCache = platformModule.pageCache; - this.constraintSemantics = editionModule.constraintSemantics; + this.constraintSemantics = editionContext.getConstraintSemantics(); this.tracers = platformModule.tracers; this.procedures = procedures; - this.ioLimiter = editionModule.ioLimiter; + this.ioLimiter = editionContext.getIoLimiter(); this.clock = platformModule.clock; - this.databaseAvailabilityGuard = editionModule.createDatabaseAvailabilityGuard( databaseName, clock, logService, config ); + this.databaseAvailabilityGuard = editionContext.createDatabaseAvailabilityGuard( clock, logService, config ); this.databaseAvailability = new DatabaseAvailability( databaseAvailabilityGuard, transactionStats, platformModule.clock, getAwaitActiveTransactionDeadlineMillis() ); - this.coreAPIAvailabilityGuard = new CoreAPIAvailabilityGuard( databaseAvailabilityGuard, editionModule.transactionStartTimeout ); - this.accessCapability = editionModule.accessCapability; + this.coreAPIAvailabilityGuard = new CoreAPIAvailabilityGuard( databaseAvailabilityGuard, editionContext.getTransactionStartTimeout() ); + this.accessCapability = editionContext.getAccessCapability(); this.storeCopyCheckPointMutex = new StoreCopyCheckPointMutex(); this.recoveryCleanupWorkCollector = platformModule.recoveryCleanupWorkCollector; this.databaseInfo = platformModule.databaseInfo; this.versionContextSupplier = platformModule.versionContextSupplier; this.collectionsFactorySupplier = platformModule.collectionsFactorySupplier; this.kernelExtensionFactories = platformModule.kernelExtensionFactories; - this.watcherServiceFactory = editionModule.watcherServiceFactory; + this.watcherServiceFactory = editionContext.getWatcherServiceFactory(); this.facade = facade; this.engineProviders = platformModule.engineProviders; }