Encapsulate the FulltextFactory for the bloom FTS add-on

enterprise/fulltext-addon/src/main/java/org/neo4j/kernel/api/impl/fulltext/FulltextFactory.java

@@ -25,11 +25,9 @@
 import java.io.File;
 import java.io.IOException;
 import java.util.List;
-import java.util.Set;
 
 import org.neo4j.function.Factory;
 import org.neo4j.io.fs.FileSystemAbstraction;
-import org.neo4j.kernel.api.exceptions.InvalidArgumentsException;
 import org.neo4j.kernel.api.impl.index.IndexWriterConfigs;
 import org.neo4j.kernel.api.impl.index.builder.LuceneIndexStorageBuilder;
 import org.neo4j.kernel.api.impl.index.partition.WritableIndexPartitionFactory;
@@ -38,11 +36,10 @@
 /**
  * Used for creating {@link LuceneFulltext} and registering those to a {@link FulltextProvider}.
  */
-public class FulltextFactory
+class FulltextFactory
 {
     public static final String INDEX_DIR = "fulltext";
     private final FileSystemAbstraction fileSystem;
-    private final FulltextProvider provider;
     private final WritableIndexPartitionFactory partitionFactory;
     private final File indexDir;
     private final Analyzer analyzer;
@@ -53,15 +50,12 @@ public class FulltextFactory
      * @param fileSystem The filesystem to use.
      * @param storeDir Store directory of the database.
      * @param analyzerClassName The Lucene analyzer to use for the {@link LuceneFulltext} created by this factory.
-     * @param provider The {@link FulltextProvider} to register the indexes with.
      * @throws IOException
      */
-    public FulltextFactory( FileSystemAbstraction fileSystem, File storeDir, String analyzerClassName,
-                            FulltextProvider provider ) throws IOException
+    FulltextFactory( FileSystemAbstraction fileSystem, File storeDir, String analyzerClassName ) throws IOException
     {
         this.analyzer = getAnalyzer( analyzerClassName );
         this.fileSystem = fileSystem;
-        this.provider = provider;
         Factory<IndexWriterConfig> indexWriterConfigFactory = () -> IndexWriterConfigs.standard( analyzer );
         partitionFactory = new WritableIndexPartitionFactory( indexWriterConfigFactory );
         indexDir = new File( storeDir, INDEX_DIR );
@@ -82,48 +76,21 @@ private Analyzer getAnalyzer( String analyzerClassName )
         return analyzer;
     }
 
-    /**
-     * Creates an instance of {@link LuceneFulltext} and registers it with the supplied {@link FulltextProvider}.
-     *
-     * @param identifier The identifier of the new fulltext index
-     * @param type The type of the new fulltext index
-     * @param properties The properties to index
-     * @throws IOException
-     */
-    public void createFulltextIndex( String identifier, FulltextProvider.FulltextIndexType type, List<String> properties ) throws IOException
+    LuceneFulltext createFulltextIndex( String identifier, FulltextIndexType type, List<String> properties ) throws IOException
     {
         File indexRootFolder = new File( indexDir, identifier );
         LuceneIndexStorageBuilder storageBuilder = LuceneIndexStorageBuilder.create();
         storageBuilder.withFileSystem( fileSystem ).withIndexFolder( indexRootFolder );
         PartitionedIndexStorage storage = storageBuilder.build();
-        LuceneFulltext index = new LuceneFulltext( storage, partitionFactory, properties, analyzer, identifier, type );
-
-        provider.register( index );
+        return new LuceneFulltext( storage, partitionFactory, properties, analyzer, identifier, type );
     }
 
-    public void openFulltextIndex( String identifier, FulltextProvider.FulltextIndexType type ) throws IOException
+    LuceneFulltext openFulltextIndex( String identifier, FulltextIndexType type ) throws IOException
     {
         File indexRootFolder = new File( indexDir, identifier );
         LuceneIndexStorageBuilder storageBuilder = LuceneIndexStorageBuilder.create();
         storageBuilder.withFileSystem( fileSystem ).withIndexFolder( indexRootFolder );
         PartitionedIndexStorage storage = storageBuilder.build();
-        LuceneFulltext index = new LuceneFulltext( storage, partitionFactory, analyzer, identifier, type );
-
-        provider.register( index );
-    }
-
-    public void changeIndexedProperties( String identifier, FulltextProvider.FulltextIndexType type, List<String> propertyKeys )
-            throws IOException, InvalidArgumentsException
-    {
-        if ( propertyKeys.stream().anyMatch( s -> s.startsWith( FulltextProvider.LUCENE_FULLTEXT_ADDON_PREFIX ) ) )
-        {
-            throw new InvalidArgumentsException( "It is not possible to index property keys starting with " + FulltextProvider.LUCENE_FULLTEXT_ADDON_PREFIX );
-        }
-        Set<String> currentProperties = provider.getProperties( identifier, type );
-        if ( !currentProperties.containsAll( propertyKeys ) || !propertyKeys.containsAll( currentProperties ) )
-        {
-            provider.drop( identifier, type );
-            createFulltextIndex( identifier, type, propertyKeys );
-        }
+        return new LuceneFulltext( storage, partitionFactory, analyzer, identifier, type );
     }
 }

