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

   1 package org.apache.archiva.consumers.lucene;
   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.File;
  23 import java.io.IOException;
  24 import java.util.ArrayList;
  25 import java.util.Arrays;
  26 import java.util.Date;
  27 import java.util.HashSet;
  28 import java.util.List;
  29 import java.util.Set;
  30
  31 import org.apache.lucene.document.Document;
  32 import org.apache.lucene.index.IndexReader;
  33 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  34 import org.apache.maven.archiva.consumers.AbstractMonitoredConsumer;
  35 import org.apache.maven.archiva.consumers.ConsumerException;
  36 import org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer;
  37 import org.apache.maven.archiva.repository.content.ManagedDefaultRepositoryContent;
  38 import org.slf4j.Logger;
  39 import org.slf4j.LoggerFactory;
  40 import org.sonatype.nexus.index.ArtifactContext;
  41 import org.sonatype.nexus.index.ArtifactContextProducer;
  42 import org.sonatype.nexus.index.ArtifactInfo;
  43 import org.sonatype.nexus.index.DefaultArtifactContextProducer;
  44 import org.sonatype.nexus.index.NexusIndexer;
  45 import org.sonatype.nexus.index.context.IndexingContext;
  46 import org.sonatype.nexus.index.context.UnsupportedExistingLuceneIndexException;
  47 import org.sonatype.nexus.index.creator.AbstractIndexCreator;
  48 import org.sonatype.nexus.index.creator.IndexerEngine;
  49 import org.sonatype.nexus.index.packer.IndexPacker;
  50
  51 /**
  52  * Consumer for indexing the repository to provide search and IDE integration features.
  53  */
  54 public class NexusIndexerConsumer
  55     extends AbstractMonitoredConsumer
  56     implements KnownRepositoryContentConsumer
  57 {
  58     private static final Logger log = LoggerFactory.getLogger( NexusIndexerConsumer.class );
  59
  60     private NexusIndexer indexer;
  61
  62     private ArtifactContextProducer artifactContextProducer;
  63
  64     private IndexPacker indexPacker;
  65
  66     private ManagedDefaultRepositoryContent repositoryContent;
  67
  68     private IndexingContext context;
  69
  70     private File managedRepository;
  71
  72     private IndexerEngine indexerEngine;
  73
  74     private Set<String> uinfos;
  75
  76     public NexusIndexerConsumer( NexusIndexer indexer, IndexPacker indexPacker, IndexerEngine indexerEngine )
  77     {
  78         this.indexer = indexer;
  79         this.indexPacker = indexPacker;
  80         this.indexerEngine = indexerEngine;
  81         this.artifactContextProducer = new DefaultArtifactContextProducer();
  82     }
  83
  84     public String getDescription()
  85     {
  86         return "Indexes the repository to provide search and IDE integration features";
  87     }
  88
  89     public String getId()
  90     {
  91         return "index-content";
  92     }
  93
  94     public boolean isPermanent()
  95     {
  96         return false;
  97     }
  98
  99     public void beginScan( ManagedRepositoryConfiguration repository, Date whenGathered )
 100         throws ConsumerException
 101     {
 102         managedRepository = new File( repository.getLocation() );
 103         String indexDir = repository.getIndexDir();
 104
 105         File indexDirectory = null;
 106         if( indexDir != null && !"".equals( indexDir ) )
 107         {
 108             indexDirectory = new File( repository.getIndexDir() );
 109         }
 110         else
 111         {
 112             indexDirectory = new File( managedRepository, ".indexer" );
 113         }
 114
 115         repositoryContent = new ManagedDefaultRepositoryContent();
 116         repositoryContent.setRepository( repository );
 117         uinfos = new HashSet<String>();
 118
 119         synchronized ( indexer )
 120         {
 121             try
 122             {
 123                 context =
 124                     indexer.addIndexingContext( repository.getId(), repository.getId(), managedRepository,
 125                                                 indexDirectory, null, null, NexusIndexer.FULL_INDEX );
 126                 context.setSearchable( repository.isScanned() );
 127
 128                 // read index to get all the artifacts already indexed
 129                 IndexReader r = context.getIndexReader();
 130                 for ( int i = 0; i < r.numDocs(); i++ )
 131                 {
 132                     if ( !r.isDeleted( i ) )
 133                     {
 134                         Document d = r.document( i );
 135                         String uinfo = d.get( ArtifactInfo.UINFO );
 136
 137                      // should we add a check here if the contents of the document still exist in the file system
 138                      // for cases when there is already an existing index & the contents of that index doesn't exist
 139                      // in the file system & in the database?
 140                         if ( uinfo != null )
 141                         {
 142                             uinfos.add( uinfo );
 143                         }
 144                     }
 145                 }
 146
 147                 indexerEngine.beginIndexing( context );
 148             }
 149             catch ( UnsupportedExistingLuceneIndexException e )
 150             {
 151                 throw new ConsumerException( "Could not create index at " + indexDirectory.getAbsoluteFile(), e );
 152             }
 153             catch ( IOException e )
 154             {
 155                 throw new ConsumerException( "Could not create index at " + indexDirectory.getAbsoluteFile(), e );
 156             }
 157         }
 158     }
 159
 160     public void processFile( String path )
 161         throws ConsumerException
 162     {
 163         File artifactFile = new File( managedRepository, path );
 164         ArtifactContext artifactContext = artifactContextProducer.getArtifactContext( context, artifactFile );
 165
 166         if ( artifactContext != null )
 167         {
 168             try
 169             {
 170                 ArtifactInfo ai = artifactContext.getArtifactInfo();
 171                 String uinfo = AbstractIndexCreator.getGAV(
 172                     ai.groupId, ai.artifactId, ai.version, ai.classifier, ai.packaging );
 173
 174                 // already indexed so update!
 175                 if ( uinfos.contains( uinfo ) )
 176                 {
 177                     indexerEngine.update( context, artifactContext );
 178                 }
 179                 else
 180                 {
 181                     indexerEngine.index( context, artifactContext );
 182                 }
 183             }
 184             catch ( IOException e )
 185             {
 186                 throw new ConsumerException( e.getMessage(), e );
 187             }
 188         }
 189     }
 190
 191     public void completeScan()
 192     {
 193         final File indexLocation = new File( managedRepository, ".index" );
 194         try
 195         {
 196             indexerEngine.endIndexing( context );
 197             indexPacker.packIndex( context, indexLocation );
 198             indexer.removeIndexingContext( context, false );
 199             uinfos = null;
 200         }
 201         catch ( IOException e )
 202         {
 203             log.error( "Could not pack index" + indexLocation.getAbsolutePath(), e );
 204         }
 205     }
 206
 207     public List<String> getExcludes()
 208     {
 209         return new ArrayList<String>();
 210     }
 211
 212     public List<String> getIncludes()
 213     {
 214         return Arrays.asList( "**/*" );
 215     }
 216 }