Use fusion index provider for consistency check test

community/consistency-check/src/test/java/org/neo4j/consistency/checking/GraphStoreFixture.java

@@ -45,8 +45,7 @@
 import org.neo4j.kernel.api.ReadOperations;
 import org.neo4j.kernel.api.direct.DirectStoreAccess;
 import org.neo4j.kernel.api.exceptions.TransactionFailureException;
-import org.neo4j.kernel.api.impl.index.storage.DirectoryFactory;
-import org.neo4j.kernel.api.impl.schema.LuceneSchemaIndexProvider;
+import org.neo4j.kernel.api.impl.schema.NativeLuceneFusionSchemaIndexProviderFactory;
 import org.neo4j.kernel.api.index.SchemaIndexProvider;
 import org.neo4j.kernel.api.labelscan.LabelScanStore;
 import org.neo4j.kernel.configuration.Config;
@@ -115,13 +114,13 @@ public abstract class GraphStoreFixture extends ConfigurablePageCacheRule implem
      */
     private String formatName = StringUtils.EMPTY;
 
-    public GraphStoreFixture( boolean keepStatistics, String formatName )
+    private GraphStoreFixture( boolean keepStatistics, String formatName )
     {
         this.keepStatistics = keepStatistics;
         this.formatName = formatName;
     }
 
-    public GraphStoreFixture( String formatName )
+    protected GraphStoreFixture( String formatName )
     {
         this( false, formatName );
     }
@@ -176,11 +175,10 @@ public DirectStoreAccess directStoreAccess()
             OperationalMode operationalMode = OperationalMode.single;
             IndexStoreView indexStoreView =
                     new NeoStoreIndexStoreView( LockService.NO_LOCK_SERVICE, nativeStores.getRawNeoStores() );
-            RecoveryCleanupWorkCollector recoveryCleanupWorkCollector = RecoveryCleanupWorkCollector.IMMEDIATE;
 
             LabelScanStore labelScanStore = startLabelScanStore( pageCache, indexStoreView );
-            directStoreAccess = new DirectStoreAccess( nativeStores, labelScanStore, createIndexes( fileSystem,
-                    config, operationalMode ) );
+            SchemaIndexProvider indexes = createIndexes( pageCache, fileSystem, directory, config, operationalMode );
+            directStoreAccess = new DirectStoreAccess( nativeStores, labelScanStore, indexes );
         }
         return directStoreAccess;
     }
@@ -202,10 +200,12 @@ private LabelScanStore startLabelScanStore( PageCache pageCache, IndexStoreView
         return labelScanStore;
     }
 
-    private SchemaIndexProvider createIndexes( FileSystemAbstraction fileSystem, Config config, OperationalMode operationalMode )
+    private SchemaIndexProvider createIndexes( PageCache pageCache, FileSystemAbstraction fileSystem, File storeDir, Config config,
+            OperationalMode operationalMode )
     {
-        return new LuceneSchemaIndexProvider( fileSystem, DirectoryFactory.PERSISTENT, directory,
-                FormattedLogProvider.toOutputStream( System.out ), config, operationalMode );
+        FormattedLogProvider logging = FormattedLogProvider.toOutputStream( System.out );
+        return NativeLuceneFusionSchemaIndexProviderFactory
+                .newInstance( pageCache, storeDir, fileSystem, logging, config, operationalMode, RecoveryCleanupWorkCollector.IMMEDIATE );
     }
 
     public File directory()
@@ -220,7 +220,7 @@ public Statistics getAccessStatistics()
 
     public abstract static class Transaction
     {
-        public final long startTimestamp = currentTimeMillis();
+        final long startTimestamp = currentTimeMillis();
 
         protected abstract void transactionData( TransactionDataBuilder tx, IdGenerator next );
 
@@ -297,7 +297,7 @@ public int propertyKey()
             return propKeyId++;
         }
 