enterprise/fulltext-addon/src/main/java/org/neo4j/kernel/api/impl/fulltext/FulltextIndexType.java

@@ -0,0 +1,43 @@
+/*
+ * 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 Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.kernel.api.impl.fulltext;
+
+/**
+ * Fulltext index type.
+ */
+public enum FulltextIndexType
+{
+    NODES
+            {
+                @Override
+                public String toString()
+                {
+                    return "Nodes";
+                }
+            },
+    RELATIONSHIPS
+            {
+                @Override
+                public String toString()
+                {
+                    return "Relationships";
+                }
+            }
+}

enterprise/fulltext-addon/src/main/java/org/neo4j/kernel/api/impl/fulltext/FulltextProvider.java

@@ -19,10 +19,12 @@
  */
 package org.neo4j.kernel.api.impl.fulltext;
 
+import java.io.File;
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -34,7 +36,9 @@
 import java.util.function.Function;
 
 import org.neo4j.graphdb.GraphDatabaseService;
+import org.neo4j.io.fs.FileSystemAbstraction;
 import org.neo4j.kernel.AvailabilityGuard;
+import org.neo4j.kernel.api.exceptions.InvalidArgumentsException;
 import org.neo4j.kernel.api.index.InternalIndexState;
 import org.neo4j.kernel.impl.transaction.log.TransactionIdStore;
 import org.neo4j.logging.Log;
@@ -57,25 +61,33 @@ public class FulltextProvider implements AutoCloseable
     private final Map<String,WritableFulltext> writableNodeIndices;
     private final Map<String,WritableFulltext> writableRelationshipIndices;
     private final FulltextUpdateApplier applier;
