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.BooleanClause;
  31 import org.apache.lucene.search.BooleanFilter;
  32 import org.apache.lucene.search.BooleanQuery;
  33 import org.apache.lucene.search.DuplicateFilter;
  34 import org.apache.lucene.search.Filter;
  35 import org.apache.lucene.search.FilterClause;
  36 import org.apache.lucene.search.Hits;
  37 import org.apache.lucene.search.MultiSearcher;
  38 import org.apache.lucene.search.Query;
  39 import org.apache.lucene.search.QueryWrapperFilter;
  40 import org.apache.lucene.search.Searchable;
  41 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  42 import org.apache.maven.archiva.configuration.ConfigurationNames;
  43 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  44 import org.apache.maven.archiva.indexer.ArtifactKeys;
  45 import org.apache.maven.archiva.indexer.RepositoryContentIndex;
  46 import org.apache.maven.archiva.indexer.RepositoryContentIndexFactory;
  47 import org.apache.maven.archiva.indexer.RepositoryIndexException;
  48 import org.apache.maven.archiva.indexer.RepositoryIndexSearchException;
  49 import org.apache.maven.archiva.indexer.bytecode.BytecodeHandlers;
  50 import org.apache.maven.archiva.indexer.bytecode.BytecodeKeys;
  51 import org.apache.maven.archiva.indexer.filecontent.FileContentHandlers;
  52 import org.apache.maven.archiva.indexer.filecontent.FileContentKeys;
  53 import org.apache.maven.archiva.indexer.hashcodes.HashcodesHandlers;
  54 import org.apache.maven.archiva.indexer.hashcodes.HashcodesKeys;
  55 import org.apache.maven.archiva.indexer.lucene.LuceneEntryConverter;
  56 import org.apache.maven.archiva.indexer.lucene.LuceneQuery;
  57 import org.apache.maven.archiva.indexer.lucene.LuceneRepositoryContentRecord;
  58 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  59 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  60 import org.codehaus.plexus.registry.Registry;
  61 import org.codehaus.plexus.registry.RegistryListener;
  62 import org.slf4j.Logger;
  63 import org.slf4j.LoggerFactory;
  64
  65 /**
  66  * DefaultCrossRepositorySearch
  67  *
  68  * @version $Id$
  69  * @plexus.component role="org.apache.maven.archiva.indexer.search.CrossRepositorySearch" role-hint="default"
  70  */
  71 public class DefaultCrossRepositorySearch
  72     implements CrossRepositorySearch, RegistryListener, Initializable
  73 {
  74     private Logger log = LoggerFactory.getLogger( DefaultCrossRepositorySearch.class );
  75
  76     /**
  77      * @plexus.requirement role-hint="lucene"
  78      */
  79     private RepositoryContentIndexFactory indexFactory;
  80
  81     /**
  82      * @plexus.requirement
  83      */
  84     private ArchivaConfiguration configuration;
  85
  86     private final List<ManagedRepositoryConfiguration> localIndexedRepositories = new ArrayList<ManagedRepositoryConfiguration>();
  87
  88     public SearchResults executeFilteredSearch( String principal, List<String> selectedRepos, String groupId,
  89                                                 String artifactId, String version, String className,
  90                                                 SearchResultLimits limits )
  91     {
  92         List<RepositoryContentIndex> indexes = getBytecodeIndexes( principal, selectedRepos );
  93         SearchResults results = new SearchResults();
  94         List<String> fieldsList = new ArrayList<String>();
  95         List<String> termsList = new ArrayList<String>();
  96         List<BooleanClause.Occur> flagsList = new ArrayList<BooleanClause.Occur>();
  97
  98         if( groupId != null && !"".equals( groupId.trim() ) )
  99         {
 100             fieldsList.add( ArtifactKeys.GROUPID );
 101             termsList.add( groupId );
 102             flagsList.add( BooleanClause.Occur.MUST );
 103         }
 104
 105         if( artifactId != null && !"".equals( artifactId.trim() ) )
 106         {
 107             fieldsList.add( ArtifactKeys.ARTIFACTID );
 108             termsList.add( artifactId );
 109             flagsList.add( BooleanClause.Occur.MUST );
 110         }
 111
 112         if( version != null && !"".equals( version.trim() ) )
 113         {
 114             fieldsList.add( ArtifactKeys.VERSION );
 115             termsList.add( version );
 116             flagsList.add( BooleanClause.Occur.MUST );
 117         }
 118
 119         if( className != null && !"".equals( className.trim() ) )
 120         {
 121             fieldsList.add( BytecodeKeys.CLASSES );
 122             fieldsList.add( BytecodeKeys.FILES );
 123             fieldsList.add( BytecodeKeys.METHODS );
 124             termsList.add( className.trim() );
 125             termsList.add( className.trim() );
 126             termsList.add( className.trim() );
 127             flagsList.add( BooleanClause.Occur.SHOULD );
 128             flagsList.add( BooleanClause.Occur.SHOULD );
 129             flagsList.add( BooleanClause.Occur.SHOULD );
 130         }
 131
 132         try
 133         {
 134             String[] fieldsArr = new String[ fieldsList.size() ];
 135             String[] queryArr = new String[ termsList.size() ];
 136             BooleanClause.Occur[] flagsArr = new BooleanClause.Occur[ flagsList.size() ];
 137
 138             Query fieldsQuery =
 139                 MultiFieldQueryParser.parse( termsList.toArray( queryArr ), fieldsList.toArray( fieldsArr ),
 140                                              flagsList.toArray( flagsArr ), new BytecodeHandlers().getAnalyzer() );
 141
 142             LuceneQuery query = new LuceneQuery( fieldsQuery );
 143             results = searchAll( query, limits, indexes, null );
 144             results.getRepositories().add( this.localIndexedRepositories );
 145         }
 146         catch ( ParseException e )
 147         {
 148             log.warn( "Unable to parse advanced search fields and query terms." );
 149         }
 150
 151         return results;
 152     }
 153
 154     public SearchResults searchForChecksum( String principal, List<String> selectedRepos, String checksum,
 155                                             SearchResultLimits limits )
 156     {
 157         List<RepositoryContentIndex> indexes = getHashcodeIndexes( principal, selectedRepos );
 158
 159         try
 160         {
 161             QueryParser parser = new MultiFieldQueryParser( new String[]{HashcodesKeys.MD5, HashcodesKeys.SHA1},
 162                                            new HashcodesHandlers().getAnalyzer() );
 163             LuceneQuery query = new LuceneQuery( parser.parse( checksum ) );
 164             SearchResults results = searchAll( query, limits, indexes, null );
 165             results.getRepositories().addAll( this.localIndexedRepositories );
 166
 167             return results;
 168         }
 169         catch ( ParseException e )
 170         {
 171             log.warn( "Unable to parse query [" + checksum + "]: " + e.getMessage(), e );
 172         }
 173
 174         // empty results.
 175         return new SearchResults();
 176     }
 177
 178     public SearchResults searchForBytecode( String principal, List<String> selectedRepos, String term, SearchResultLimits limits )
 179     {
 180         List<RepositoryContentIndex> indexes = getBytecodeIndexes( principal, selectedRepos );
 181
 182         try
 183         {
 184             QueryParser parser = new BytecodeHandlers().getQueryParser();
 185             LuceneQuery query = new LuceneQuery( parser.parse( term ) );
 186             SearchResults results = searchAll( query, limits, indexes, null );
 187             results.getRepositories().addAll( this.localIndexedRepositories );
 188
 189             return results;
 190         }
 191         catch ( ParseException e )
 192         {
 193             log.warn( "Unable to parse query [" + term + "]: " + e.getMessage(), e );
 194         }
 195
 196         // empty results.
 197         return new SearchResults();
 198     }
 199
 200     public SearchResults searchForTerm( String principal, List<String> selectedRepos, String term, SearchResultLimits limits )
 201     {
 202         return searchForTerm( principal, selectedRepos, term, limits, null );
 203     }
 204
 205     public SearchResults searchForTerm( String principal, List<String> selectedRepos, String term,
 206                                         SearchResultLimits limits, List<String> previousSearchTerms )
 207     {
 208         List<RepositoryContentIndex> indexes = getFileContentIndexes( principal, selectedRepos );
 209
 210         try
 211         {
 212             QueryParser parser = new FileContentHandlers().getQueryParser();
 213             LuceneQuery query = null;
 214             SearchResults results = null;
 215             if ( previousSearchTerms == null || previousSearchTerms.isEmpty() )
 216             {
 217                 query = new LuceneQuery( parser.parse( term ) );
 218                 results = searchAll( query, limits, indexes, null );
 219             }
 220             else
 221             {
 222                 // AND the previous search terms
 223                 BooleanQuery booleanQuery = new BooleanQuery();
 224                 for ( String previousSearchTerm : previousSearchTerms )
 225                 {
 226                     booleanQuery.add( parser.parse( previousSearchTerm ), BooleanClause.Occur.MUST );
 227                 }
 228
 229                 query = new LuceneQuery( booleanQuery );
 230                 Filter filter = new QueryWrapperFilter( parser.parse( term ) );
 231                 results = searchAll( query, limits, indexes, filter );
 232             }
 233             results.getRepositories().addAll( this.localIndexedRepositories );
 234
 235             return results;
 236         }
 237         catch ( ParseException e )
 238         {
 239             log.warn( "Unable to parse query [" + term + "]: " + e.getMessage(), e );
 240         }
 241
 242         // empty results.
 243         return new SearchResults();
 244     }
 245
 246     private SearchResults searchAll( LuceneQuery luceneQuery, SearchResultLimits limits, List<RepositoryContentIndex> indexes, Filter filter )
 247     {
 248         org.apache.lucene.search.Query specificQuery = luceneQuery.getLuceneQuery();
 249
 250         SearchResults results = new SearchResults();
 251
 252         if ( indexes.isEmpty() )
 253         {
 254             // No point going any further.
 255             return results;
 256         }
 257
 258         // Setup the converter
 259         LuceneEntryConverter converter = null;
 260         RepositoryContentIndex index = indexes.get( 0 );
 261         converter = index.getEntryConverter();
 262
 263         // Process indexes into an array of Searchables.
 264         List<Searchable> searchableList = toSearchables( indexes );
 265
 266         Searchable searchables[] = new Searchable[searchableList.size()];
 267         searchableList.toArray( searchables );
 268
 269         MultiSearcher searcher = null;
 270
 271         try
 272         {
 273             // Create a multi-searcher for looking up the information.
 274             searcher = new MultiSearcher( searchables );
 275
 276             BooleanFilter booleanFilter = new BooleanFilter();
 277             DuplicateFilter artifactIdDuplicateFilter = new DuplicateFilter(FileContentKeys.ARTIFACTID_EXACT);
 278             booleanFilter.add(new FilterClause(artifactIdDuplicateFilter, BooleanClause.Occur.MUST));
 279             DuplicateFilter groupIdDuplicateFilter = new DuplicateFilter(FileContentKeys.GROUPID_EXACT);
 280             booleanFilter.add(new FilterClause(groupIdDuplicateFilter, BooleanClause.Occur.MUST));
 281
 282             // Perform the search.
 283             Hits hits = null;
 284             if ( filter != null )
 285             {
 286                 booleanFilter.add(new FilterClause(filter, BooleanClause.Occur.MUST));
 287                 hits = searcher.search( specificQuery, booleanFilter );
 288             }
 289             else
 290             {
 291                 hits = searcher.search( specificQuery, booleanFilter );
 292             }
 293
 294             int hitCount = hits.length();
 295
 296             // Now process the limits.
 297             results.setLimits( limits );
 298             results.setTotalHits( hitCount );
 299
 300             int fetchCount = limits.getPageSize();
 301             int offset = ( limits.getSelectedPage() * limits.getPageSize() );
 302
 303             if ( limits.getSelectedPage() == SearchResultLimits.ALL_PAGES )
 304             {
 305                 fetchCount = hitCount;
 306                 offset = 0;
 307             }
 308
 309             // Goto offset.
 310             if ( offset < hitCount )
 311             {
 312                 // only process if the offset is within the hit count.
 313                 for ( int i = 0; i < fetchCount; i++ )
 314                 {
 315                     // Stop fetching if we are past the total # of available hits.
 316                     if ( offset + i >= hitCount )
 317                     {
 318                         break;
 319                     }
 320
 321                     try
 322                     {
 323                         Document doc = hits.doc( offset + i );
 324                         LuceneRepositoryContentRecord record = converter.convert( doc );
 325                         results.addHit( record );
 326                     }
 327                     catch ( java.text.ParseException e )
 328                     {
 329                         log.warn( "Unable to parse document into record: " + e.getMessage(), e );
 330                     }
 331                 }
 332             }
 333
 334         }
 335         catch ( IOException e )
 336         {
 337             log.error( "Unable to setup multi-search: " + e.getMessage(), e );
 338         }
 339         finally
 340         {
 341             try
 342             {
 343                 if ( searcher != null )
 344                 {
 345                     searcher.close();
 346                 }
 347             }
 348             catch ( IOException ie )
 349             {
 350                 log.error( "Unable to close index searcher: " + ie.getMessage(), ie );
 351             }
 352         }
 353
 354         return results;
 355     }
 356
 357     private List<Searchable> toSearchables( List<RepositoryContentIndex> indexes )
 358     {
 359         List<Searchable> searchableList = new ArrayList<Searchable>();
 360         for ( RepositoryContentIndex contentIndex : indexes )
 361         {
 362             try
 363             {
 364                 searchableList.add( contentIndex.getSearchable() );
 365             }
 366             catch ( RepositoryIndexSearchException e )
 367             {
 368                 log.warn( "Unable to get searchable for index [" + contentIndex.getId() + "] :"
 369                                       + e.getMessage(), e );
 370             }
 371         }
 372         return searchableList;
 373     }
 374
 375     public List<RepositoryContentIndex> getBytecodeIndexes( String principal, List<String> selectedRepos )
 376     {
 377         List<RepositoryContentIndex> ret = new ArrayList<RepositoryContentIndex>();
 378
 379         for ( ManagedRepositoryConfiguration repoConfig : localIndexedRepositories )
 380         {
 381             // Only used selected repo
 382             if ( selectedRepos.contains( repoConfig.getId() ) )
 383             {
 384                 RepositoryContentIndex index = indexFactory.createBytecodeIndex( repoConfig );
 385                 // If they exist.
 386                 if ( indexExists( index ) )
 387                 {
 388                     ret.add( index );
 389                 }
 390             }
 391         }
 392
 393         return ret;
 394     }
 395
 396     public List<RepositoryContentIndex> getFileContentIndexes( String principal, List<String> selectedRepos )
 397     {
 398         List<RepositoryContentIndex> ret = new ArrayList<RepositoryContentIndex>();
 399
 400         for ( ManagedRepositoryConfiguration repoConfig : localIndexedRepositories )
 401         {
 402             // Only used selected repo
 403             if ( selectedRepos.contains( repoConfig.getId() ) )
 404             {
 405                 RepositoryContentIndex index = indexFactory.createFileContentIndex( repoConfig );
 406                 // If they exist.
 407                 if ( indexExists( index ) )
 408                 {
 409                     ret.add( index );
 410                 }
 411             }
 412         }
 413
 414         return ret;
 415     }
 416
 417     public List<RepositoryContentIndex> getHashcodeIndexes( String principal, List<String> selectedRepos )
 418     {
 419         List<RepositoryContentIndex> ret = new ArrayList<RepositoryContentIndex>();
 420
 421         for ( ManagedRepositoryConfiguration repoConfig : localIndexedRepositories )
 422         {
 423             // Only used selected repo
 424             if ( selectedRepos.contains( repoConfig.getId() ) )
 425             {
 426                 RepositoryContentIndex index = indexFactory.createHashcodeIndex( repoConfig );
 427                 // If they exist.
 428                 if ( indexExists( index ) )
 429                 {
 430                     ret.add( index );
 431                 }
 432             }
 433         }
 434
 435         return ret;
 436     }
 437
 438     private boolean indexExists( RepositoryContentIndex index )
 439     {
 440         try
 441         {
 442             return index.exists();
 443         }
 444         catch ( RepositoryIndexException e )
 445         {
 446             log.info(
 447                               "Repository Content Index [" + index.getId() + "] for repository ["
 448                                   + index.getRepository().getId() + "] does not exist yet in ["
 449                                   + index.getIndexDirectory().getAbsolutePath() + "]." );
 450             return false;
 451         }
 452     }
 453
 454     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 455     {
 456         if ( ConfigurationNames.isManagedRepositories( propertyName ) )
 457         {
 458             initRepositories();
 459         }
 460     }
 461
 462     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 463     {
 464         /* Nothing to do here */
 465     }
 466
 467     private void initRepositories()
 468     {
 469         synchronized ( this.localIndexedRepositories )
 470         {
 471             this.localIndexedRepositories.clear();
 472
 473             List<ManagedRepositoryConfiguration> repos = configuration.getConfiguration().getManagedRepositories();
 474             for ( ManagedRepositoryConfiguration repo : repos )
 475             {
 476                 if ( repo.isScanned() )
 477                 {
 478                     localIndexedRepositories.add( repo );
 479                 }
 480             }
 481         }
 482     }
 483
 484     public void initialize()
 485         throws InitializationException
 486     {
 487         initRepositories();
 488         configuration.addChangeListener( this );
 489     }
 490 }