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 org.apache.commons.collections.CollectionUtils;
  23 import org.apache.commons.collections.Predicate;
  24 import org.apache.commons.collections.Transformer;
  25 import org.apache.commons.collections.functors.AndPredicate;
  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.RepositoryConfiguration;
  36 import org.apache.maven.archiva.configuration.functors.IndexedRepositoryPredicate;
  37 import org.apache.maven.archiva.configuration.functors.LocalRepositoryPredicate;
  38 import org.apache.maven.archiva.indexer.RepositoryContentIndex;
  39 import org.apache.maven.archiva.indexer.bytecode.BytecodeHandlers;
  40 import org.apache.maven.archiva.indexer.filecontent.FileContentHandlers;
  41 import org.apache.maven.archiva.indexer.functors.UserAllowedToSearchRepositoryPredicate;
  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.apache.maven.archiva.repository.ArchivaConfigurationAdaptor;
  48 import org.codehaus.plexus.logging.AbstractLogEnabled;
  49 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  50 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  51 import org.codehaus.plexus.registry.Registry;
  52 import org.codehaus.plexus.registry.RegistryListener;
  53
  54 import java.io.IOException;
  55 import java.util.ArrayList;
  56 import java.util.Collection;
  57 import java.util.List;
  58
  59 /**
  60  * DefaultCrossRepositorySearch
  61  *
  62  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  63  * @version $Id$
  64  * @plexus.component role="org.apache.maven.archiva.indexer.search.CrossRepositorySearch" role-hint="default"
  65  */
  66 public class DefaultCrossRepositorySearch
  67     extends AbstractLogEnabled
  68     implements CrossRepositorySearch, RegistryListener, Initializable
  69 {
  70     /**
  71      * @plexus.requirement role-hint="bytecode"
  72      */
  73     private Transformer bytecodeIndexTransformer;
  74
  75     /**
  76      * @plexus.requirement role-hint="filecontent"
  77      */
  78     private Transformer filecontentIndexTransformer;
  79
  80     /**
  81      * @plexus.requirement role-hint="hashcodes"
  82      */
  83     private Transformer hashcodesIndexTransformer;
  84
  85     /**
  86      * @plexus.requirement role-hint="searchable"
  87      */
  88     private Transformer searchableTransformer;
  89
  90     /**
  91      * @plexus.requirement role-hint="index-exists"
  92      */
  93     private Predicate indexExistsPredicate;
  94
  95     /**
  96      * @plexus.requirement
  97      */
  98     private ArchivaConfiguration configuration;
  99
 100     private List localIndexedRepositories = new ArrayList();
 101
 102     public SearchResults searchForChecksum( String checksum, SearchResultLimits limits )
 103     {
 104         List indexes = getHashcodeIndexes();
 105
 106         try
 107         {
 108             QueryParser parser = new MultiFieldQueryParser( new String[] { HashcodesKeys.MD5, HashcodesKeys.SHA1 },
 109                                                             new HashcodesHandlers().getAnalyzer() );
 110             LuceneQuery query = new LuceneQuery( parser.parse( checksum ) );
 111             SearchResults results = searchAll( query, limits, indexes );
 112             results.getRepositories().addAll( this.localIndexedRepositories );
 113
 114             return results;
 115         }
 116         catch ( ParseException e )
 117         {
 118             getLogger().warn( "Unable to parse query [" + checksum + "]: " + e.getMessage(), e );
 119         }
 120
 121         // empty results.
 122         return new SearchResults();
 123     }
 124
 125     public SearchResults searchForBytecode( String term, SearchResultLimits limits )
 126     {
 127         List indexes = getHashcodeIndexes();
 128
 129         try
 130         {
 131             QueryParser parser = new BytecodeHandlers().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             getLogger().warn( "Unable to parse query [" + term + "]: " + e.getMessage(), e );
 141         }
 142
 143         // empty results.
 144         return new SearchResults();
 145     }
 146
 147     public SearchResults searchForTerm( String term, SearchResultLimits limits )
 148     {
 149         List indexes = getFileContentIndexes();
 150
 151         try
 152         {
 153             QueryParser parser = new FileContentHandlers().getQueryParser();
 154             LuceneQuery query = new LuceneQuery( parser.parse( term ) );
 155             SearchResults results = searchAll( query, limits, indexes );
 156             results.getRepositories().addAll( this.localIndexedRepositories );
 157
 158             return results;
 159         }
 160         catch ( ParseException e )
 161         {
 162             getLogger().warn( "Unable to parse query [" + term + "]: " + e.getMessage(), e );
 163         }
 164
 165         // empty results.
 166         return new SearchResults();
 167     }
 168
 169     private SearchResults searchAll( LuceneQuery luceneQuery, SearchResultLimits limits, List indexes )
 170     {
 171         org.apache.lucene.search.Query specificQuery = luceneQuery.getLuceneQuery();
 172
 173         SearchResults results = new SearchResults();
 174
 175         if ( indexes.isEmpty() )
 176         {
 177             // No point going any further.
 178             return results;
 179         }
 180
 181         // Setup the converter
 182         LuceneEntryConverter converter = null;
 183         RepositoryContentIndex index = (RepositoryContentIndex) indexes.get( 0 );
 184         converter = index.getEntryConverter();
 185
 186         // Process indexes into an array of Searchables.
 187         List searchableList = new ArrayList( indexes );
 188         CollectionUtils.transform( searchableList, searchableTransformer );
 189
 190         Searchable searchables[] = new Searchable[searchableList.size()];
 191         searchableList.toArray( searchables );
 192
 193         MultiSearcher searcher = null;
 194
 195         try
 196         {
 197             // Create a multi-searcher for looking up the information.
 198             searcher = new MultiSearcher( searchables );
 199
 200             // Perform the search.
 201             Hits hits = searcher.search( specificQuery );
 202
 203             int hitCount = hits.length();
 204
 205             // Now process the limits.
 206             results.setLimits( limits );
 207             results.setTotalHits( hitCount );
 208
 209             int fetchCount = limits.getPageSize();
 210             int offset = ( limits.getSelectedPage() * limits.getPageSize() );
 211
 212             if ( limits.getSelectedPage() == SearchResultLimits.ALL_PAGES )
 213             {
 214                 fetchCount = hitCount;
 215                 offset = 0;
 216             }
 217
 218             // Goto offset.
 219             if ( offset < hitCount )
 220             {
 221                 // only process if the offset is within the hit count.
 222                 for ( int i = 0; i <= fetchCount; i++ )
 223                 {
 224                     // Stop fetching if we are past the total # of available hits.
 225                     if ( offset + i >= hitCount )
 226                     {
 227                         break;
 228                     }
 229
 230                     try
 231                     {
 232                         Document doc = hits.doc( offset + i );
 233                         LuceneRepositoryContentRecord record = converter.convert( doc );
 234                         results.addHit( record );
 235                     }
 236                     catch ( java.text.ParseException e )
 237                     {
 238                         getLogger().warn( "Unable to parse document into record: " + e.getMessage(), e );
 239                     }
 240                 }
 241             }
 242
 243         }
 244         catch ( IOException e )
 245         {
 246             getLogger().error( "Unable to setup multi-search: " + e.getMessage(), e );
 247         }
 248         finally
 249         {
 250             try
 251             {
 252                 searcher.close();
 253             }
 254             catch ( IOException ie )
 255             {
 256                 getLogger().error( "Unable to close index searcher: " + ie.getMessage(), ie );
 257             }
 258         }
 259
 260         return results;
 261     }
 262
 263     private Predicate getAllowedToSearchReposPredicate()
 264     {
 265         return new UserAllowedToSearchRepositoryPredicate();
 266     }
 267
 268     public List getBytecodeIndexes()
 269     {
 270         List ret = new ArrayList();
 271
 272         synchronized ( this.localIndexedRepositories )
 273         {
 274             ret.addAll( CollectionUtils.select( this.localIndexedRepositories, getAllowedToSearchReposPredicate() ) );
 275             CollectionUtils.transform( ret, bytecodeIndexTransformer );
 276             CollectionUtils.filter( ret, indexExistsPredicate );
 277         }
 278
 279         return ret;
 280     }
 281
 282     public List getFileContentIndexes()
 283     {
 284         List ret = new ArrayList();
 285
 286         synchronized ( this.localIndexedRepositories )
 287         {
 288             ret.addAll( CollectionUtils.select( this.localIndexedRepositories, getAllowedToSearchReposPredicate() ) );
 289             CollectionUtils.transform( ret, filecontentIndexTransformer );
 290             CollectionUtils.filter( ret, indexExistsPredicate );
 291         }
 292
 293         return ret;
 294     }
 295
 296     public List getHashcodeIndexes()
 297     {
 298         List ret = new ArrayList();
 299
 300         synchronized ( this.localIndexedRepositories )
 301         {
 302             ret.addAll( CollectionUtils.select( this.localIndexedRepositories, getAllowedToSearchReposPredicate() ) );
 303             CollectionUtils.transform( ret, hashcodesIndexTransformer );
 304             CollectionUtils.filter( ret, indexExistsPredicate );
 305         }
 306
 307         return ret;
 308     }
 309
 310     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 311     {
 312         if ( ConfigurationNames.isRepositories( propertyName ) )
 313         {
 314             initRepositories();
 315         }
 316     }
 317
 318     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 319     {
 320         /* Nothing to do here */
 321     }
 322
 323     private void initRepositories()
 324     {
 325         synchronized ( this.localIndexedRepositories )
 326         {
 327             this.localIndexedRepositories.clear();
 328
 329             Predicate localIndexedRepos = AndPredicate.getInstance( LocalRepositoryPredicate.getInstance(),
 330                                                                     IndexedRepositoryPredicate.getInstance() );
 331
 332             Collection repos = CollectionUtils.select( configuration.getConfiguration().getRepositories(),
 333                                                        localIndexedRepos );
 334
 335             Transformer toArchivaRepository = new Transformer()
 336             {
 337
 338                 public Object transform( Object input )
 339                 {
 340                     if ( input instanceof RepositoryConfiguration )
 341                     {
 342                         return ArchivaConfigurationAdaptor.toArchivaRepository( (RepositoryConfiguration) input );
 343                     }
 344                     return input;
 345                 }
 346             };
 347
 348             CollectionUtils.transform( repos, toArchivaRepository );
 349
 350             this.localIndexedRepositories.addAll( repos );
 351         }
 352     }
 353
 354     public void initialize()
 355         throws InitializationException
 356     {
 357         initRepositories();
 358         configuration.addChangeListener( this );
 359     }
 360 }