+    private final FulltextFactory factory;
     private final ReadWriteLock configurationLock;
 
     /**
      * Creates a provider of fulltext indices for the given database. This is the entry point for all fulltext index operations.
+     *
+     *
      * @param db Database that this provider should work with.
      * @param log For logging errors.
      * @param availabilityGuard Used for waiting with populating the index until the database is available.
      * @param scheduler For background work.
      * @param transactionIdStore Used for checking if the store has had transactions applied to it, while the fulltext
-     * indexes have been disabled. If so, then the indexes will be rebuilt.
+     * @param fileSystem The filesystem to use.
+     * @param storeDir Store directory of the database.
+     * @param analyzerClassName The Lucene analyzer to use for the {@link LuceneFulltext} created by this factory.
      */
     public FulltextProvider( GraphDatabaseService db, Log log, AvailabilityGuard availabilityGuard,
-                             JobScheduler scheduler, TransactionIdStore transactionIdStore )
+                             JobScheduler scheduler, TransactionIdStore transactionIdStore,
+                             FileSystemAbstraction fileSystem, File storeDir,
+                             String analyzerClassName ) throws IOException
     {
         this.db = db;
         this.log = log;
         this.transactionIdStore = transactionIdStore;
         applier = new FulltextUpdateApplier( log, availabilityGuard, scheduler );
         applier.start();
+        factory = new FulltextFactory( fileSystem, storeDir, analyzerClassName );
         fulltextTransactionEventUpdater = new FulltextTransactionEventUpdater( this, log, applier );
         nodeProperties = ConcurrentHashMap.newKeySet();
         relationshipProperties = ConcurrentHashMap.newKeySet();
@@ -84,7 +96,7 @@ public FulltextProvider( GraphDatabaseService db, Log log, AvailabilityGuard ava
         configurationLock = new ReentrantReadWriteLock( true );
     }
 
-    public void init() throws IOException
+    public void registerTransactionEventHandler() throws IOException
     {
         db.registerTransactionEventHandler( fulltextTransactionEventUpdater );
     }
@@ -108,7 +120,7 @@ private boolean matchesConfiguration( WritableFulltext index ) throws IOExceptio
      *
      * Such population, where the entire store is scanned for data to write to the index, will be started if the index
      * needs to recover after an unclean shut-down, or a configuration change.
-     * @throws IOException If it was not possible to wait for the population to finish, for some reason.
+     * @throws RuntimeException If it was not possible to wait for the population to finish, for some reason.
      */
     public void awaitPopulation()
     {
@@ -126,31 +138,20 @@ public void awaitPopulation()
         }
     }
 
-    /**
-     * Closes the provider and all associated resources.
-     */
-    @Override
-    public void close()
+    public void openIndex( String identifier, FulltextIndexType type ) throws IOException
     {
-        db.unregisterTransactionEventHandler( fulltextTransactionEventUpdater );
-        applier.stop();
-        Consumer<WritableFulltext> fulltextCloser = luceneFulltextIndex ->
-        {
-            try
-            {
-                luceneFulltextIndex.saveConfiguration( transactionIdStore.getLastCommittedTransactionId() );
-                luceneFulltextIndex.close();
-            }
-            catch ( IOException e )
-            {
-                log.error( "Unable to close fulltext index.", e );
-            }
-        };
-        writableNodeIndices.values().forEach( fulltextCloser );
-        writableRelationshipIndices.values().forEach( fulltextCloser );
+        LuceneFulltext index = factory.openFulltextIndex( identifier, type );
+        register( index );
     }
 
-    void register( LuceneFulltext fulltextIndex ) throws IOException
+    public void createIndex( String identifier, FulltextIndexType type, List<String> properties )
+            throws IOException
+    {
+        LuceneFulltext index = factory.createFulltextIndex( identifier, type, properties );
+        register( index );
+    }
+
+    private void register( LuceneFulltext fulltextIndex ) throws IOException
     {
         configurationLock.writeLock().lock();
         try
@@ -222,13 +223,21 @@ Collection<WritableFulltext> writableRelationshipIndices()
      */
     public ReadOnlyFulltext getReader( String identifier, FulltextIndexType type ) throws IOException
     {
-        if ( type == FulltextIndexType.NODES )
+        WritableFulltext writableFulltext = getIndexMap( type ).get( identifier );
+        if ( writableFulltext == null )
         {
-            return writableNodeIndices.get( identifier ).getIndexReader();
+            throw new IllegalArgumentException( "No such " + type + " index '" + identifier + "'." );
         }
-        else
+        return writableFulltext.getIndexReader();
+    }
+
+    private Map<String,WritableFulltext> getIndexMap( FulltextIndexType type )
+    {
+        switch ( type )
         {
-            return writableRelationshipIndices.get( identifier ).getIndexReader();
+        case NODES: return writableNodeIndices;
+        case RELATIONSHIPS: return writableRelationshipIndices;
+        default: throw new IllegalArgumentException( "No such fulltext index type: " + type );
         }
     }
 
@@ -292,26 +301,51 @@ Lock readLockIndexConfiguration()
         return lock;
     }
 
