Support multiple schema index providers

Introduce kernel extension for Native+Lucene schema index provider

community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java

@@ -45,7 +45,7 @@
 import org.neo4j.kernel.api.labelscan.LabelScanStore;
 import org.neo4j.kernel.api.legacyindex.AutoIndexing;
 import org.neo4j.kernel.configuration.Config;
-import org.neo4j.kernel.extension.dependency.HighestSelectionStrategy;
+import org.neo4j.kernel.extension.dependency.AllByPrioritySelectionStrategy;
 import org.neo4j.kernel.guard.Guard;
 import org.neo4j.kernel.impl.api.CommitProcessFactory;
 import org.neo4j.kernel.impl.api.ConstraintEnforcingEntityOperations;
@@ -69,6 +69,7 @@
 import org.neo4j.kernel.impl.api.TransactionCommitProcess;
 import org.neo4j.kernel.impl.api.TransactionHooks;
 import org.neo4j.kernel.impl.api.index.IndexingService;
+import org.neo4j.kernel.impl.api.index.SchemaIndexProviderMap;
 import org.neo4j.kernel.impl.api.operations.QueryRegistrationOperations;
 import org.neo4j.kernel.impl.api.state.ConstraintIndexCreator;
 import org.neo4j.kernel.impl.constraints.ConstraintSemantics;
@@ -133,6 +134,7 @@
 import org.neo4j.kernel.impl.transaction.log.pruning.LogPruningImpl;
 import org.neo4j.kernel.impl.transaction.log.rotation.LogRotation;
 import org.neo4j.kernel.impl.transaction.log.rotation.LogRotationImpl;
+import org.neo4j.kernel.impl.transaction.state.DefaultSchemaIndexProviderMap;
 import org.neo4j.kernel.impl.transaction.state.NeoStoreFileListing;
 import org.neo4j.kernel.impl.util.Dependencies;
 import org.neo4j.kernel.impl.util.SynchronizedArrayIdOrderingQueue;
@@ -267,7 +269,7 @@ boolean applicable( DiagnosticsPhase phase )
 
     private Dependencies dependencies;
     private LifeSupport life;
-    private SchemaIndexProvider schemaIndexProvider;
+    private SchemaIndexProviderMap schemaIndexProviderMap;
     private File storeDir;
     private boolean readOnly;
     private final IdController idController;
@@ -407,9 +409,17 @@ public void start() throws IOException
 
         life.add( recoveryCleanupWorkCollector );
 
-        schemaIndexProvider = dependencyResolver.resolveDependency( SchemaIndexProvider.class,
-                HighestSelectionStrategy.getInstance() );
-        dependencies.satisfyDependency( schemaIndexProvider );
+        AllByPrioritySelectionStrategy<SchemaIndexProvider> indexProviderSelection =
+                new AllByPrioritySelectionStrategy<>();
+        SchemaIndexProvider defaultIndexProvider = dependencyResolver.resolveDependency( SchemaIndexProvider.class,
+                indexProviderSelection );
+
+        // todo do we really need to have this dependency?
+        dependencies.satisfyDependency( defaultIndexProvider );
+
+        schemaIndexProviderMap = new DefaultSchemaIndexProviderMap( defaultIndexProvider,
+                indexProviderSelection.lowerPrioritizedCandidates() );
+        dependencies.satisfyDependency( schemaIndexProviderMap );
 
         IndexConfigStore indexConfigStore = new IndexConfigStore( storeDir, fs );
         dependencies.satisfyDependency( lockService );
@@ -558,7 +568,7 @@ private void upgradeStore( RecordFormats format )
                 fs,
                 config,
                 logService,
-                schemaIndexProvider,
+                schemaIndexProviderMap,
                 indexProviders,
                 pageCache,
                 format ).migrate( storeDir );
