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

   1 package org.apache.maven.archiva.indexer.search;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import java.io.IOException;
  23 import java.util.ArrayList;
  24 import java.util.List;
  25
  26 import org.apache.lucene.document.Document;
  27 import org.apache.lucene.queryParser.MultiFieldQueryParser;
  28 import org.apache.lucene.queryParser.ParseException;
  29 import org.apache.lucene.queryParser.QueryParser;
  30 import org.apache.lucene.search.Hits;
  31 import org.apache.lucene.search.MultiSearcher;
  32 import org.apache.lucene.search.Searchable;
  33 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  34 import org.apache.maven.archiva.configuration.ConfigurationNames;
  35 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  36 import org.apache.maven.archiva.indexer.RepositoryContentIndex;
  37 import org.apache.maven.archiva.indexer.RepositoryContentIndexFactory;
  38 import org.apache.maven.archiva.indexer.RepositoryIndexException;
  39 import org.apache.maven.archiva.indexer.RepositoryIndexSearchException;
  40 import org.apache.maven.archiva.indexer.bytecode.BytecodeHandlers;
  41 import org.apache.maven.archiva.indexer.filecontent.FileContentHandlers;
  42 import org.apache.maven.archiva.indexer.hashcodes.HashcodesHandlers;
  43 import org.apache.maven.archiva.indexer.hashcodes.HashcodesKeys;
  44 import org.apache.maven.archiva.indexer.lucene.LuceneEntryConverter;
  45 import org.apache.maven.archiva.indexer.lucene.LuceneQuery;
  46 import org.apache.maven.archiva.indexer.lucene.LuceneRepositoryContentRecord;
  47 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  48 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  49 import org.codehaus.plexus.registry.Registry;
  50 import org.codehaus.plexus.registry.RegistryListener;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53
  54 /**
  55  * DefaultCrossRepositorySearch
  56  *
  57  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  58  * @version $Id$
  59  * @plexus.component role="org.apache.maven.archiva.indexer.search.CrossRepositorySearch" role-hint="default"
  60  */
  61 public class DefaultCrossRepositorySearch
  62     implements CrossRepositorySearch, RegistryListener, Initializable
  63 {
  64     private Logger log = LoggerFactory.getLogger( DefaultCrossRepositorySearch.class );
  65
  66     /**
  67      * @plexus.requirement role-hint="lucene"
  68      */
  69     private RepositoryContentIndexFactory indexFactory;
  70
  71     /**
  72      * @plexus.requirement
  73      */
  74     private ArchivaConfiguration configuration;
  75
  76     private List<ManagedRepositoryConfiguration> localIndexedRepositories = new ArrayList<ManagedRepositoryConfiguration>();
  77
  78     public SearchResults searchForChecksum( String principal, List<String> selectedRepos, String checksum, SearchResultLimits limits )
  79     {
  80         List<RepositoryContentIndex> indexes = getHashcodeIndexes( principal, selectedRepos );
  81
  82         try
  83         {
  84             QueryParser parser = new MultiFieldQueryParser( new String[]{HashcodesKeys.MD5, HashcodesKeys.SHA1},
  85                                                             new HashcodesHandlers().getAnalyzer() );
  86             LuceneQuery query = new LuceneQuery( parser.parse( checksum ) );
  87             SearchResults results = searchAll( query, limits, indexes );
  88             results.getRepositories().addAll( this.localIndexedRepositories );
  89
  90             return results;
  91         }
  92         catch ( ParseException e )
  93         {
  94             log.warn( "Unable to parse query [" + checksum + "]: " + e.getMessage(), e );
  95         }
  96
  97         // empty results.
  98         return new SearchResults();
  99     }
 100
 101     public SearchResults searchForBytecode( String principal, List<String> selectedRepos, String term, SearchResultLimits limits )
 102     {
 103         List<RepositoryContentIndex> indexes = getBytecodeIndexes( principal, selectedRepos );
 104
 105         try
 106         {
 107             QueryParser parser = new BytecodeHandlers().getQueryParser();
 108             LuceneQuery query = new LuceneQuery( parser.parse( term ) );
 109             SearchResults results = searchAll( query, limits, indexes );
 110             results.getRepositories().addAll( this.localIndexedRepositories );
 111
 112             return results;
 113         }
 114         catch ( ParseException e )
 115         {
 116             log.warn( "Unable to parse query [" + term + "]: " + e.getMessage(), e );
 117         }
 118
 119         // empty results.
 120         return new SearchResults();
 121     }
 122
 123     public SearchResults searchForTerm( String principal, List<String> selectedRepos, String term, SearchResultLimits limits )
 124     {
 125         List<RepositoryContentIndex> indexes = getFileContentIndexes( principal, selectedRepos );
 126         List<RepositoryContentIndex> bytecodeIndices = getBytecodeIndexes( principal, selectedRepos );
 127         indexes.addAll( bytecodeIndices );
 128
 129         try
 130         {
 131             QueryParser parser = new FileContentHandlers().getQueryParser();
 132             LuceneQuery query = new LuceneQuery( parser.parse( term ) );
 133             SearchResults results = searchAll( query, limits, indexes );
 134             results.getRepositories().addAll( this.localIndexedRepositories );
 135
 136             return results;
 137         }
 138         catch ( ParseException e )
 139         {
 140             log.warn( "Unable to parse query [" + term + "]: " + e.getMessage(), e );
 141         }
 142
 143         // empty results.
 144         return new SearchResults();
 145     }
 146
 147     private SearchResults searchAll( LuceneQuery luceneQuery, SearchResultLimits limits, List<RepositoryContentIndex> indexes )
 148     {
 149         org.apache.lucene.search.Query specificQuery = luceneQuery.getLuceneQuery();
 150
 151         SearchResults results = new SearchResults();
 152
 153         if ( indexes.isEmpty() )
 154         {
 155             // No point going any further.
 156             return results;
 157         }
 158
 159         // Setup the converter
 160         LuceneEntryConverter converter = null;
 161         RepositoryContentIndex index = indexes.get( 0 );
 162         converter = index.getEntryConverter();
 163
 164         // Process indexes into an array of Searchables.
 165         List<Searchable> searchableList = toSearchables( indexes );
 166
 167         Searchable searchables[] = new Searchable[searchableList.size()];
 168         searchableList.toArray( searchables );
 169
 170         MultiSearcher searcher = null;
 171
 172         try
 173         {
 174             // Create a multi-searcher for looking up the information.
 175             searcher = new MultiSearcher( searchables );
 176
 177             // Perform the search.
 178             Hits hits = searcher.search( specificQuery );
 179
 180             int hitCount = hits.length();
 181
 182             // Now process the limits.
 183             results.setLimits( limits );
 184             results.setTotalHits( hitCount );
 185
 186             int fetchCount = limits.getPageSize();
 187             int offset = ( limits.getSelectedPage() * limits.getPageSize() );
 188
 189             if ( limits.getSelectedPage() == SearchResultLimits.ALL_PAGES )
 190             {
 191                 fetchCount = hitCount;
 192                 offset = 0;
 193             }
 194
 195             // Goto offset.
 196             if ( offset < hitCount )
 197             {
 198                 // only process if the offset is within the hit count.
 199                 for ( int i = 0; i < fetchCount; i++ )
 200                 {
 201                     // Stop fetching if we are past the total # of available hits.
 202                     if ( offset + i >= hitCount )
 203                     {
 204                         break;
 205                     }
 206
 207                     try
 208                     {
 209                         Document doc = hits.doc( offset + i );
 210                         LuceneRepositoryContentRecord record = converter.convert( doc );
 211                         results.addHit( record );
 212                     }
 213                     catch ( java.text.ParseException e )
 214                     {
 215                         log.warn( "Unable to parse document into record: " + e.getMessage(), e );
 216                     }
 217                 }
 218             }
 219
 220         }
 221         catch ( IOException e )
 222         {
 223             log.error( "Unable to setup multi-search: " + e.getMessage(), e );
 224         }
 225         finally
 226         {
 227             try
 228             {
 229                 if ( searcher != null )
 230                 {
 231                     searcher.close();
 232                 }
 233             }
 234             catch ( IOException ie )
 235             {
 236                 log.error( "Unable to close index searcher: " + ie.getMessage(), ie );
 237             }
 238         }
 239
 240         return results;
 241     }
 242
 243     private List<Searchable> toSearchables( List<RepositoryContentIndex> indexes )
 244     {
 245         List<Searchable> searchableList = new ArrayList<Searchable>();
 246         for ( RepositoryContentIndex contentIndex : indexes )
 247         {
 248             try
 249             {
 250                 searchableList.add( contentIndex.getSearchable() );
 251             }
 252             catch ( RepositoryIndexSearchException e )
 253             {
 254                 log.warn( "Unable to get searchable for index [" + contentIndex.getId() + "] :"
 255                                       + e.getMessage(), e );
 256             }
 257         }
 258         return searchableList;
 259     }
 260
 261     public List<RepositoryContentIndex> getBytecodeIndexes( String principal, List<String> selectedRepos )
 262     {
 263         List<RepositoryContentIndex> ret = new ArrayList<RepositoryContentIndex>();
 264
 265         for ( ManagedRepositoryConfiguration repoConfig : localIndexedRepositories )
 266         {
 267             // Only used selected repo
 268             if ( selectedRepos.contains( repoConfig.getId() ) )
 269             {
 270                 RepositoryContentIndex index = indexFactory.createBytecodeIndex( repoConfig );
 271                 // If they exist.
 272                 if ( indexExists( index ) )
 273                 {
 274                     ret.add( index );
 275                 }
 276             }
 277         }
 278
 279         return ret;
 280     }
 281
 282     public List<RepositoryContentIndex> getFileContentIndexes( String principal, List<String> selectedRepos )
 283     {
 284         List<RepositoryContentIndex> ret = new ArrayList<RepositoryContentIndex>();
 285
 286         for ( ManagedRepositoryConfiguration repoConfig : localIndexedRepositories )
 287         {
 288             // Only used selected repo
 289             if ( selectedRepos.contains( repoConfig.getId() ) )
 290             {
 291                 RepositoryContentIndex index = indexFactory.createFileContentIndex( repoConfig );
 292                 // If they exist.
 293                 if ( indexExists( index ) )
 294                 {
 295                     ret.add( index );
 296                 }
 297             }
 298         }
 299
 300         return ret;
 301     }
 302
 303     public List<RepositoryContentIndex> getHashcodeIndexes( String principal, List<String> selectedRepos )
 304     {
 305         List<RepositoryContentIndex> ret = new ArrayList<RepositoryContentIndex>();
 306
 307         for ( ManagedRepositoryConfiguration repoConfig : localIndexedRepositories )
 308         {
 309             // Only used selected repo
 310             if ( selectedRepos.contains( repoConfig.getId() ) )
 311             {
 312                 RepositoryContentIndex index = indexFactory.createHashcodeIndex( repoConfig );
 313                 // If they exist.
 314                 if ( indexExists( index ) )
 315                 {
 316                     ret.add( index );
 317                 }
 318             }
 319         }
 320
 321         return ret;
 322     }
 323
 324     private boolean indexExists( RepositoryContentIndex index )
 325     {
 326         try
 327         {
 328             return index.exists();
 329         }
 330         catch ( RepositoryIndexException e )
 331         {
 332             log.info(
 333                               "Repository Content Index [" + index.getId() + "] for repository ["
 334                                   + index.getRepository().getId() + "] does not exist yet in ["
 335                                   + index.getIndexDirectory().getAbsolutePath() + "]." );
 336             return false;
 337         }
 338     }
 339
 340     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 341     {
 342         if ( ConfigurationNames.isManagedRepositories( propertyName ) )
 343         {
 344             initRepositories();
 345         }
 346     }
 347
 348     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 349     {
 350         /* Nothing to do here */
 351     }
 352
 353     private void initRepositories()
 354     {
 355         synchronized ( this.localIndexedRepositories )
 356         {
 357             this.localIndexedRepositories.clear();
 358
 359             List<ManagedRepositoryConfiguration> repos = configuration.getConfiguration().getManagedRepositories();
 360             for ( ManagedRepositoryConfiguration repo : repos )
 361             {
 362                 if ( repo.isScanned() )
 363                 {
 364                     localIndexedRepositories.add( repo );
 365                 }
 366             }
 367         }
 368     }
 369
 370     public void initialize()
 371         throws InitializationException
 372     {
 373         initRepositories();
 374         configuration.addChangeListener( this );
 375     }
 376 }