-        public void updateCorrespondingIdGenerators( NeoStores neoStores )
+        void updateCorrespondingIdGenerators( NeoStores neoStores )
         {
             neoStores.getNodeStore().setHighestPossibleIdInUse( nodeId );
             neoStores.getRelationshipStore().setHighestPossibleIdInUse( relId );
@@ -310,7 +310,7 @@ public static final class TransactionDataBuilder
         private final TransactionWriter writer;
         private final NodeStore nodes;
 
-        public TransactionDataBuilder( TransactionWriter writer, NodeStore nodes )
+        TransactionDataBuilder( TransactionWriter writer, NodeStore nodes )
         {
             this.writer = writer;
             this.nodes = nodes;
@@ -446,12 +446,12 @@ protected void stop() throws Throwable
         }
     }
 
-    protected int myId()
+    private int myId()
     {
         return 1;
     }
 
-    protected int masterId()
+    private int masterId()
     {
         return -1;
     }
@@ -463,7 +463,7 @@ public class Applier implements AutoCloseable
         private final TransactionIdStore transactionIdStore;
         private final NeoStores neoStores;
 
-        public Applier()
+        Applier()
         {
             database = (GraphDatabaseAPI) new TestGraphDatabaseFactory().newEmbeddedDatabase( directory );
             DependencyResolver dependencyResolver = database.getDependencyResolver();
@@ -498,7 +498,7 @@ public Applier createApplier()
         return new Applier();
     }
 
-    protected void applyTransaction( Transaction transaction ) throws TransactionFailureException
+    private void applyTransaction( Transaction transaction ) throws TransactionFailureException
     {
         // TODO you know... we could have just appended the transaction representation to the log
         // and the next startup of the store would do recovery where the transaction would have been

community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/schema/LuceneSchemaIndexProviderFactory.java

@@ -19,13 +19,16 @@
  */
 package org.neo4j.kernel.api.impl.schema;
 
+import java.io.File;
+
 import org.neo4j.helpers.Service;
 import org.neo4j.io.fs.FileSystemAbstraction;
 import org.neo4j.kernel.api.impl.index.storage.DirectoryFactory;
 import org.neo4j.kernel.api.index.SchemaIndexProvider;
 import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.extension.KernelExtensionFactory;
 import org.neo4j.kernel.impl.factory.GraphDatabaseFacadeFactory;
+import org.neo4j.kernel.impl.factory.OperationalMode;
 import org.neo4j.kernel.impl.logging.LogService;
 import org.neo4j.kernel.impl.spi.KernelContext;
 import org.neo4j.logging.LogProvider;
@@ -58,19 +61,20 @@ public LuceneSchemaIndexProviderFactory()
     @Override
     public LuceneSchemaIndexProvider newInstance( KernelContext context, Dependencies dependencies ) throws Throwable
     {
-        return create( context, dependencies );
+        FileSystemAbstraction fileSystemAbstraction = dependencies.fileSystem();
+        File storeDir = context.storeDir();
+        Config config = dependencies.getConfig();
+        LogService logging = dependencies.getLogging();
+        LogProvider internalLogProvider = logging.getInternalLogProvider();
+        OperationalMode operationalMode = context.databaseInfo().operationalMode;
+        return create( fileSystemAbstraction, storeDir, internalLogProvider, config, operationalMode );
     }
 
-    static LuceneSchemaIndexProvider create( KernelContext context, Dependencies dependencies ) throws Throwable
+    public static LuceneSchemaIndexProvider create( FileSystemAbstraction fileSystemAbstraction, File storeDir,
+            LogProvider logProvider, Config config, OperationalMode operationalMode )
     {
-        Config config = dependencies.getConfig();
-        LogProvider logging = dependencies.getLogging().getInternalLogProvider();
         boolean ephemeral = config.get( GraphDatabaseFacadeFactory.Configuration.ephemeral );
-
-        FileSystemAbstraction fileSystem = dependencies.fileSystem();
-        DirectoryFactory directoryFactory = directoryFactory( ephemeral, fileSystem );
-
-        return new LuceneSchemaIndexProvider( fileSystem, directoryFactory, context.storeDir(), logging, config,
-                context.databaseInfo().operationalMode );
+        DirectoryFactory directoryFactory = directoryFactory( ephemeral, fileSystemAbstraction );
+        return new LuceneSchemaIndexProvider( fileSystemAbstraction, directoryFactory, storeDir, logProvider, config, operationalMode );
     }
 }