@@ -573,7 +583,7 @@ private StorageEngine buildStorageEngine(
         RecordStorageEngine storageEngine =
                 new RecordStorageEngine( storeDir, config, pageCache, fs, logProvider, propertyKeyTokenHolder,
                         labelTokens, relationshipTypeTokens, schemaState, constraintSemantics, scheduler,
-                        tokenNameLookup, lockService, schemaIndexProvider, indexingServiceMonitor, databaseHealth,
+                        tokenNameLookup, lockService, schemaIndexProviderMap, indexingServiceMonitor, databaseHealth,
                         legacyIndexProviderLookup, indexConfigStore,
                         legacyIndexTransactionOrdering, idGeneratorFactory, idController, monitors, recoveryCleanupWorkCollector,
                         operationalMode );

community/kernel/src/main/java/org/neo4j/kernel/api/index/SchemaIndexProvider.java

@@ -212,7 +212,7 @@ public int hashCode()
     /**
      * Get schema index store root directory in specified store.
      * @param storeDir store root directory
-     * @return shema index store root directory
+     * @return schema index store root directory
      */
     public File getSchemaIndexStoreDirectory( File storeDir )
     {

community/kernel/src/main/java/org/neo4j/kernel/extension/dependency/AllByPrioritySelectionStrategy.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.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.kernel.extension.dependency;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.neo4j.graphdb.DependencyResolver;
+import org.neo4j.helpers.collection.Iterables;
+
+import static org.neo4j.kernel.extension.KernelExtensionUtil.servicesClassPathEntryInformation;
+
+/**
+ * Selects the candidate with highest priority (assumed to implement {@link Comparable}) and returns
+ * in {@link #select(Class, Iterable)}, but keeps the others for access too.
+ */
+public class AllByPrioritySelectionStrategy<T> implements DependencyResolver.SelectionStrategy
+{
+    @SuppressWarnings( "rawtypes" )
+    private List lowerPrioritizedCandidates = Collections.emptyList();
+
+    @SuppressWarnings( {"rawtypes", "unchecked"} )
+    @Override
+    public <R> R select( Class<R> type, Iterable<R> candidates ) throws IllegalArgumentException
+    {
+        List<Comparable> all = (List<Comparable>) Iterables.asList( candidates );
+        if ( all.isEmpty() )
+        {
+            throw new IllegalArgumentException( "Could not resolve dependency of type: " +
+                                                type.getName() + ". " + servicesClassPathEntryInformation() );
+        }
+        Collections.sort( all, Collections.reverseOrder() );
+        R highest = (R) all.remove( 0 );
+        lowerPrioritizedCandidates = all;
+        return highest;
+    }
+
+    @SuppressWarnings( "unchecked" )
+    public Iterable<T> lowerPrioritizedCandidates()
+    {
+        return lowerPrioritizedCandidates;
+    }
+}

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/SchemaIndexProviderMap.java

@@ -19,6 +19,7 @@
  */
 package org.neo4j.kernel.impl.api.index;
 
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 import org.neo4j.kernel.api.index.SchemaIndexProvider;
@@ -29,4 +30,6 @@ public interface SchemaIndexProviderMap extends Function<SchemaIndexProvider.Des
     SchemaIndexProvider apply( SchemaIndexProvider.Descriptor descriptor ) throws IndexProviderNotFoundException;
 
     SchemaIndexProvider getDefaultProvider();
+
+    void accept( Consumer<SchemaIndexProvider> visitor );
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/NativeSchemaNumberIndexPopulator.java

@@ -74,6 +74,7 @@ public abstract class NativeSchemaNumberIndexPopulator<KEY extends SchemaNumberK
     public synchronized void create() throws IOException
     {
         GBPTreeUtil.deleteIfPresent( pageCache, storeFile );
+        pageCache.getCachedFileSystem().mkdirs( storeFile.getParentFile() );
         instantiateTree( RecoveryCleanupWorkCollector.IMMEDIATE, new NativeSchemaIndexHeaderWriter( BYTE_POPULATING ) );
         instantiateWriter();
     }

community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/NativeSchemaNumberIndexProvider.java

@@ -53,12 +53,12 @@ public class NativeSchemaNumberIndexProvider extends SchemaIndexProvider
     private final RecoveryCleanupWorkCollector recoveryCleanupWorkCollector;
     private final boolean readOnly;
 
-    NativeSchemaNumberIndexProvider( PageCache pageCache, File nativeSchemaIndexBaseDir, LogProvider logging,
+    public NativeSchemaNumberIndexProvider( PageCache pageCache, File storeDir, LogProvider logging,
             RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, boolean readOnly )
     {
         super( NATIVE_PROVIDER_DESCRIPTOR, 0 );
         this.pageCache = pageCache;
-        this.nativeSchemaIndexBaseDir = getSchemaIndexStoreDirectory( nativeSchemaIndexBaseDir );
+        this.nativeSchemaIndexBaseDir = getSchemaIndexStoreDirectory( storeDir );
         this.log = logging.getLog( getClass() );
         this.recoveryCleanupWorkCollector = recoveryCleanupWorkCollector;
         this.readOnly = readOnly;

community/kernel/src/main/java/org/neo4j/kernel/impl/index/schema/fusion/FusionSchemaIndexProvider.java

@@ -50,11 +50,10 @@ public interface Selector
     private final SchemaIndexProvider luceneProvider;
     private final Selector selector;
 
-    public FusionSchemaIndexProvider( SchemaIndexProvider nativeProvider, SchemaIndexProvider luceneProvider, Selector selector )
+    public FusionSchemaIndexProvider( SchemaIndexProvider nativeProvider, SchemaIndexProvider luceneProvider, Selector selector,
+            SchemaIndexProvider.Descriptor descriptor, int priority )
     {
-        super( new Descriptor(
-                nativeProvider.getProviderDescriptor().getKey() + "+" + luceneProvider.getProviderDescriptor().getKey(),
-                nativeProvider.getProviderDescriptor().getVersion() + "+" + luceneProvider.getProviderDescriptor().getVersion() ), 0 );
+        super( descriptor, priority );
         this.nativeProvider = nativeProvider;
         this.luceneProvider = luceneProvider;
         this.selector = selector;

community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/RecordStorageEngine.java

@@ -38,7 +38,6 @@
 import org.neo4j.kernel.api.exceptions.TransactionFailureException;
 import org.neo4j.kernel.api.exceptions.schema.ConstraintValidationException;
 import org.neo4j.kernel.api.exceptions.schema.CreateConstraintFailureException;
-import org.neo4j.kernel.api.index.SchemaIndexProvider;
 import org.neo4j.kernel.api.labelscan.LabelScanStore;
 import org.neo4j.kernel.api.labelscan.LabelScanWriter;
 import org.neo4j.kernel.api.txstate.TransactionCountingStateVisitor;
@@ -59,6 +58,7 @@
 import org.neo4j.kernel.impl.api.index.IndexingServiceFactory;
 import org.neo4j.kernel.impl.api.index.IndexingUpdateService;
 import org.neo4j.kernel.impl.api.index.PropertyPhysicalToLogicalConverter;
+import org.neo4j.kernel.impl.api.index.SchemaIndexProviderMap;
 import org.neo4j.kernel.impl.api.scan.FullLabelStream;
 import org.neo4j.kernel.impl.api.store.SchemaCache;
 import org.neo4j.kernel.impl.api.store.StorageLayer;
@@ -89,7 +89,6 @@
 import org.neo4j.kernel.impl.transaction.command.IndexUpdatesWork;
 import org.neo4j.kernel.impl.transaction.command.LabelUpdateWork;
 import org.neo4j.kernel.impl.transaction.command.NeoStoreBatchTransactionApplier;
-import org.neo4j.kernel.impl.transaction.state.DefaultSchemaIndexProviderMap;
 import org.neo4j.kernel.impl.transaction.state.IntegrityValidator;
 import org.neo4j.kernel.impl.transaction.state.Loaders;
 import org.neo4j.kernel.impl.transaction.state.PropertyCreator;
@@ -144,7 +143,7 @@ public class RecordStorageEngine implements StorageEngine, Lifecycle
     private final IntegrityValidator integrityValidator;
     private final CacheAccessBackDoor cacheAccess;
     private final LabelScanStore labelScanStore;
-    private final DefaultSchemaIndexProviderMap schemaIndexProviderMap;
+    private final SchemaIndexProviderMap schemaIndexProviderMap;
     private final LegacyIndexApplierLookup legacyIndexApplierLookup;
     private final SchemaState schemaState;
     private final SchemaStorage schemaStorage;
@@ -181,7 +180,7 @@ public RecordStorageEngine(
             JobScheduler scheduler,
             TokenNameLookup tokenNameLookup,
             LockService lockService,
-            SchemaIndexProvider indexProvider,
+            SchemaIndexProviderMap indexProviderMap,
             IndexingService.Monitor indexingServiceMonitor,
             DatabaseHealth databaseHealth,
             LegacyIndexProviderLookup legacyIndexProviderLookup,
@@ -220,7 +219,7 @@ public RecordStorageEngine(
                     readOnly, monitors, recoveryCleanupWorkCollector );
 
             indexStoreView = new DynamicIndexStoreView( neoStoreIndexStoreView, labelScanStore, lockService, neoStores, logProvider );
-            schemaIndexProviderMap = new DefaultSchemaIndexProviderMap( indexProvider );
+            schemaIndexProviderMap = indexProviderMap;
             indexingService = IndexingServiceFactory.createIndexingService( config, scheduler, schemaIndexProviderMap,
                     indexStoreView, tokenNameLookup,
                     Iterators.asList( new SchemaStorage( neoStores.getSchemaStore() ).indexesGetAll() ), logProvider,

community/kernel/src/main/java/org/neo4j/kernel/impl/storemigration/DatabaseMigrator.java

@@ -24,8 +24,8 @@
 
 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;
+import org.neo4j.kernel.impl.api.index.SchemaIndexProviderMap;
 import org.neo4j.kernel.impl.logging.LogService;
 import org.neo4j.kernel.impl.store.format.RecordFormats;
 import org.neo4j.kernel.impl.storemigration.monitoring.MigrationProgressMonitor;
@@ -49,22 +49,22 @@ public class DatabaseMigrator
     private final FileSystemAbstraction fs;
     private final Config config;
     private final LogService logService;
-    private final SchemaIndexProvider schemaIndexProvider;
+    private final SchemaIndexProviderMap schemaIndexProviderMap;
     private final Map<String,IndexImplementation> indexProviders;
     private final PageCache pageCache;
     private final RecordFormats format;
 
     public DatabaseMigrator(
             MigrationProgressMonitor progressMonitor, FileSystemAbstraction fs,
-            Config config, LogService logService, SchemaIndexProvider schemaIndexProvider,
+            Config config, LogService logService, SchemaIndexProviderMap schemaIndexProviderMap,
             Map<String,IndexImplementation> indexProviders, PageCache pageCache,
             RecordFormats format )
     {
         this.progressMonitor = progressMonitor;
         this.fs = fs;
         this.config = config;
         this.logService = logService;
-        this.schemaIndexProvider = schemaIndexProvider;
+        this.schemaIndexProviderMap = schemaIndexProviderMap;
         this.indexProviders = indexProviders;
         this.pageCache = pageCache;
         this.format = format;
@@ -84,13 +84,13 @@ public void migrate( File storeDir )
         StoreUpgrader storeUpgrader = new StoreUpgrader( upgradableDatabase, progressMonitor, config, fs, pageCache,
                 logProvider );
 
-        StoreMigrationParticipant schemaMigrator = schemaIndexProvider.storeMigrationParticipant( fs, pageCache );
         LegacyIndexMigrator legacyIndexMigrator = new LegacyIndexMigrator( fs, indexProviders, logProvider );
         StoreMigrator storeMigrator = new StoreMigrator( fs, pageCache, config, logService );
         NativeLabelScanStoreMigrator nativeLabelScanStoreMigrator = new NativeLabelScanStoreMigrator( fs, pageCache );
         CountsMigrator countsMigrator = new CountsMigrator( fs, pageCache, config );
 
-        storeUpgrader.addParticipant( schemaMigrator );
+        schemaIndexProviderMap.accept(
+                provider -> storeUpgrader.addParticipant( provider.storeMigrationParticipant( fs, pageCache ) ) );
         storeUpgrader.addParticipant( legacyIndexMigrator );
         storeUpgrader.addParticipant( storeMigrator );
         storeUpgrader.addParticipant( nativeLabelScanStoreMigrator );

community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/state/DefaultSchemaIndexProviderMap.java

@@ -19,34 +19,56 @@
  */
 package org.neo4j.kernel.impl.transaction.state;
 
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+
 import org.neo4j.kernel.api.index.SchemaIndexProvider;
 import org.neo4j.kernel.impl.api.index.SchemaIndexProviderMap;
 
 public class DefaultSchemaIndexProviderMap implements SchemaIndexProviderMap
 {
-    private final SchemaIndexProvider indexProvider;
+    private final SchemaIndexProvider defaultIndexProvider;
+    private final Map<SchemaIndexProvider.Descriptor,SchemaIndexProvider> indexProviders = new HashMap<>();
+
+    public DefaultSchemaIndexProviderMap( SchemaIndexProvider defaultIndexProvider )
+    {
+        this( defaultIndexProvider, Collections.emptyList() );
+    }
 
-    public DefaultSchemaIndexProviderMap( SchemaIndexProvider indexProvider )
+    public DefaultSchemaIndexProviderMap( SchemaIndexProvider defaultIndexProvider,
+            Iterable<SchemaIndexProvider> additionalIndexProviders )
     {
-        this.indexProvider = indexProvider;
+        this.defaultIndexProvider = defaultIndexProvider;
+        indexProviders.put( defaultIndexProvider.getProviderDescriptor(), defaultIndexProvider );
+        additionalIndexProviders.forEach(
+                provider -> indexProviders.put( provider.getProviderDescriptor(), provider ) );
     }
 
     @Override
     public SchemaIndexProvider getDefaultProvider()
     {
-        return indexProvider;
+        return defaultIndexProvider;
     }
 
     @Override
     public SchemaIndexProvider apply( SchemaIndexProvider.Descriptor descriptor )
     {
-        if ( indexProvider.getProviderDescriptor().getKey().equals( descriptor.getKey() ) )
+        SchemaIndexProvider provider = indexProviders.get( descriptor );
+        if ( provider != null )
         {
-            return indexProvider;
+            return provider;
         }
 
         throw new IllegalArgumentException( "Tried to get index provider for an existing index with provider " +
-                descriptor + " whereas the default and only supported provider in this session is " +
-                indexProvider.getProviderDescriptor() );
+                descriptor + " whereas available providers in this session being " + indexProviders +
+                ", and default being " + defaultIndexProvider );
+    }
+
+    @Override
+    public void accept( Consumer<SchemaIndexProvider> visitor )
+    {
+        indexProviders.values().forEach( visitor );
     }
 }

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

@@ -51,7 +51,7 @@ protected void configure( GraphDatabaseFactory databaseFactory )
         {
             List<KernelExtensionFactory<?>> extensions;
             extensions = Collections.singletonList( singleInstanceSchemaIndexProviderFactory( "test", provider ) );
-            ((TestGraphDatabaseFactory) databaseFactory).addKernelExtensions( extensions );
+            ((TestGraphDatabaseFactory) databaseFactory).setKernelExtensions( extensions );
         }
     };
 

community/kernel/src/test/java/org/neo4j/kernel/impl/api/index/IndexCRUDIT.java

@@ -168,11 +168,12 @@ private Node createNode( Map<String, Object> properties, Label ... labels )
     @Before
     public void before() throws Exception
     {
+        when( mockedIndexProvider.getProviderDescriptor() ).thenReturn( PROVIDER_DESCRIPTOR );
         when( mockedIndexProvider.storeMigrationParticipant( any( FileSystemAbstraction.class ), any( PageCache.class ) ) )
                 .thenReturn( StoreMigrationParticipant.NOT_PARTICIPATING );
         TestGraphDatabaseFactory factory = new TestGraphDatabaseFactory();
         factory.setFileSystem( fs.get() );
-        factory.addKernelExtensions(
+        factory.setKernelExtensions(
                 Collections.singletonList( mockedIndexProviderFactory ) );
         db = (GraphDatabaseAPI) factory.newImpermanentDatabase();
         ctxSupplier = db.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class );
@@ -184,7 +185,6 @@ private GatheringIndexWriter newWriter() throws IOException
         when( mockedIndexProvider.getPopulator(
                     anyLong(), any( IndexDescriptor.class ), any( IndexSamplingConfig.class ) )
             ).thenReturn( writer );
-        when( mockedIndexProvider.getProviderDescriptor() ).thenReturn( PROVIDER_DESCRIPTOR );
         when( mockedIndexProvider.getOnlineAccessor(
                     anyLong(), any( IndexDescriptor.class ), any( IndexSamplingConfig.class )
             ) ).thenReturn( writer );