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.index.IndexReader;
  20 import org.apache.lucene.index.IndexWriter;
  21
  22 import java.io.File;
  23 import java.io.IOException;
  24 import java.util.Collection;
  25
  26 /**
  27  * Abstract class for RepositoryIndexers
  28  *
  29  * @author Edwin Punzalan
  30  */
  31 public abstract class AbstractRepositoryIndex
  32     implements RepositoryIndex
  33 {
  34     protected String indexPath;
  35
  36     protected boolean indexOpen;
  37
  38     protected IndexReader indexReader;
  39
  40     protected IndexWriter indexWriter;
  41
  42     /**
  43      * method to encapsulate the optimize() method for lucene
  44      */
  45     public void optimize()
  46         throws RepositoryIndexException
  47     {
  48         if ( !isOpen() )
  49         {
  50             throw new RepositoryIndexException( "Unable to optimize index on a closed index" );
  51         }
  52
  53         try
  54         {
  55             indexWriter.optimize();
  56         }
  57         catch ( IOException ioe )
  58         {
  59             throw new RepositoryIndexException( "Failed to optimize index", ioe );
  60         }
  61     }
  62
  63     /**
  64      * method used to query the index status
  65      *
  66      * @param true if the index is open.
  67      */
  68     public boolean isOpen()
  69     {
  70         return indexOpen;
  71     }
  72
  73     /**
  74      * method used to close all open streams to the index directory
  75      */
  76     public void close()
  77         throws RepositoryIndexException
  78     {
  79         try
  80         {
  81             if ( indexWriter != null )
  82             {
  83                 indexWriter.close();
  84                 indexWriter = null;
  85             }
  86
  87             if ( indexReader != null )
  88             {
  89                 indexReader.close();
  90                 indexReader = null;
  91             }
  92
  93             indexOpen = false;
  94         }
  95         catch ( Exception e )
  96         {
  97             throw new RepositoryIndexException( e );
  98         }
  99     }
 100
 101     /**
 102      * method for opening the index directory for indexing operations
 103      */
 104     public void open( String indexPath )
 105         throws RepositoryIndexException
 106     {
 107         try
 108         {
 109             this.indexPath = indexPath;
 110             validateIndex();
 111         }
 112         catch ( IOException e )
 113         {
 114             throw new RepositoryIndexException( e );
 115         }
 116     }
 117
 118     public String getIndexPath()
 119     {
 120         return indexPath;
 121     }
 122
 123     protected void getIndexWriter()
 124         throws IOException
 125     {
 126         if ( indexWriter == null )
 127         {
 128             indexWriter = new IndexWriter( indexPath, getAnalyzer(), false );
 129         }
 130     }
 131
 132     protected void getIndexReader()
 133         throws IOException
 134     {
 135         if ( indexReader == null )
 136         {
 137             indexReader = IndexReader.open( indexPath );
 138         }
 139     }
 140
 141     /**
 142      * method for validating an index directory
 143      *
 144      * @throws RepositoryIndexException if the given indexPath is not valid for this type of RepositoryIndex
 145      */
 146     protected void validateIndex()
 147         throws RepositoryIndexException, IOException
 148     {
 149         File indexDir = new File( indexPath );
 150         if ( IndexReader.indexExists( indexDir ) )
 151         {
 152             getIndexReader();
 153             if ( indexReader.numDocs() > 0 )
 154             {
 155                 Collection fields = indexReader.getFieldNames();
 156                 String[] indexFields = getIndexFields();
 157                 for ( int idx = 0; idx < indexFields.length; idx++ )
 158                 {
 159                     if ( !fields.contains( indexFields[idx] ) )
 160                     {
 161                         throw new RepositoryIndexException(
 162                             "The Field " + indexFields[idx] + " does not exist in " + "index path " + indexPath + "." );
 163                     }
 164                 }
 165             }
 166             else
 167             {
 168                 System.out.println( "Skipping index field validations for empty index." );
 169             }
 170         }
 171         else if ( !indexDir.exists() )
 172         {
 173             indexWriter = new IndexWriter( indexPath, getAnalyzer(), true );
 174             System.out.println( "New index directory created in: " + indexDir.getAbsolutePath() );
 175         }
 176         else if ( indexDir.isDirectory() )
 177         {
 178             throw new RepositoryIndexException( indexPath + " is not a valid index directory." );
 179         }
 180         else
 181         {
 182             throw new RepositoryIndexException( indexPath + " is not a directory." );
 183         }
 184
 185         indexOpen = true;
 186     }
 187 }