community/lucene-index/src/main/java/org/neo4j/kernel/api/impl/schema/NativeLuceneFusionSchemaIndexProviderFactory.java

@@ -19,9 +19,12 @@
  */
 package org.neo4j.kernel.api.impl.schema;
 
+import java.io.File;
+
 import org.neo4j.graphdb.factory.GraphDatabaseSettings;
 import org.neo4j.helpers.Service;
 import org.neo4j.index.internal.gbptree.RecoveryCleanupWorkCollector;
+import org.neo4j.io.fs.FileSystemAbstraction;
 import org.neo4j.io.pagecache.PageCache;
 import org.neo4j.kernel.api.index.SchemaIndexProvider;
 import org.neo4j.kernel.configuration.Config;
@@ -56,24 +59,26 @@ public NativeLuceneFusionSchemaIndexProviderFactory()
     @Override
     public FusionSchemaIndexProvider newInstance( KernelContext context, Dependencies dependencies ) throws Throwable
     {
-        NativeSchemaNumberIndexProvider nativeProvider = nativeSchemaNumberIndexProvider( context, dependencies );
-        LuceneSchemaIndexProvider luceneProvider = luceneSchemaIndexProvider( context, dependencies );
-        return new FusionSchemaIndexProvider( nativeProvider, luceneProvider, new NativeSelector(), DESCRIPTOR, 50 );
-    }
-
-    private LuceneSchemaIndexProvider luceneSchemaIndexProvider( KernelContext context,
-            Dependencies dependencies ) throws Throwable
-    {
-        return LuceneSchemaIndexProviderFactory.create( context, dependencies );
+        PageCache pageCache = dependencies.pageCache();
+        File storeDir = context.storeDir();
+        FileSystemAbstraction fs = dependencies.fileSystem();
+        LogProvider logProvider = dependencies.getLogging().getInternalLogProvider();
+        Config config = dependencies.getConfig();
+        OperationalMode operationalMode = context.databaseInfo().operationalMode;
+        RecoveryCleanupWorkCollector recoveryCleanupWorkCollector = dependencies.recoveryCleanupWorkCollector();
+        return newInstance( pageCache, storeDir, fs, logProvider, config, operationalMode, recoveryCleanupWorkCollector );
     }
 
-    private NativeSchemaNumberIndexProvider nativeSchemaNumberIndexProvider( KernelContext context,
-            Dependencies dependencies )
+    public static FusionSchemaIndexProvider newInstance( PageCache pageCache, File storeDir, FileSystemAbstraction fs,
+            LogProvider logProvider, Config config, OperationalMode operationalMode,
+            RecoveryCleanupWorkCollector recoveryCleanupWorkCollector )
     {
-        boolean readOnly = isReadOnly( dependencies.getConfig(), context.databaseInfo().operationalMode );
-        LogProvider logging = dependencies.getLogging().getInternalLogProvider();
-        return new NativeSchemaNumberIndexProvider( dependencies.pageCache(),
-                context.storeDir(), logging, dependencies.recoveryCleanupWorkCollector(), readOnly );
+        boolean readOnly = isReadOnly( config, operationalMode );
+        NativeSchemaNumberIndexProvider nativeProvider =
+                new NativeSchemaNumberIndexProvider( pageCache, storeDir, logProvider, recoveryCleanupWorkCollector, readOnly );
+        LuceneSchemaIndexProvider luceneProvider = LuceneSchemaIndexProviderFactory.create( fs, storeDir, logProvider, config,
+                operationalMode );
+        return new FusionSchemaIndexProvider( nativeProvider, luceneProvider, new NativeSelector(), DESCRIPTOR, 50 );
     }
 
     private static boolean isReadOnly( Config config, OperationalMode operationalMode )

