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 final NexusIndexer indexer;
  61
  62     private final ArtifactContextProducer artifactContextProducer;
  63
  64     private final 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( managedRepository, 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                         if ( uinfo != null )
 138                         {
 139                             uinfos.add( uinfo );
 140                         }
 141                     }
 142                 }
 143
 144                 indexerEngine.beginIndexing( context );
 145             }
 146             catch ( UnsupportedExistingLuceneIndexException e )
 147             {
 148                 log.error( "Could not create index at " + indexDirectory.getAbsoluteFile(), e );
 149             }
 150             catch ( IOException e )
 151             {
 152                 log.error( "Could not create index at " + indexDirectory.getAbsoluteFile(), e );
 153             }
 154         }
 155     }
 156
 157     public void processFile( String path )
 158         throws ConsumerException
 159     {
 160         File artifactFile = new File( managedRepository, path );
 161         ArtifactContext artifactContext = artifactContextProducer.getArtifactContext( context, artifactFile );
 162
 163         if ( artifactContext != null )
 164         {
 165             try
 166             {
 167                 ArtifactInfo ai = artifactContext.getArtifactInfo();
 168                 String uinfo = AbstractIndexCreator.getGAV(
 169                     ai.groupId, ai.artifactId, ai.version, ai.classifier, ai.packaging );
 170
 171                 // already indexed so update!
 172                 if ( uinfos.contains( uinfo ) )
 173                 {
 174                     indexerEngine.update( context, artifactContext );
 175                 }
 176                 else
 177                 {
 178                     indexerEngine.index( context, artifactContext );
 179                 }
 180             }
 181             catch ( IOException e )
 182             {
 183                 throw new ConsumerException( e.getMessage(), e );
 184             }
 185         }
 186     }
 187
 188     public void completeScan()
 189     {
 190         final File indexLocation = new File( managedRepository, ".index" );
 191         try
 192         {
 193             indexerEngine.endIndexing( context );
 194             indexPacker.packIndex( context, indexLocation );
 195             indexer.removeIndexingContext( context, false );
 196             uinfos = null;
 197         }
 198         catch ( IOException e )
 199         {
 200             log.error( "Could not pack index" + indexLocation.getAbsolutePath(), e );
 201         }
 202     }
 203
 204     public List<String> getExcludes()
 205     {
 206         return new ArrayList<String>();
 207     }
 208
 209     public List<String> getIncludes()
 210     {
 211         return Arrays.asList( "**/*" );
 212     }
 213 }