Changeset 32620 for main/trunk

Timestamp:

2018-11-20T21:35:42+13:00 (5 years ago)

Author:

ak19

Message:

Directly related to previous commit revision. 3 significant changes in 1 commit particularly impacting Lucene queries: 1. Instead if GS2LuceneSearch havinga GS2LuceneQuery object member variable for doing each and every search, each query now instantiates its own local GS2LuceneQuery object, configures it for that specific search, runs the search and then the GS2LuceneQuery object expires. This fixes a bug by preventing multiple concurrent searches getting the search configurations of other searches run at the same time. 2. Though GS2LuceneQuery objects need to be instantiated 1 per query over a collection, we don't want to keep reopening a collection's sidx and didx index folders with IndexReader objects for every query. Since IndexReaders support concurrent access, we'd like to use one IndexReader per collection index (one for didx, one for sidx) with the IndexReaders existing for the life of a collection. This meant moving the maintaining of IndexReader objects from GS2LuceneQuery into the GS2LuceneSearch service and turning them into singletons by using a HashMap to maintain index-dir, reader pairs. GS3 Services, e.g. GS2LuceneSearch, are loaded and unloaded on collection activate and deactivate respectively. On deactivate, cleanUp() is called on services and other GS3 modules. When GS2LuceneSearch.cleanUp() is called, we now finally close the singleton IndexReader objects/resources that a collection's GS2LuceneSearch object maintains. 3. Redid previous bugfix (then committed to GS2LuceneQuery): Point 2 again solves the filelocking problem of multiple handles to the index being opened and not all being closed on deactivate, but it's solved in a different and better/more optimal way than in the previous commit.

File:

• main/trunk/greenstone2/common-src/indexers/lucene-gs/src/org/greenstone/LuceneWrapper4/GS2LuceneQuery.java (modified) (6 diffs)

main/trunk/greenstone2/common-src/indexers/lucene-gs/src/org/greenstone/LuceneWrapper4/GS2LuceneQuery.java

@@ -44 +44 @@
 import org.apache.lucene.search.ConstantScoreQuery;
 import org.apache.lucene.search.Filter;
-import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.IndexSearcher; // Searcher is deprecated
 import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.MultiTermQuery.ConstantScoreAutoRewrite;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.TermRangeFilter;
-import org.apache.lucene.search.IndexSearcher; // Searcher is deprecated
 import org.apache.lucene.search.ScoreDoc;
 import org.apache.lucene.search.Sort;
@@ -80 +79 @@
     protected QueryParser query_parser_no_stop_words = null;
     protected IndexSearcher searcher = null;
-    protected IndexReader reader = null;
+    protected IndexReader reader = null; // reference to a Reader resource. GS2LuceneQuery doesn't maintain it, GS2LuceneSearch maintains it!
+        // GS2LuceneSearch locally instantiates one GS2LuceneQuery object per query then allows each Query instance use a relevant Reader.
+        // But GS2LuceneSearch opens the IndexReaders and, more importantly, closes them all when a collection is deactivated.
 
     public GS2LuceneQuery() {
@@ -89 +90 @@
     query_parser = new QueryParser(GSLuceneConstants.MATCH_VERSION, TEXTFIELD, new GS2Analyzer()); // uses built-in stop_words_set
         query_parser_no_stop_words = new QueryParser(GSLuceneConstants.MATCH_VERSION, TEXTFIELD, new GS2Analyzer(new String[] { }));
-    }
-    
-    
-    public boolean initialise() {
-
-    if (!super.initialise()) {
-        return false;
-    }
+    }   
+    
+    public boolean initialise(IndexReader reader) {
+
+        if (!super.initialise()) {
+            return false;
+        }
 
 
@@ -104 +104 @@
         return false;
         }
-
-        try {   
         
-            if(reader != null) {
-                    reader.close();
-                    searcher = null;
-            }   
-            
-        Directory full_indexdir_dir = FSDirectory.open(new File(full_indexdir));
-
-        reader = DirectoryReader.open(full_indexdir_dir); // Returns a IndexReader reading the index in the given Directory. now readOnly=true by default, and therefore also for searcher
-        searcher = new IndexSearcher(reader); // during searcher.search() will get it to compute ranks when sorting by fields
-        
-        this.sorter = new Sort(new SortField(this.sort_field, this.sort_type, this.reverse_sort));
-    }
-    catch (IOException exception) {
-            exception.printStackTrace();
-        return false;
-        }
-    return true;
-
+        if(reader == null) {
+            return false;
+        }
+        else {
+            this.reader = reader;
+            this.searcher = new IndexSearcher(reader); // during searcher.search() will get it to compute ranks when sorting by fields
+            this.sorter = new Sort(new SortField(this.sort_field, this.sort_type, this.reverse_sort));      
+            return true;
+        }
     }
 
@@ -170 +159 @@
     LuceneQueryResult lucene_query_result=new LuceneQueryResult();
     lucene_query_result.clear();
-        
+    
+    if(this.reader == null) {
+        System.err.println("#### Reader is null!");
+    }
+    
     try {               
         Query query_including_stop_words = query_parser_no_stop_words.parse(query_string);
@@ -348 +341 @@
     }
      
-       
+    // This version of the cleanUp() method is just to clean up anything associated only with this instance of GS2LuceneQuery.
+    // So it won't clean up the singleton IndexReader instances maintained by the encapsulating GS2LuceneSearch class.
     public void cleanUp() {
-    super.cleanUp();
-    try {
-        if(reader != null) {
-        reader.close();
-        // Closes files associated with this index. Also saves any new deletions to disk. 
-        // No other methods should be called after this has been called. 
-        }
+        super.cleanUp();
         
-    } catch (IOException exception) {
-        exception.printStackTrace();
-    }
-    }
-
+        searcher = null;
+    
+        // Don't close the indexReader reference here.
+        // This has moved into the GS2LuceneSearch.cleanUp() method, as it maintains singleton IndexReaders
+        // for each index level (sidx, didix) with lifespans matching their collection's lifespan
+        // A collection's GS2LuceneSearch object lives for the duration of the Collection.
+        // A GS2LuceneQuery object is ephemeral: only lives for the duration of a query, allowing multiple
+        // users to queries concurrently, sharing a single IndexReader object for each indexing level
+        // as IndexReader support concurrency.
+    }
 
     protected Query parseQuery(IndexReader reader, QueryParser query_parser, String query_string, String fuzziness)