community/lucene-index/src/test/java/org/neo4j/index/impl/lucene/legacy/NonUniqueIndexTest.java

@@ -32,8 +32,8 @@
 import org.neo4j.graphdb.Node;
 import org.neo4j.graphdb.Transaction;
 import org.neo4j.graphdb.factory.GraphDatabaseFactoryState;
-import org.neo4j.kernel.api.impl.index.storage.DirectoryFactory;
-import org.neo4j.kernel.api.impl.schema.LuceneSchemaIndexProvider;
+import org.neo4j.io.fs.DefaultFileSystemAbstraction;
+import org.neo4j.kernel.api.impl.schema.LuceneSchemaIndexProviderFactory;
 import org.neo4j.kernel.api.index.IndexAccessor;
 import org.neo4j.kernel.api.index.SchemaIndexProvider;
 import org.neo4j.kernel.api.schema.IndexQuery;
@@ -151,9 +151,11 @@ private static Runnable slowRunnable( final Runnable target )
     private List<Long> nodeIdsInIndex( int indexId, String value ) throws Exception
     {
         Config config = Config.defaults();
-        SchemaIndexProvider indexProvider = new LuceneSchemaIndexProvider( fileSystemRule.get(),
-                DirectoryFactory.PERSISTENT, directory.graphDbDir(), NullLogProvider.getInstance(),
-                Config.defaults(), OperationalMode.single );
+        DefaultFileSystemAbstraction fs = fileSystemRule.get();
+        File storeDir = directory.graphDbDir();
+        NullLogProvider logProvider = NullLogProvider.getInstance();
+        OperationalMode operationalMode = OperationalMode.single;
+        SchemaIndexProvider indexProvider = LuceneSchemaIndexProviderFactory.create( fs, storeDir, logProvider, config, operationalMode );
         IndexSamplingConfig samplingConfig = new IndexSamplingConfig( config );
         try ( IndexAccessor accessor = indexProvider.getOnlineAccessor( indexId,
                 IndexDescriptorFactory.forLabel( 0, 0 ), samplingConfig );

community/lucene-index/src/test/java/org/neo4j/kernel/api/impl/schema/LuceneSchemaIndexProviderCompatibilitySuiteTest.java

@@ -37,7 +37,6 @@ protected LuceneSchemaIndexProvider createIndexProvider( FileSystemAbstraction f
         NullLogProvider logging = NullLogProvider.getInstance();
         Config config = Config.defaults();
         OperationalMode mode = OperationalMode.single;
-        return new LuceneSchemaIndexProvider( fs, directoryFactory, graphDbDir, logging, config, mode );
-
+        return LuceneSchemaIndexProviderFactory.create( fs, graphDbDir, logging, config, mode );
     }
 }

enterprise/ha/src/test/java/org/neo4j/kernel/api/SchemaIndexHaIT.java

@@ -25,8 +25,8 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.NoSuchElementException;
@@ -45,11 +45,12 @@
 import org.neo4j.graphdb.schema.IndexDefinition;
 import org.neo4j.graphdb.schema.Schema.IndexState;
 import org.neo4j.helpers.collection.Iterables;
+import org.neo4j.index.internal.gbptree.RecoveryCleanupWorkCollector;
+import org.neo4j.io.fs.DefaultFileSystemAbstraction;
 import org.neo4j.io.fs.FileSystemAbstraction;
 import org.neo4j.io.pagecache.PageCache;
 import org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException;
-import org.neo4j.kernel.api.impl.index.storage.DirectoryFactory;
-import org.neo4j.kernel.api.impl.schema.LuceneSchemaIndexProvider;
+import org.neo4j.kernel.api.impl.schema.NativeLuceneFusionSchemaIndexProviderFactory;
 import org.neo4j.kernel.api.index.IndexAccessor;
 import org.neo4j.kernel.api.index.IndexEntryUpdate;
 import org.neo4j.kernel.api.index.IndexPopulator;
@@ -64,8 +65,10 @@
 import org.neo4j.kernel.ha.UpdatePuller;
 import org.neo4j.kernel.ha.cluster.HighAvailabilityMemberState;
 import org.neo4j.kernel.impl.api.index.sampling.IndexSamplingConfig;
+import org.neo4j.kernel.impl.factory.OperationalMode;
 import org.neo4j.kernel.impl.ha.ClusterManager;
 import org.neo4j.kernel.impl.ha.ClusterManager.ManagedCluster;
+import org.neo4j.kernel.impl.index.schema.fusion.FusionSchemaIndexProvider;
 import org.neo4j.kernel.impl.spi.KernelContext;
 import org.neo4j.kernel.impl.storemigration.StoreMigrationParticipant;
 import org.neo4j.kernel.lifecycle.Lifecycle;
@@ -540,6 +543,8 @@ interface IndexProviderDependencies
     {
         GraphDatabaseService db();
         Config config();
+        PageCache pageCache();
+        RecoveryCleanupWorkCollector recoveryCleanupWorkCollector();
     }
 
     private static class ControllingIndexProviderFactory extends KernelExtensionFactory<IndexProviderDependencies>
@@ -558,20 +563,26 @@ private static class ControllingIndexProviderFactory extends KernelExtensionFact
         @Override
         public Lifecycle newInstance( KernelContext context, SchemaIndexHaIT.IndexProviderDependencies deps ) throws Throwable
         {
+            PageCache pageCache = deps.pageCache();
+            File storeDir = context.storeDir();
+            DefaultFileSystemAbstraction fs = fileSystemRule.get();
+            NullLogProvider logProvider = NullLogProvider.getInstance();
+            Config config = deps.config();
+            OperationalMode operationalMode = context.databaseInfo().operationalMode;
+            RecoveryCleanupWorkCollector recoveryCleanupWorkCollector = deps.recoveryCleanupWorkCollector();
+
+            FusionSchemaIndexProvider fusionSchemaIndexProvider = NativeLuceneFusionSchemaIndexProviderFactory
+                    .newInstance( pageCache, storeDir, fs, logProvider, config, operationalMode, recoveryCleanupWorkCollector );
+
             if ( injectLatchPredicate.test( deps.db() ) )
             {
-                ControlledSchemaIndexProvider provider = new ControlledSchemaIndexProvider(
-                        new LuceneSchemaIndexProvider( fileSystemRule.get(),
-                                DirectoryFactory.PERSISTENT, context.storeDir(), NullLogProvider.getInstance(),
-                                deps.config(), context.databaseInfo().operationalMode ) );
+                ControlledSchemaIndexProvider provider = new ControlledSchemaIndexProvider( fusionSchemaIndexProvider );
                 perDbIndexProvider.put( deps.db(), provider );
                 return provider;
             }
             else
             {
-                return new LuceneSchemaIndexProvider( fileSystemRule.get(),
-                        DirectoryFactory.PERSISTENT, context.storeDir(), NullLogProvider.getInstance(), deps.config(),
-                        context.databaseInfo().operationalMode );
+                return fusionSchemaIndexProvider;
             }
         }
     }
@@ -594,7 +605,7 @@ private ControlledGraphDatabaseFactory( Predicate<GraphDatabaseService> dbsToCon
         @Override
         public GraphDatabaseBuilder newEmbeddedDatabaseBuilder( File file )
         {
-            getCurrentState().addKernelExtensions( Arrays.asList( factory ) );
+            getCurrentState().addKernelExtensions( Collections.singletonList( factory ) );
             return super.newEmbeddedDatabaseBuilder( file );
         }