Refactor (Facade)Factory and Platform to use Config not Map

community/kernel/src/main/java/org/neo4j/graphdb/factory/GraphDatabaseFactory.java

@@ -24,6 +24,7 @@
 
 import org.neo4j.graphdb.GraphDatabaseService;
 import org.neo4j.graphdb.security.URLAccessRule;
+import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.impl.factory.CommunityEditionModule;
 import org.neo4j.kernel.impl.factory.DatabaseInfo;
 import org.neo4j.kernel.impl.factory.Edition;
@@ -95,10 +96,11 @@ protected void configure( GraphDatabaseBuilder builder )
         // Let the default configuration pass through.
     }
 
-    protected GraphDatabaseService newDatabase( File storeDir, Map<String,String> config, GraphDatabaseFacadeFactory.Dependencies dependencies )
+    protected GraphDatabaseService newDatabase( File storeDir, Map<String,String> settings,
+            GraphDatabaseFacadeFactory.Dependencies dependencies )
     {
         return new GraphDatabaseFacadeFactory( DatabaseInfo.COMMUNITY, CommunityEditionModule::new )
-                .newFacade( storeDir, config, dependencies );
+                .newFacade( storeDir, Config.embeddedDefaults().with( settings ), dependencies );
     }
 
     public GraphDatabaseFactory addURLAccessRule( String protocol, URLAccessRule rule )

community/kernel/src/main/java/org/neo4j/kernel/impl/factory/GraphDatabaseFacade.java

@@ -205,14 +205,14 @@ public GraphDatabaseFacade()
      *
      * Any required dependencies are resolved using the resolver obtained from the SPI.
      */
-    public final void init( SPI spi, Config config )
+    public final void init( SPI spi )
     {
         DependencyResolver resolver = spi.resolver();
         init(
             spi,
             resolver.resolveDependency( Guard.class ),
             resolver.resolveDependency( ThreadToStatementContextBridge.class ),
-            config
+            resolver.resolveDependency( Config.class )
         );
     }
 

community/kernel/src/main/java/org/neo4j/kernel/impl/factory/GraphDatabaseFacadeFactory.java

@@ -31,6 +31,7 @@
 import org.neo4j.helpers.Exceptions;
 import org.neo4j.kernel.AvailabilityGuard;
 import org.neo4j.kernel.NeoStoreDataSource;
+import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.configuration.Settings;
 import org.neo4j.kernel.extension.KernelExtensionFactory;
 import org.neo4j.kernel.impl.coreapi.CoreAPIAvailabilityGuard;
@@ -52,12 +53,12 @@
  * This is the main factory for creating database instances. It delegates creation to three different modules
  * ({@link PlatformModule}, {@link EditionModule}, and {@link DataSourceModule}),
  * which create all the specific services needed to run a graph database.
- * <p/>
+ * <p>
  * It is abstract in order for subclasses to specify their own {@link org.neo4j.kernel.impl.factory.EditionModule}
