package org.apache.maven.index.context;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0    
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import java.io.File;
  import java.io.IOException;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Date;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Set;
  import java.util.concurrent.locks.ReadWriteLock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import org.apache.lucene.analysis.Analyzer;
  import org.apache.lucene.document.Document;
  import org.apache.lucene.document.Field;
  import org.apache.lucene.index.CorruptIndexException;
  import org.apache.lucene.index.IndexFileNameFilter;
  import org.apache.lucene.index.IndexReader;
  import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.index.SerialMergeScheduler;
  import org.apache.lucene.index.Term;
  import org.apache.lucene.search.IndexSearcher;
  import org.apache.lucene.search.TermQuery;
  import org.apache.lucene.search.TopDocs;
  import org.apache.lucene.search.TopScoreDocCollector;
  import org.apache.lucene.store.Directory;
  import org.apache.lucene.store.FSDirectory;
  import org.apache.maven.index.ArtifactInfo;
  import org.apache.maven.index.artifact.GavCalculator;
  import org.apache.maven.index.artifact.M2GavCalculator;
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * The default {@link IndexingContext} implementation.
   * 
   * @author Jason van Zyl
   * @author Tamas Cservenak
   */
  public class DefaultIndexingContext
      extends AbstractIndexingContext
  {
      /**
       * A standard location for indices served up by a webserver.
       */
      private static final String INDEX_DIRECTORY = ".index";
  
      public static final String FLD_DESCRIPTOR = "DESCRIPTOR";
  
      private static final String FLD_DESCRIPTOR_CONTENTS = "NexusIndex";
  
      private static final String FLD_IDXINFO = "IDXINFO";
  
      private static final String VERSION = "1.0";
  
      private static final Term DESCRIPTOR_TERM = new Term( FLD_DESCRIPTOR, FLD_DESCRIPTOR_CONTENTS );
  
      private Directory indexDirectory;
  
      private File indexDirectoryFile;
  
      private String id;
  
      private boolean searchable;
  
      private String repositoryId;
  
      private File repository;
  
      private String repositoryUrl;
  
      private String indexUpdateUrl;
  
      private IndexReader indexReader;
  
      private NexusIndexSearcher indexSearcher;
  
      // disabled for now, see getReadOnlyIndexSearcher() method for explanation
      // private NexusIndexSearcher readOnlyIndexSearcher;
 
     private NexusIndexWriter indexWriter;
 
     private Date timestamp;
 
     private List<? extends IndexCreator> indexCreators;
 
     /**
      * Currently nexus-indexer knows only M2 reposes
      * <p>
      * XXX move this into a concrete Scanner implementation
      */
     private GavCalculator gavCalculator;
 
     private ReadWriteLock indexMaintenanceLock = new ReentrantReadWriteLock();
 
     private Thread bottleWarmerThread;
 
     private DefaultIndexingContext( String id,
                                     String repositoryId,
                                     File repository, //
                                     String repositoryUrl, String indexUpdateUrl,
                                     List<? extends IndexCreator> indexCreators, Directory indexDirectory,
                                     boolean reclaimIndex )
         throws UnsupportedExistingLuceneIndexException, IOException
     {
         this.id = id;
 
         this.searchable = true;
 
         this.repositoryId = repositoryId;
 
         this.repository = repository;
 
         this.repositoryUrl = repositoryUrl;
 
         this.indexUpdateUrl = indexUpdateUrl;
 
         this.indexReader = null;
 
         this.indexWriter = null;
 
         this.indexCreators = indexCreators;
 
         this.indexDirectory = indexDirectory;
 
         // eh?
         // Guice does NOT initialize these, and we have to do manually?
         // While in Plexus, all is well, but when in guice-shim,
         // these objects are still LazyHintedBeans or what not and IndexerFields are NOT registered!
         for ( IndexCreator indexCreator : indexCreators )
         {
             indexCreator.getIndexerFields();
         }
 
         this.gavCalculator = new M2GavCalculator();
 
         prepareIndex( reclaimIndex );
 
         installBottleWarmer();
     }
 
     public DefaultIndexingContext( String id, String repositoryId, File repository, File indexDirectoryFile,
                                    String repositoryUrl, String indexUpdateUrl,
                                    List<? extends IndexCreator> indexCreators, boolean reclaimIndex )
         throws IOException, UnsupportedExistingLuceneIndexException
     {
         this( id, repositoryId, repository, repositoryUrl, indexUpdateUrl, indexCreators,
             FSDirectory.open( indexDirectoryFile ), reclaimIndex );
 
         this.indexDirectoryFile = indexDirectoryFile;
     }
 
     public DefaultIndexingContext( String id, String repositoryId, File repository, Directory indexDirectory,
                                    String repositoryUrl, String indexUpdateUrl,
                                    List<? extends IndexCreator> indexCreators, boolean reclaimIndex )
         throws IOException, UnsupportedExistingLuceneIndexException
     {
         this( id, repositoryId, repository, repositoryUrl, indexUpdateUrl, indexCreators, indexDirectory, reclaimIndex );
 
         if ( indexDirectory instanceof FSDirectory )
         {
             this.indexDirectoryFile = ( (FSDirectory) indexDirectory ).getFile();
         }
     }
 
     public void lock()
     {
         indexMaintenanceLock.readLock().lock();
     }
 
     public void unlock()
     {
         indexMaintenanceLock.readLock().unlock();
     }
 
     public void lockExclusively()
     {
         indexMaintenanceLock.writeLock().lock();
     }
 
     public void unlockExclusively()
     {
         indexMaintenanceLock.writeLock().unlock();
     }
 
     public Directory getIndexDirectory()
     {
         return indexDirectory;
     }
 
     public File getIndexDirectoryFile()
     {
         return indexDirectoryFile;
     }
 
     private void prepareIndex( boolean reclaimIndex )
         throws IOException, UnsupportedExistingLuceneIndexException
     {
         if ( IndexReader.indexExists( indexDirectory ) )
         {
             try
             {
                 // unlock the dir forcibly
                 if ( IndexWriter.isLocked( indexDirectory ) )
                 {
                     IndexWriter.unlock( indexDirectory );
                 }
 
                 openAndWarmup();
 
                 checkAndUpdateIndexDescriptor( reclaimIndex );
             }
             catch ( IOException e )
             {
                 if ( reclaimIndex )
                 {
                     prepareCleanIndex( true );
                 }
                 else
                 {
                     throw e;
                 }
             }
         }
         else
         {
             prepareCleanIndex( false );
         }
 
         timestamp = IndexUtils.getTimestamp( indexDirectory );
     }
 
     private void prepareCleanIndex( boolean deleteExisting )
         throws IOException
     {
         if ( deleteExisting )
         {
             closeReaders();
 
             // unlock the dir forcibly
             if ( IndexWriter.isLocked( indexDirectory ) )
             {
                 IndexWriter.unlock( indexDirectory );
             }
 
             deleteIndexFiles( true );
         }
 
         openAndWarmup();
 
         if ( StringUtils.isEmpty( getRepositoryId() ) )
         {
             throw new IllegalArgumentException( "The repositoryId cannot be null when creating new repository!" );
         }
 
         storeDescriptor();
     }
 
     private void checkAndUpdateIndexDescriptor( boolean reclaimIndex )
         throws IOException, UnsupportedExistingLuceneIndexException
     {
         if ( reclaimIndex )
         {
             // forcefully "reclaiming" the ownership of the index as ours
             storeDescriptor();
             return;
         }
 
         // check for descriptor if this is not a "virgin" index
         if ( getIndexReader().numDocs() > 0 )
         {
             TopScoreDocCollector collector = TopScoreDocCollector.create( 1, false );
 
             getIndexSearcher().search( new TermQuery( DESCRIPTOR_TERM ), collector );
 
             if ( collector.getTotalHits() == 0 )
             {
                 throw new UnsupportedExistingLuceneIndexException( "The existing index has no NexusIndexer descriptor" );
             }
 
             if ( collector.getTotalHits() > 1 )
             {
                 // eh? this is buggy index it seems, just iron it out then
                 storeDescriptor();
                 return;
             }
             else
             {
                 // good, we have one descriptor as should
                 Document descriptor = getIndexSearcher().doc( collector.topDocs().scoreDocs[0].doc );
                 String[] h = StringUtils.split( descriptor.get( FLD_IDXINFO ), ArtifactInfo.FS );
                 // String version = h[0];
                 String repoId = h[1];
 
                 // // compare version
                 // if ( !VERSION.equals( version ) )
                 // {
                 // throw new UnsupportedExistingLuceneIndexException(
                 // "The existing index has version [" + version + "] and not [" + VERSION + "] version!" );
                 // }
 
                 if ( getRepositoryId() == null )
                 {
                     repositoryId = repoId;
                 }
                 else if ( !getRepositoryId().equals( repoId ) )
                 {
                     throw new UnsupportedExistingLuceneIndexException( "The existing index is for repository " //
                         + "[" + repoId + "] and not for repository [" + getRepositoryId() + "]" );
                 }
             }
         }
     }
 
     private void storeDescriptor()
         throws IOException
     {
         Document hdr = new Document();
 
         hdr.add( new Field( FLD_DESCRIPTOR, FLD_DESCRIPTOR_CONTENTS, Field.Store.YES, Field.Index.NOT_ANALYZED ) );
 
         hdr.add( new Field( FLD_IDXINFO, VERSION + ArtifactInfo.FS + getRepositoryId(), Field.Store.YES, Field.Index.NO ) );
 
         IndexWriter w = getIndexWriter();
 
         w.updateDocument( DESCRIPTOR_TERM, hdr );
 
         w.commit();
     }
 
     private void deleteIndexFiles( boolean full )
         throws IOException
     {
         if ( indexDirectory != null )
         {
             String[] names = indexDirectory.listAll();
 
             if ( names != null )
             {
                 IndexFileNameFilter filter = IndexFileNameFilter.getFilter();
 
                 for ( int i = 0; i < names.length; i++ )
                 {
                     if ( filter.accept( null, names[i] ) )
                     {
                         indexDirectory.deleteFile( names[i] );
                     }
                 }
             }
 
             if ( full )
             {
                 if ( indexDirectory.fileExists( INDEX_PACKER_PROPERTIES_FILE ) )
                 {
                     indexDirectory.deleteFile( INDEX_PACKER_PROPERTIES_FILE );
                 }
 
                 if ( indexDirectory.fileExists( INDEX_UPDATER_PROPERTIES_FILE ) )
                 {
                     indexDirectory.deleteFile( INDEX_UPDATER_PROPERTIES_FILE );
                 }
             }
 
             IndexUtils.deleteTimestamp( indexDirectory );
         }
     }
 
     public boolean isSearchable()
     {
         return searchable;
     }
 
     public void setSearchable( boolean searchable )
     {
         this.searchable = searchable;
     }
 
     public String getId()
     {
         return id;
     }
 
     public void updateTimestamp()
         throws IOException
     {
         updateTimestamp( false );
     }
 
     public void updateTimestamp( boolean save )
         throws IOException
     {
         updateTimestamp( save, new Date() );
     }
 
     public void updateTimestamp( boolean save, Date timestamp )
         throws IOException
     {
         this.timestamp = timestamp;
 
         if ( save )
         {
             IndexUtils.updateTimestamp( indexDirectory, getTimestamp() );
         }
     }
 
     public Date getTimestamp()
     {
         return timestamp;
     }
 
     public int getSize()
         throws IOException
     {
         return getIndexReader().numDocs();
     }
 
     public String getRepositoryId()
     {
         return repositoryId;
     }
 
     public File getRepository()
     {
         return repository;
     }
 
     public String getRepositoryUrl()
     {
         return repositoryUrl;
     }
 
     public String getIndexUpdateUrl()
     {
         if ( repositoryUrl != null )
         {
             if ( indexUpdateUrl == null || indexUpdateUrl.trim().length() == 0 )
             {
                 return repositoryUrl + ( repositoryUrl.endsWith( "/" ) ? "" : "/" ) + INDEX_DIRECTORY;
             }
         }
         return indexUpdateUrl;
     }
 
     public Analyzer getAnalyzer()
     {
         return new NexusAnalyzer();
     }
 
     protected void openAndWarmup()
         throws IOException
     {
         // IndexWriter (close)
         if ( indexWriter != null )
         {
             indexWriter.close();
 
             indexWriter = null;
         }
         // IndexSearcher (close only, since we did supply this.indexReader explicitly)
         if ( indexSearcher != null )
         {
             indexSearcher.close();
 
             indexSearcher = null;
         }
         // IndexReader
         if ( indexReader != null )
         {
             indexReader.close();
 
             indexReader = null;
         }
 
         // IndexWriter open
         final boolean create = !IndexReader.indexExists( indexDirectory );
 
         indexWriter = new NexusIndexWriter( getIndexDirectory(), new NexusAnalyzer(), create );
 
         indexWriter.setRAMBufferSizeMB( 2 );
 
         indexWriter.setMergeScheduler( new SerialMergeScheduler() );
 
         indexWriter.commit(); // LUCENE-2386
 
         openAndWarmupReaders();
     }
 
     protected void openAndWarmupReaders()
         throws IOException
     {
         if ( indexReader != null && indexReader.isCurrent() )
         {
             return;
         }
 
         // IndexReader open
         IndexReader newIndexReader = IndexReader.open( indexDirectory, true );
 
         // IndexSearcher open, but with new reader
         NexusIndexSearcher newIndexSearcher = new NexusIndexSearcher( this, newIndexReader );
 
         // warm up
         warmUp( newIndexSearcher );
 
         lockExclusively();
 
         try
         {
             // IndexSearcher (close only, since we did supply this.indexReader explicitly)
             if ( indexSearcher != null )
             {
                 indexSearcher.close();
             }
             // IndexReader
             if ( indexReader != null )
             {
                 indexReader.close();
             }
 
             indexReader = newIndexReader;
 
             indexSearcher = newIndexSearcher;
         }
         finally
         {
             unlockExclusively();
         }
     }
 
     protected void warmUp( NexusIndexSearcher searcher )
         throws IOException
     {
         try
         {
             // TODO: figure this out better and non blocking
             searcher.search( new TermQuery( new Term( "g", "org.apache" ) ), 1000 );
         }
         catch ( IOException e )
         {
             close( false );
 
             throw e;
         }
     }
 
     public IndexWriter getIndexWriter()
         throws IOException
     {
         lock();
 
         try
         {
             return indexWriter;
         }
         finally
         {
             unlock();
         }
     }
 
     public IndexReader getIndexReader()
         throws IOException
     {
         lock();
 
         try
         {
             return indexReader;
         }
         finally
         {
             unlock();
         }
     }
 
     public IndexSearcher getIndexSearcher()
         throws IOException
     {
         lock();
 
         try
         {
             return indexSearcher;
         }
         finally
         {
             unlock();
         }
     }
 
     public void commit()
         throws IOException
     {
         // TODO: detect is writer "dirty"?
         if ( true )
         {
             if ( BLOCKING_COMMIT )
             {
                 lockExclusively();
             }
             else
             {
                 lock();
             }
 
             try
             {
                 doCommit( BLOCKING_COMMIT );
             }
             finally
             {
                 if ( BLOCKING_COMMIT )
                 {
                     unlockExclusively();
                 }
                 else
                 {
                     unlock();
                 }
             }
         }
     }
 
     protected void doCommit( boolean blocking )
         throws IOException
     {
         try
         {
             // TODO: is this needed? Why not put the commit() call into synchronized
             // since all callers of doCommit() aside of commit() already possess exclusive lock
             synchronized ( this )
             {
                 getIndexWriter().commit();
             }
 
             // TODO: define some treshold or requirement
             // for reopening readers (is expensive)
             // For example: by inserting 1 record among 1M, do we really want to reopen?
             if ( true )
             {
                 if ( blocking )
                 {
                     openAndWarmupReaders();
                 }
                 else
                 {
                     flagNeedsReopen();
                 }
             }
         }
         catch ( CorruptIndexException e )
         {
             close( false );
 
             throw e;
         }
         catch ( IOException e )
         {
             close( false );
 
             throw e;
         }
     }
 
     public void rollback()
         throws IOException
     {
         // detect is writer "dirty"?
         if ( true )
         {
             lock();
 
             try
             {
                 IndexWriter w = getIndexWriter();
 
                 try
                 {
                     synchronized ( this )
                     {
                         w.rollback();
                     }
                 }
                 catch ( CorruptIndexException e )
                 {
                     close( false );
 
                     throw e;
                 }
                 catch ( IOException e )
                 {
                     close( false );
 
                     throw e;
                 }
             }
             finally
             {
                 unlock();
             }
         }
     }
 
     public void optimize()
         throws CorruptIndexException, IOException
     {
         lockExclusively();
 
         try
         {
             IndexWriter w = getIndexWriter();
 
             try
             {
                 w.optimize();
 
                 doCommit( true );
             }
             catch ( CorruptIndexException e )
             {
                 close( false );
 
                 throw e;
             }
             catch ( IOException e )
             {
                 close( false );
 
                 throw e;
             }
         }
         finally
         {
             unlockExclusively();
         }
     }
 
     public void close( boolean deleteFiles )
         throws IOException
     {
         lockExclusively();
 
         try
         {
             if ( indexDirectory != null )
             {
                 IndexUtils.updateTimestamp( indexDirectory, getTimestamp() );
 
                 closeReaders();
 
                 if ( deleteFiles )
                 {
                     deleteIndexFiles( true );
                 }
 
                 indexDirectory.close();
             }
 
             // TODO: this will prevent from reopening them, but needs better solution
             // Needed to make bottleWarmerThread die off
             indexDirectory = null;
         }
         finally
         {
             unlockExclusively();
         }
     }
 
     public void purge()
         throws IOException
     {
         lockExclusively();
 
         try
         {
             closeReaders();
 
             deleteIndexFiles( true );
 
             openAndWarmup();
 
             try
             {
                 prepareIndex( true );
             }
             catch ( UnsupportedExistingLuceneIndexException e )
             {
                 // just deleted it
             }
 
             rebuildGroups();
 
             updateTimestamp( true, null );
         }
         finally
         {
             unlockExclusively();
         }
     }
 
     public void replace( Directory directory )
         throws IOException
     {
         lockExclusively();
 
         try
         {
             Date ts = IndexUtils.getTimestamp( directory );
 
             closeReaders();
 
             deleteIndexFiles( false );
 
             IndexUtils.copyDirectory( directory, indexDirectory );
 
             openAndWarmup();
 
             // reclaim the index as mine
             storeDescriptor();
 
             updateTimestamp( true, ts );
 
             optimize();
         }
         finally
         {
             unlockExclusively();
         }
     }
 
     public void merge( Directory directory )
         throws IOException
     {
         merge( directory, null );
     }
 
     public void merge( Directory directory, DocumentFilter filter )
         throws IOException
     {
         lockExclusively();
 
         try
         {
             IndexWriter w = getIndexWriter();
 
             IndexSearcher s = getIndexSearcher();
 
             IndexReader directoryReader = IndexReader.open( directory, true );
 
             TopScoreDocCollector collector = null;
 
             try
             {
                 int numDocs = directoryReader.maxDoc();
 
                 for ( int i = 0; i < numDocs; i++ )
                 {
                     if ( directoryReader.isDeleted( i ) )
                     {
                         continue;
                     }
 
                     Document d = directoryReader.document( i );
 
                     if ( filter != null && !filter.accept( d ) )
                     {
                         continue;
                     }
 
                     String uinfo = d.get( ArtifactInfo.UINFO );
 
                     if ( uinfo != null )
                     {
                         collector = TopScoreDocCollector.create( 1, false );
 
                         s.search( new TermQuery( new Term( ArtifactInfo.UINFO, uinfo ) ), collector );
 
                         if ( collector.getTotalHits() == 0 )
                         {
                             w.addDocument( IndexUtils.updateDocument( d, this, false ) );
                         }
                     }
                     else
                     {
                         String deleted = d.get( ArtifactInfo.DELETED );
 
                         if ( deleted != null )
                         {
                             // Deleting the document loses history that it was delete,
                             // so incrementals wont work. Therefore, put the delete
                             // document in as well
                             w.deleteDocuments( new Term( ArtifactInfo.UINFO, deleted ) );
                             w.addDocument( d );
                         }
                     }
                 }
 
             }
             finally
             {
                 directoryReader.close();
 
                 doCommit( true );
             }
 
             rebuildGroups();
 
             Date mergedTimestamp = IndexUtils.getTimestamp( directory );
 
             if ( getTimestamp() != null && mergedTimestamp != null && mergedTimestamp.after( getTimestamp() ) )
             {
                 // we have both, keep the newest
                 updateTimestamp( true, mergedTimestamp );
             }
             else
             {
                 updateTimestamp( true );
             }
 
             optimize();
         }
         finally
         {
             unlockExclusively();
         }
     }
 
     private void closeReaders()
         throws CorruptIndexException, IOException
     {
         if ( indexWriter != null )
         {
             indexWriter.close();
 
             indexWriter = null;
         }
         if ( indexSearcher != null )
         {
             indexSearcher.close();
 
             indexSearcher = null;
         }
         if ( indexReader != null )
         {
             indexReader.close();
 
             indexReader = null;
         }
     }
 
     public GavCalculator getGavCalculator()
     {
         return gavCalculator;
     }
 
     public List<IndexCreator> getIndexCreators()
     {
         return Collections.unmodifiableList( indexCreators );
     }
 
     // groups
 
     public void rebuildGroups()
         throws IOException
     {
         lockExclusively();
 
         try
         {
             IndexReader r = getIndexReader();
 
             Set<String> rootGroups = new LinkedHashSet<String>();
             Set<String> allGroups = new LinkedHashSet<String>();
 
             int numDocs = r.maxDoc();
 
             for ( int i = 0; i < numDocs; i++ )
             {
                 if ( r.isDeleted( i ) )
                 {
                     continue;
                 }
 
                 Document d = r.document( i );
 
                 String uinfo = d.get( ArtifactInfo.UINFO );
 
                 if ( uinfo != null )
                 {
                     ArtifactInfo info = IndexUtils.constructArtifactInfo( d, this );
                     rootGroups.add( info.getRootGroup() );
                     allGroups.add( info.groupId );
                 }
             }
 
             setRootGroups( rootGroups );
             setAllGroups( allGroups );
 
             optimize();
         }
         finally
         {
             unlockExclusively();
         }
     }
 
     public Set<String> getAllGroups()
         throws IOException
     {
         lock();
 
         try
         {
             return getGroups( ArtifactInfo.ALL_GROUPS, ArtifactInfo.ALL_GROUPS_VALUE, ArtifactInfo.ALL_GROUPS_LIST );
         }
         finally
         {
             unlock();
         }
     }
 
     public void setAllGroups( Collection<String> groups )
         throws IOException
     {
         lockExclusively();
 
         try
         {
             setGroups( groups, ArtifactInfo.ALL_GROUPS, ArtifactInfo.ALL_GROUPS_VALUE, ArtifactInfo.ALL_GROUPS_LIST );
 
             doCommit( true );
         }
         finally
         {
             unlockExclusively();
         }
     }
 
     public Set<String> getRootGroups()
         throws IOException
     {
         lock();
 
         try
         {
             return getGroups( ArtifactInfo.ROOT_GROUPS, ArtifactInfo.ROOT_GROUPS_VALUE, ArtifactInfo.ROOT_GROUPS_LIST );
         }
         finally
         {
             unlock();
         }
     }
 
     public void setRootGroups( Collection<String> groups )
         throws IOException
     {
         lockExclusively();
 
         try
         {
             setGroups( groups, ArtifactInfo.ROOT_GROUPS, ArtifactInfo.ROOT_GROUPS_VALUE, ArtifactInfo.ROOT_GROUPS_LIST );
 
             doCommit( true );
         }
         finally
         {
             unlockExclusively();
         }
     }
 
     protected Set<String> getGroups( String field, String filedValue, String listField )
         throws IOException, CorruptIndexException
     {
         TopScoreDocCollector collector = TopScoreDocCollector.create( 1, false );
 
         getIndexSearcher().search( new TermQuery( new Term( field, filedValue ) ), collector );
 
         TopDocs topDocs = collector.topDocs();
 
         Set<String> groups = new LinkedHashSet<String>( Math.max( 10, topDocs.totalHits ) );
 
         if ( topDocs.totalHits > 0 )
         {
             Document doc = getIndexSearcher().doc( topDocs.scoreDocs[0].doc );
 
             String groupList = doc.get( listField );
 
             if ( groupList != null )
             {
                 groups.addAll( Arrays.asList( groupList.split( "\\|" ) ) );
             }
         }
 
         return groups;
     }
 
     protected void setGroups( Collection<String> groups, String groupField, String groupFieldValue,
                               String groupListField )
         throws IOException, CorruptIndexException
     {
         IndexWriter w = getIndexWriter();
 
         w.updateDocument( new Term( groupField, groupFieldValue ),
             createGroupsDocument( groups, groupField, groupFieldValue, groupListField ) );
     }
 
     protected Document createGroupsDocument( Collection<String> groups, String field, String fieldValue,
                                              String listField )
     {
         Document groupDoc = new Document();
 
         groupDoc.add( new Field( field, //
             fieldValue, Field.Store.YES, Field.Index.NOT_ANALYZED ) );
 
         groupDoc.add( new Field( listField, //
             ArtifactInfo.lst2str( groups ), Field.Store.YES, Field.Index.NO ) );
 
         return groupDoc;
     }
 
     @Override
     public String toString()
     {
         return id + " : " + timestamp;
     }
 
     // ==
 
     private volatile boolean needsReaderReopen = false;
 
     protected void flagNeedsReopen()
     {
         needsReaderReopen = true;
     }
 
     protected void unflagNeedsReopen()
     {
         needsReaderReopen = false;
     }
 
     protected boolean isReopenNeeded()
     {
         return needsReaderReopen;
     }
 
     protected void installBottleWarmer()
     {
         if ( BLOCKING_COMMIT )
         {
             return;
         }
 
         Runnable bottleWarmer = new Runnable()
         {
             public void run()
             {
                 // die off when context is closed
                 while ( indexDirectory != null )
                 {
                     try
                     {
                         if ( isReopenNeeded() )
                         {
                             openAndWarmupReaders();
 
                             unflagNeedsReopen();
                         }
 
                         Thread.sleep( 1000 );
                     }
                     catch ( Exception e )
                     {
                         e.printStackTrace();
                     }
                 }
             }
         };
 
         bottleWarmerThread = new Thread( bottleWarmer, "Index-BottleWarmer-" + id );
         bottleWarmerThread.setDaemon( true );
         bottleWarmerThread.start();
     }
 
     /**
      * A flag useful for tests, to make this IndexingContext implementation blocking. If this flag is true, context will
      * block the commit() calls and will return from it when Lucene commit done AND all the readers are reopened and are
      * current. TODO: this is currently inherently unsafe (is not final), and is meant to be used in Unit tests only!
      * Think something and tie this knot properly.
      */
     public static boolean BLOCKING_COMMIT = false;
 }