source.dussan.org Git - archiva.git/blob

   1 package org.apache.maven.repository.indexing;
   2
   3 /*
   4  * Copyright 2005-2006 The Apache Software Foundation.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 import org.apache.lucene.analysis.Analyzer;
  20 import org.apache.lucene.analysis.SimpleAnalyzer;
  21 import org.apache.lucene.index.IndexReader;
  22 import org.apache.lucene.index.IndexWriter;
  23 import org.apache.lucene.index.Term;
  24 import org.apache.maven.artifact.repository.ArtifactRepository;
  25
  26 import java.io.File;
  27 import java.io.IOException;
  28 import java.util.Collection;
  29
  30 /**
  31  * Abstract class for RepositoryIndexers
  32  *
  33  * @author Edwin Punzalan
  34  */
  35 public abstract class AbstractRepositoryIndex
  36     implements RepositoryIndex
  37 {
  38     private String indexPath;
  39
  40     private boolean indexOpen;
  41
  42     private IndexWriter indexWriter;
  43
  44     protected ArtifactRepository repository;
  45
  46     protected boolean indexExists;
  47
  48     private Analyzer analyzer;
  49
  50     /**
  51      * Class constructor
  52      *
  53      * @param indexPath
  54      * @param repository
  55      * @throws RepositoryIndexException
  56      */
  57     protected AbstractRepositoryIndex( String indexPath, ArtifactRepository repository )
  58         throws RepositoryIndexException
  59     {
  60         this.repository = repository;
  61         this.indexPath = indexPath;
  62     }
  63
  64     /**
  65      * Method to open the IndexWriter
  66      *
  67      * @throws RepositoryIndexException
  68      */
  69     public void open()
  70         throws RepositoryIndexException
  71     {
  72         try
  73         {
  74             if ( indexExists )
  75             {
  76                 indexWriter = new IndexWriter( indexPath, getAnalyzer(), false );
  77             }
  78             else
  79             {
  80                 indexWriter = new IndexWriter( indexPath, getAnalyzer(), true );
  81             }
  82         }
  83         catch ( IOException ie )
  84         {
  85             throw new RepositoryIndexException( ie );
  86         }
  87         indexOpen = true;
  88     }
  89
  90     /**
  91      * @see org.apache.maven.repository.indexing.RepositoryIndex#optimize()
  92      */
  93     public void optimize()
  94         throws RepositoryIndexException
  95     {
  96         if ( !indexOpen )
  97         {
  98             throw new RepositoryIndexException( "Unable to optimize index on a closed index" );
  99         }
 100
 101         try
 102         {
 103             indexWriter.optimize();
 104         }
 105         catch ( IOException ioe )
 106         {
 107             throw new RepositoryIndexException( "Failed to optimize index", ioe );
 108         }
 109     }
 110
 111     /**
 112      * @see org.apache.maven.repository.indexing.RepositoryIndex#isOpen()
 113      */
 114     public boolean isOpen()
 115     {
 116         return indexOpen;
 117     }
 118
 119     /**
 120      * @see org.apache.maven.repository.indexing.RepositoryIndex#close()
 121      */
 122     public void close()
 123         throws RepositoryIndexException
 124     {
 125         try
 126         {
 127             if ( indexWriter != null )
 128             {
 129                 indexWriter.close();
 130                 indexWriter = null;
 131             }
 132
 133             indexOpen = false;
 134         }
 135         catch ( IOException e )
 136         {
 137             throw new RepositoryIndexException( e.getMessage(), e );
 138         }
 139     }
 140
 141     /**
 142      * @see org.apache.maven.repository.indexing.RepositoryIndex#getIndexPath()
 143      */
 144     public String getIndexPath()
 145     {
 146         return indexPath;
 147     }
 148
 149     /**
 150      * Method to retrieve the lucene IndexWriter used in creating/updating the index
 151      *
 152      * @return the lucene IndexWriter object used to update the index
 153      * @throws IOException
 154      */
 155     protected IndexWriter getIndexWriter()
 156         throws IOException
 157     {
 158         if ( indexWriter == null )
 159         {
 160             indexWriter = new IndexWriter( indexPath, getAnalyzer(), false );
 161         }
 162         return indexWriter;
 163     }
 164
 165     /**
 166      * method for validating an index directory
 167      *
 168      * @param indexFields
 169      * @throws RepositoryIndexException if the given indexPath is not valid for this type of RepositoryIndex
 170      */
 171     protected void validateIndex( String[] indexFields )
 172         throws RepositoryIndexException, IOException
 173     {
 174         IndexReader indexReader = IndexReader.open( indexPath );
 175         try
 176         {
 177             if ( indexReader.numDocs() > 0 )
 178             {
 179                 Collection fields = indexReader.getFieldNames();
 180                 for ( int idx = 0; idx < indexFields.length; idx++ )
 181                 {
 182                     if ( !fields.contains( indexFields[idx] ) )
 183                     {
 184                         throw new RepositoryIndexException(
 185                             "The Field " + indexFields[idx] + " does not exist in index " + indexPath + "." );
 186                     }
 187                 }
 188             }
 189         }
 190         finally
 191         {
 192             indexReader.close();
 193         }
 194     }
 195
 196     /**
 197      * @see org.apache.maven.repository.indexing.RepositoryIndex#getRepository()
 198      */
 199     public ArtifactRepository getRepository()
 200     {
 201         return repository;
 202     }
 203
 204     /**
 205      * Delete the document(s) that contains the specified value on the specified field.
 206      *
 207      * @param field
 208      * @param value
 209      * @throws RepositoryIndexException
 210      * @throws IOException
 211      */
 212     protected void deleteDocument( String field, String value )
 213         throws RepositoryIndexException, IOException
 214     {
 215         IndexReader indexReader = null;
 216         try
 217         {
 218             indexReader = IndexReader.open( indexPath );
 219             indexReader.delete( new Term( field, value ) );
 220         }
 221         catch ( IOException ie )
 222         {
 223             throw new RepositoryIndexException( indexPath + "is not a valid directory." );
 224         }
 225         finally
 226         {
 227             if ( indexReader != null )
 228             {
 229                 indexReader.close();
 230             }
 231         }
 232     }
 233
 234     /**
 235      * Check if the index already exists.
 236      *
 237      * @throws IOException
 238      * @throws RepositoryIndexException
 239      */
 240     protected void checkIfIndexExists()
 241         throws IOException, RepositoryIndexException
 242     {
 243         File indexDir = new File( indexPath );
 244
 245         if ( IndexReader.indexExists( indexDir ) )
 246         {
 247             indexExists = true;
 248         }
 249         else if ( !indexDir.exists() )
 250         {
 251             indexExists = false;
 252         }
 253         else if ( indexDir.isDirectory() )
 254         {
 255             throw new RepositoryIndexException( indexPath + " is not a valid index directory." );
 256         }
 257         else
 258         {
 259             throw new RepositoryIndexException( indexPath + " is not a directory." );
 260         }
 261     }
 262
 263     /**
 264      * Checks if the object has already been indexed.
 265      *
 266      * @param object the object to be indexed.
 267      * @throws RepositoryIndexException
 268      * @throws IOException
 269      */
 270     abstract void isIndexed( Object object )
 271         throws RepositoryIndexException, IOException;
 272
 273     /**
 274      * @see org.apache.maven.repository.indexing.RepositoryIndex#getAnalyzer()
 275      */
 276     public Analyzer getAnalyzer()
 277     {
 278         if ( analyzer == null )
 279         {
 280             analyzer = new ArtifactRepositoryIndexAnalyzer( new SimpleAnalyzer() );
 281         }
 282
 283         return analyzer;
 284     }
 285
 286     /**
 287      * @see RepositoryIndex#isKeywordField(String)
 288      */
 289     public boolean isKeywordField( String field )
 290     {
 291         return KEYWORD_FIELDS.contains( field );
 292     }
 293 }