+    public void changeIndexedProperties( String identifier, FulltextIndexType type, List<String> propertyKeys )
+            throws IOException, InvalidArgumentsException
+    {
+        configurationLock.writeLock().lock();
+        try
+        {
+            if ( propertyKeys.stream().anyMatch( s -> s.startsWith( FulltextProvider.LUCENE_FULLTEXT_ADDON_PREFIX ) ) )
+            {
+                throw new InvalidArgumentsException( "It is not possible to index property keys starting with " + FulltextProvider.LUCENE_FULLTEXT_ADDON_PREFIX );
+            }
+            Set<String> currentProperties = getProperties( identifier, type );
+            if ( !currentProperties.containsAll( propertyKeys ) || !propertyKeys.containsAll( currentProperties ) )
+            {
+                drop( identifier, type );
+                createIndex( identifier, type, propertyKeys );
+            }
+        }
+        finally
+        {
+            configurationLock.writeLock().unlock();
+        }
+    }
+
     /**
-     * Fulltext index type.
+     * Closes the provider and all associated resources.
      */
-    public enum FulltextIndexType
+    @Override
+    public void close()
     {
-        NODES
-                {
-                    @Override
-                    public String toString()
-                    {
-                        return "Nodes";
-                    }
-                },
-        RELATIONSHIPS
-                {
-                    @Override
-                    public String toString()
-                    {
-                        return "Relationships";
-                    }
-                }
+        db.unregisterTransactionEventHandler( fulltextTransactionEventUpdater );
+        applier.stop();
+        Consumer<WritableFulltext> fulltextCloser = luceneFulltextIndex ->
+        {
+            try
+            {
+                luceneFulltextIndex.saveConfiguration( transactionIdStore.getLastCommittedTransactionId() );
+                luceneFulltextIndex.close();
+            }
+            catch ( IOException e )
+            {
+                log.error( "Unable to close fulltext index.", e );
+            }
+        };
+        writableNodeIndices.values().forEach( fulltextCloser );
+        writableRelationshipIndices.values().forEach( fulltextCloser );
     }
+
 }

enterprise/fulltext-addon/src/main/java/org/neo4j/kernel/api/impl/fulltext/LuceneFulltext.java

@@ -42,13 +42,13 @@ class LuceneFulltext extends AbstractLuceneIndex
 {
     private final Analyzer analyzer;
     private final String identifier;
-    private final FulltextProvider.FulltextIndexType type;
+    private final FulltextIndexType type;
     private Set<String> properties;
     private volatile InternalIndexState state;
 
     LuceneFulltext( PartitionedIndexStorage indexStorage, IndexPartitionFactory partitionFactory, Collection<String> properties, Analyzer analyzer,
             String identifier,
-                    FulltextProvider.FulltextIndexType type )
+                    FulltextIndexType type )
     {
         super( indexStorage, partitionFactory );
         this.properties = Collections.unmodifiableSet( new HashSet<>( properties ) );
@@ -59,7 +59,7 @@ class LuceneFulltext extends AbstractLuceneIndex
     }
 
     LuceneFulltext( PartitionedIndexStorage indexStorage, WritableIndexPartitionFactory partitionFactory, Analyzer analyzer, String identifier,
-            FulltextProvider.FulltextIndexType type ) throws IOException
+            FulltextIndexType type ) throws IOException
     {
         this( indexStorage, partitionFactory, Collections.EMPTY_SET, analyzer, identifier, type );
         this.properties = readProperties();
@@ -126,7 +126,7 @@ ReadOnlyFulltext getIndexReader() throws IOException
         return hasSinglePartition( partitions ) ? createSimpleReader( partitions ) : createPartitionedReader( partitions );
     }
 
-    FulltextProvider.FulltextIndexType getType()
+    FulltextIndexType getType()
     {
         return type;
     }