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.List;
  28 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  29 import org.apache.maven.archiva.consumers.AbstractMonitoredConsumer;
  30 import org.apache.maven.archiva.consumers.ConsumerException;
  31 import org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer;
  32 import org.apache.maven.archiva.repository.content.ManagedDefaultRepositoryContent;
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35 import org.sonatype.nexus.index.ArtifactContext;
  36 import org.sonatype.nexus.index.ArtifactContextProducer;
  37 import org.sonatype.nexus.index.DefaultArtifactContextProducer;
  38 import org.sonatype.nexus.index.NexusIndexer;
  39 import org.sonatype.nexus.index.context.IndexingContext;
  40 import org.sonatype.nexus.index.context.UnsupportedExistingLuceneIndexException;
  41 import org.sonatype.nexus.index.creator.IndexerEngine;
  42 import org.sonatype.nexus.index.packer.IndexPacker;
  43
  44 /**
  45  * Consumer for indexing the repository to provide search and IDE integration features.
  46  */
  47 public class NexusIndexerConsumer
  48     extends AbstractMonitoredConsumer
  49     implements KnownRepositoryContentConsumer
  50 {
  51     private static final Logger log = LoggerFactory.getLogger( NexusIndexerConsumer.class );
  52
  53     private final NexusIndexer indexer;
  54
  55     private final ArtifactContextProducer artifactContextProducer;
  56
  57     private final IndexPacker indexPacker;
  58
  59     private ManagedRepositoryConfiguration repository;
  60
  61     private ManagedDefaultRepositoryContent repositoryContent;
  62
  63     private IndexingContext context;
  64
  65     private File managedRepository;
  66
  67     private IndexerEngine indexerEngine;
  68
  69     public NexusIndexerConsumer( NexusIndexer indexer, IndexPacker indexPacker, IndexerEngine indexerEngine )
  70     {
  71         this.indexer = indexer;
  72         this.indexPacker = indexPacker;
  73         this.indexerEngine = indexerEngine;
  74         this.artifactContextProducer = new DefaultArtifactContextProducer();
  75     }
  76
  77     public String getDescription()
  78     {
  79         return "Indexes the repository to provide search and IDE integration features";
  80     }
  81
  82     public String getId()
  83     {
  84         return "index-content";
  85     }
  86
  87     public boolean isPermanent()
  88     {
  89         return false;
  90     }
  91
  92     public void beginScan( ManagedRepositoryConfiguration repository, Date whenGathered )
  93         throws ConsumerException
  94     {
  95         this.repository = repository;
  96         managedRepository = new File( repository.getLocation() );
  97         File indexDirectory = new File( managedRepository, ".indexer" );
  98
  99         repositoryContent = new ManagedDefaultRepositoryContent();
 100         repositoryContent.setRepository( repository );
 101
 102         synchronized ( indexer )
 103         {
 104             try
 105             {
 106                 context =
 107                     indexer.addIndexingContext( repository.getId(), repository.getId(), managedRepository,
 108                                                 indexDirectory, null, null, NexusIndexer.FULL_INDEX );
 109                 context.setSearchable( repository.isScanned() );
 110
 111                 indexerEngine.beginIndexing( context );
 112             }
 113             catch ( UnsupportedExistingLuceneIndexException e )
 114             {
 115                 log.error( "Could not create index at " + indexDirectory.getAbsoluteFile(), e );
 116             }
 117             catch ( IOException e )
 118             {
 119                 log.error( "Could not create index at " + indexDirectory.getAbsoluteFile(), e );
 120             }
 121         }
 122     }
 123
 124     public void processFile( String path )
 125         throws ConsumerException
 126     {
 127         File artifactFile = new File( managedRepository, path );
 128
 129         ArtifactContext artifactContext = artifactContextProducer.getArtifactContext( context, artifactFile );
 130         if ( artifactContext != null )
 131         {
 132             try
 133             {
 134                 indexer.artifactDiscovered( artifactContext, context );
 135
 136                 indexerEngine.index( context, artifactContext );
 137             }
 138             catch ( IOException e )
 139             {
 140                 throw new ConsumerException( e.getMessage(), e );
 141             }
 142         }
 143     }
 144
 145     public void completeScan()
 146     {
 147         final File indexLocation = new File( managedRepository, ".index" );
 148         try
 149         {
 150             indexPacker.packIndex( context, indexLocation );
 151             indexerEngine.endIndexing( context );
 152         }
 153         catch ( IOException e )
 154         {
 155             log.error( "Could not pack index" + indexLocation.getAbsolutePath(), e );
 156         }
 157     }
 158
 159     public List<String> getExcludes()
 160     {
 161         return new ArrayList<String>();
 162     }
 163
 164     public List<String> getIncludes()
 165     {
 166         return Arrays.asList( "**/*" );
 167     }
 168 }