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.

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 );
 

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();

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 <http://www.gnu.org/licenses/>.
+ */
+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<Locks,StatementLocksFactory> statementLocksFactoryProvider;
+    private final Function<File,FileSystemWatcherService> 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<String,TokenHolders> 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<File,FileSystemWatcherService> 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 );
+    }
+}

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 <http://www.gnu.org/licenses/>.
+ */
+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<File,FileSystemWatcherService> 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 );
+}

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<String, TokenHolders> tokenHoldersProvider;
+    protected Function<String, TokenHolders> tokenHoldersProvider;
 
-    public Supplier<Locks> locksSupplier;
+    protected Supplier<Locks> locksSupplier;
 
-    public Function<Locks, StatementLocksFactory> statementLocksFactoryProvider;
+    protected Function<Locks, StatementLocksFactory> 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<File, FileSystemWatcherService> watcherServiceFactory;
+    protected Function<File, FileSystemWatcherService> 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<String> fileNameFilter )
     {
@@ -264,4 +269,9 @@ public void createDatabases( DatabaseManager databaseManager, Config config )
     {
         databaseManager.createDatabase( config.get( GraphDatabaseSettings.active_database ) );
     }
+
+    public long getTransactionStartTimeout()
+    {
+        return transactionStartTimeout;
+    }
 }

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;
     }