- * implementations. Subclasses also have to set the edition name
- * in overridden version of {@link #initFacade(File, Map, GraphDatabaseFacadeFactory.Dependencies, GraphDatabaseFacade)},
+ * implementations. Subclasses also have to set the edition name in overridden version of
+ * {@link #initFacade(File, Map, GraphDatabaseFacadeFactory.Dependencies, GraphDatabaseFacade)},
  * which is used for logging and similar.
- * <p/>
+ * <p>
  * To create test versions of databases, override an edition factory (e.g. {@link org.neo4j.kernel.impl.factory
  * .CommunityFacadeFactory}), and replace modules
  * with custom versions that instantiate alternative services.
@@ -116,15 +117,14 @@ public GraphDatabaseFacadeFactory( DatabaseInfo databaseInfo, Function<PlatformM
      * Instantiate a graph database given configuration and dependencies.
      *
      * @param storeDir the directory where the Neo4j data store is located
-     * @param params configuration parameters
+     * @param config configuration
      * @param dependencies the dependencies required to construct the {@link GraphDatabaseFacade}
      * @return the newly constructed {@link GraphDatabaseFacade}
      */
-    public GraphDatabaseFacade newFacade( File storeDir, Map<String,String> params, final Dependencies dependencies )
+    public GraphDatabaseFacade newFacade( File storeDir, Config config, final Dependencies dependencies )
     {
-        return initFacade( storeDir, params, dependencies, new GraphDatabaseFacade() );
+        return initFacade( storeDir, config, dependencies, new GraphDatabaseFacade() );
     }
-
     /**
      * Instantiate a graph database given configuration, dependencies, and a custom implementation of {@link org
      * .neo4j.kernel.impl.factory.GraphDatabaseFacade}.
@@ -138,7 +138,23 @@ public GraphDatabaseFacade newFacade( File storeDir, Map<String,String> params,
     public GraphDatabaseFacade initFacade( File storeDir, Map<String,String> params, final Dependencies dependencies,
             final GraphDatabaseFacade graphDatabaseFacade )
     {
-        PlatformModule platform = createPlatform( storeDir, params, dependencies, graphDatabaseFacade );
+        return initFacade( storeDir, Config.embeddedDefaults().with( params ), dependencies, graphDatabaseFacade );
+    }
+
+    /**
+     * Instantiate a graph database given configuration, dependencies, and a custom implementation of {@link org
+     * .neo4j.kernel.impl.factory.GraphDatabaseFacade}.
+     *
+     * @param storeDir the directory where the Neo4j data store is located
+     * @param config configuration
+     * @param dependencies the dependencies required to construct the {@link GraphDatabaseFacade}
+     * @param graphDatabaseFacade the already created facade which needs initialisation
+     * @return the initialised {@link GraphDatabaseFacade}
+     */
+    public GraphDatabaseFacade initFacade( File storeDir, Config config, final Dependencies dependencies,
+            final GraphDatabaseFacade graphDatabaseFacade )
+    {
+        PlatformModule platform = createPlatform( storeDir, config, dependencies, graphDatabaseFacade );
         EditionModule edition = editionFactory.apply( platform );
 
         AtomicReference<QueryExecutionEngine> queryEngine = new AtomicReference<>( noEngine() );
@@ -221,10 +237,10 @@ public void unregistered( NeoStoreDataSource dataSource )
     /**
      * Create the platform module. Override to replace with custom module.
      */
-    protected PlatformModule createPlatform( File storeDir, Map<String,String> params, final Dependencies dependencies,
+    protected PlatformModule createPlatform( File storeDir, Config config, final Dependencies dependencies,
             final GraphDatabaseFacade graphDatabaseFacade )
     {
-        return new PlatformModule( storeDir, params, databaseInfo, dependencies, graphDatabaseFacade );
+        return new PlatformModule( storeDir, config, databaseInfo, dependencies, graphDatabaseFacade );
     }
 
     /**

community/kernel/src/main/java/org/neo4j/kernel/impl/factory/PlatformModule.java

@@ -22,7 +22,6 @@
 import java.io.File;
 import java.io.IOException;
 import java.time.Clock;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -67,6 +66,8 @@
 import org.neo4j.udc.UsageData;
 import org.neo4j.udc.UsageDataKeys;
 
+import static org.neo4j.helpers.collection.MapUtil.stringMap;
+
 /**
  * Platform module for {@link org.neo4j.kernel.impl.factory.GraphDatabaseFacadeFactory}. This creates
  * all the services needed by {@link org.neo4j.kernel.impl.factory.EditionModule} implementations.
@@ -111,7 +112,14 @@ public class PlatformModule
 
     public final SystemNanoClock clock;
 
-    public PlatformModule( File providedStoreDir, Map<String, String> params, DatabaseInfo databaseInfo,
+    public PlatformModule( File providedStoreDir, Map<String,String> params, DatabaseInfo databaseInfo,
+            GraphDatabaseFacadeFactory.Dependencies externalDependencies, GraphDatabaseFacade graphDatabaseFacade )
+    {
+        this( providedStoreDir, Config.embeddedDefaults().with( params ), databaseInfo, externalDependencies,
+                graphDatabaseFacade );
+    }
+
+    public PlatformModule( File providedStoreDir, Config config, DatabaseInfo databaseInfo,
             GraphDatabaseFacadeFactory.Dependencies externalDependencies, GraphDatabaseFacade graphDatabaseFacade )
     {
         this.databaseInfo = databaseInfo;
@@ -123,15 +131,10 @@ public PlatformModule( File providedStoreDir, Map<String, String> params, Databa
         life = dependencies.satisfyDependency( createLife() );
         this.graphDatabaseFacade = dependencies.satisfyDependency( graphDatabaseFacade );
 
-        if ( !params.containsKey( GraphDatabaseSettings.neo4j_home.name() ) )
-        {
-            params = new HashMap<>( params );
-            params.put( GraphDatabaseSettings.neo4j_home.name(), providedStoreDir.getAbsolutePath() );
-        }
-
         // SPI - provided services
-        config = dependencies.satisfyDependency( new Config( params, getSettingsClasses(
-                externalDependencies.settingsClasses(), externalDependencies.kernelExtensions() ) ) );
+        this.config = dependencies.satisfyDependency( config.withDefaults(
+                stringMap( GraphDatabaseSettings.neo4j_home.name(), providedStoreDir.getAbsolutePath() )
+        ) );
 
         this.storeDir = providedStoreDir.getAbsoluteFile();
 

community/kernel/src/main/java/org/neo4j/kernel/internal/EmbeddedGraphDatabase.java

@@ -25,6 +25,7 @@
 import org.neo4j.graphdb.GraphDatabaseService;
 import org.neo4j.graphdb.factory.GraphDatabaseSettings;
 import org.neo4j.kernel.GraphDatabaseDependencies;
+import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.impl.factory.CommunityEditionModule;
 import org.neo4j.kernel.impl.factory.DatabaseInfo;
 import org.neo4j.kernel.impl.factory.GraphDatabaseFacade;
@@ -72,6 +73,16 @@ public EmbeddedGraphDatabase( File storeDir,
         create( storeDir, params, dependencies );
     }
 
+    /**
+     * Internal constructor
+     */
+    public EmbeddedGraphDatabase( File storeDir,
+            Config config,
+            GraphDatabaseFacadeFactory.Dependencies dependencies )
+    {
+        create( storeDir, config, dependencies );
+    }
+
     protected void create( File storeDir, Map<String, String> params,
                                       GraphDatabaseFacadeFactory.Dependencies dependencies)
     {
@@ -80,4 +91,13 @@ protected void create( File storeDir, Map<String, String> params,
         new GraphDatabaseFacadeFactory( DatabaseInfo.COMMUNITY, CommunityEditionModule::new )
                 .initFacade( storeDir, params, newDependencies, this );
     }
+
+    protected void create( File storeDir, Config config,
+            GraphDatabaseFacadeFactory.Dependencies dependencies)
+    {
+        GraphDatabaseDependencies newDependencies = newDependencies( dependencies )
+                .settingsClasses( asList( append( GraphDatabaseSettings.class, dependencies.settingsClasses() ) ) );
+        new GraphDatabaseFacadeFactory( DatabaseInfo.COMMUNITY, CommunityEditionModule::new )
+                .initFacade( storeDir, config, newDependencies, this );
+    }
 }

community/kernel/src/test/java/org/neo4j/graphdb/LabelsAcceptanceTest.java

@@ -38,7 +38,7 @@
 import org.neo4j.io.fs.FileSystemAbstraction;
 import org.neo4j.kernel.GraphDatabaseDependencies;
 import org.neo4j.kernel.api.Statement;
-import org.neo4j.kernel.api.exceptions.EntityNotFoundException;
+import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge;
 import org.neo4j.kernel.impl.factory.CommunityEditionModule;
 import org.neo4j.kernel.impl.factory.DatabaseInfo;
@@ -753,9 +753,11 @@ protected IdGeneratorFactory createIdGeneratorFactory(
                                 {
 
                                     @Override
-                                    protected PlatformModule createPlatform( File storeDir, Map<String, String> params, Dependencies dependencies, GraphDatabaseFacade graphDatabaseFacade )
+                                    protected PlatformModule createPlatform( File storeDir, Config config,
+                                            Dependencies dependencies, GraphDatabaseFacade graphDatabaseFacade )
                                     {
-                                        return new ImpermanentPlatformModule( storeDir, params, databaseInfo, dependencies, graphDatabaseFacade );
+                                        return new ImpermanentPlatformModule( storeDir, config, databaseInfo,
+                                                dependencies, graphDatabaseFacade );
                                     }
                                 }.initFacade( storeDir, params, dependencies, this );
                             }

community/kernel/src/test/java/org/neo4j/kernel/GraphDatabaseFacadeFactoryTest.java

@@ -27,7 +27,6 @@
 
 import java.io.File;
 import java.util.Collections;
-import java.util.Map;
 import java.util.function.Supplier;
 
 import org.neo4j.helpers.Exceptions;
@@ -121,14 +120,14 @@ private GraphDatabaseFacadeFactory newFaultyGraphDatabaseFacadeFactory( final Ru
                 (p) -> Mockito.mock( EditionModule.class, Mockito.RETURNS_DEEP_STUBS ))
         {
             @Override
-            protected PlatformModule createPlatform( File storeDir, Map<String,String> params,
+            protected PlatformModule createPlatform( File storeDir, Config config,
                     Dependencies dependencies, GraphDatabaseFacade graphDatabaseFacade )
             {
                 final LifeSupport lifeMock = mock( LifeSupport.class );
                 doThrow( startupError ).when( lifeMock ).start();
                 doAnswer( invocation -> invocation.getArguments()[0] ).when( lifeMock ).add( any( Lifecycle.class ) );
 
-                return new PlatformModule( storeDir, params, databaseInfo, dependencies, graphDatabaseFacade )
+                return new PlatformModule( storeDir, config, databaseInfo, dependencies, graphDatabaseFacade )
                 {
                     @Override
                     public LifeSupport createLife()

community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTest.java

@@ -28,6 +28,7 @@
 import org.neo4j.graphdb.Transaction;
 import org.neo4j.kernel.api.Statement;
 import org.neo4j.kernel.api.exceptions.InvalidTransactionTypeKernelException;
+import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge;
 import org.neo4j.kernel.impl.factory.CommunityEditionModule;
 import org.neo4j.kernel.impl.factory.DatabaseInfo;
@@ -93,9 +94,11 @@ protected SchemaWriteGuard createSchemaWriteGuard()
             new GraphDatabaseFacadeFactory( DatabaseInfo.COMMUNITY,  factory )
             {
                 @Override
-                protected PlatformModule createPlatform( File storeDir, Map<String, String> params, Dependencies dependencies, GraphDatabaseFacade graphDatabaseFacade )
+                protected PlatformModule createPlatform( File storeDir, Config config, Dependencies dependencies,
+                        GraphDatabaseFacade graphDatabaseFacade )
                 {
-                    return new ImpermanentPlatformModule( storeDir, params, databaseInfo, dependencies, graphDatabaseFacade );
+                    return new ImpermanentPlatformModule( storeDir, config, databaseInfo, dependencies,
+                            graphDatabaseFacade );
                 }
             }.initFacade( storeDir, params, dependencies, this );
         }

community/kernel/src/test/java/org/neo4j/kernel/impl/factory/GraphDatabaseFacadeTest.java

@@ -49,7 +49,6 @@ public class GraphDatabaseFacadeTest
     private GraphDatabaseFacade.SPI spi = Mockito.mock( GraphDatabaseFacade.SPI.class, RETURNS_DEEP_STUBS );
     private GraphDatabaseFacade graphDatabaseFacade = new GraphDatabaseFacade();
     private GraphDatabaseQueryService queryService;
-    private Config defaultConfig;
 
     @Before
     public void setUp()
@@ -64,9 +63,9 @@ public void setUp()
         when( resolver.resolveDependency( ThreadToStatementContextBridge.class ) ).thenReturn( contextBridge );
         when( resolver.resolveDependency( Guard.class ) ).thenReturn( mock( Guard.class ) );
         when( contextBridge.get() ).thenReturn( statement );
-        defaultConfig = Config.defaults();
+        when( resolver.resolveDependency( Config.class ) ).thenReturn( Config.embeddedDefaults() );
 
-        graphDatabaseFacade.init( spi, defaultConfig );
+        graphDatabaseFacade.init( spi );
     }
 
     @Test
@@ -82,7 +81,7 @@ public void beginTransaction()
     {
         graphDatabaseFacade.beginTx();
 
-        long timeout = defaultConfig.get( GraphDatabaseSettings.transaction_timeout );
+        long timeout = Config.embeddedDefaults().get( GraphDatabaseSettings.transaction_timeout );
         verify( spi ).beginTransaction( KernelTransaction.Type.explicit, AUTH_DISABLED, timeout );
     }
 
@@ -110,7 +109,7 @@ public void executeQueryStartDefaultTransaction()
         graphDatabaseFacade.execute( "create (n)" );
         graphDatabaseFacade.execute( "create (n)", new HashMap<>() );
 
-        long timeout = defaultConfig.get( GraphDatabaseSettings.transaction_timeout );
+        long timeout = Config.embeddedDefaults().get( GraphDatabaseSettings.transaction_timeout );
         verify( spi, times( 2 ) ).beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED, timeout );
     }
 }

community/kernel/src/test/java/org/neo4j/kernel/impl/store/IdGeneratorRebuildFailureEmulationTest.java

@@ -236,9 +236,9 @@ protected void create( File storeDir, Map<String, String> params, GraphDatabaseF
             new GraphDatabaseFacadeFactory( DatabaseInfo.COMMUNITY, CommunityEditionModule::new )
             {
                 @Override
-                protected PlatformModule createPlatform( File storeDir, Map<String, String> params, Dependencies dependencies, GraphDatabaseFacade facade )
+                protected PlatformModule createPlatform( File storeDir, Config config, Dependencies dependencies, GraphDatabaseFacade facade )
                 {
-                    return new ImpermanentPlatformModule( storeDir, params, databaseInfo, dependencies, facade )
+                    return new ImpermanentPlatformModule( storeDir, config, databaseInfo, dependencies, facade )
                     {
                         @Override
                         protected FileSystemAbstraction createFileSystemAbstraction()

community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/CommitContentionTests.java

@@ -25,13 +25,13 @@
 import org.junit.Test;
 
 import java.io.File;
-import java.util.Map;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicReference;
 
 import org.neo4j.graphdb.GraphDatabaseService;
 import org.neo4j.graphdb.Transaction;
 import org.neo4j.graphdb.factory.GraphDatabaseFactoryState;
+import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.impl.api.index.RemoveOrphanConstraintIndexesOnStartup;
 import org.neo4j.kernel.impl.factory.CommunityEditionModule;
 import org.neo4j.kernel.impl.factory.DatabaseInfo;
@@ -40,7 +40,6 @@
 import org.neo4j.kernel.impl.factory.PlatformModule;
 import org.neo4j.test.rule.TestDirectory;
 
-import static java.util.Collections.emptyMap;
 import static java.util.concurrent.TimeUnit.SECONDS;
 
 public class CommitContentionTests
@@ -132,9 +131,9 @@ private GraphDatabaseService createDb()
         return new GraphDatabaseFacadeFactory( DatabaseInfo.COMMUNITY, CommunityEditionModule::new )
         {
             @Override
-            protected PlatformModule createPlatform( File storeDir, Map<String, String> params, Dependencies dependencies, GraphDatabaseFacade graphDatabaseFacade )
+            protected PlatformModule createPlatform( File storeDir, Config config, Dependencies dependencies, GraphDatabaseFacade graphDatabaseFacade )
             {
-                return new PlatformModule( storeDir, params, databaseInfo, dependencies, graphDatabaseFacade )
+                return new PlatformModule( storeDir, config, databaseInfo, dependencies, graphDatabaseFacade )
                 {
                     @Override
                     protected TransactionStats createTransactionStats()
@@ -183,7 +182,7 @@ private boolean isTheRemoveOrphanedConstraintIndexesOnStartupTransaction()
                     }
                 };
             }
-        }.newFacade( storeLocation.graphDbDir(), emptyMap(), state.databaseDependencies() );
+        }.newFacade( storeLocation.graphDbDir(), Config.embeddedDefaults(), state.databaseDependencies() );
     }
 
     private void waitForFirstTransactionToStartPushing() throws InterruptedException