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 java.util.zip.ZipException;
  29
  30 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  31 import org.apache.maven.archiva.consumers.AbstractMonitoredConsumer;
  32 import org.apache.maven.archiva.consumers.ConsumerException;
  33 import org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer;
  34 import org.apache.maven.archiva.repository.content.ManagedDefaultRepositoryContent;
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37 import org.sonatype.nexus.index.ArtifactContext;
  38 import org.sonatype.nexus.index.ArtifactContextProducer;
  39 import org.sonatype.nexus.index.DefaultArtifactContextProducer;
  40 import org.sonatype.nexus.index.NexusIndexer;
  41 import org.sonatype.nexus.index.context.DefaultIndexingContext;
  42 import org.sonatype.nexus.index.context.IndexingContext;
  43 import org.sonatype.nexus.index.context.UnsupportedExistingLuceneIndexException;
  44 import org.sonatype.nexus.index.IndexerEngine;
  45 import org.sonatype.nexus.index.packer.IndexPacker;
  46 import org.sonatype.nexus.index.packer.IndexPackingRequest;
  47
  48 /**
  49  * Consumer for indexing the repository to provide search and IDE integration features.
  50  */
  51 public class NexusIndexerConsumer
  52     extends AbstractMonitoredConsumer
  53     implements KnownRepositoryContentConsumer
  54 {
  55     private static final Logger log = LoggerFactory.getLogger( NexusIndexerConsumer.class );
  56
  57     private ArtifactContextProducer artifactContextProducer;
  58
  59     private IndexPacker indexPacker;
  60
  61     private ManagedDefaultRepositoryContent repositoryContent;
  62
  63     private IndexingContext context;
  64
  65     private File managedRepository;
  66
  67     private IndexerEngine indexerEngine;
  68
  69     //private IndexingContextMap indexingContextMap;
  70
  71     public NexusIndexerConsumer( IndexPacker indexPacker, IndexerEngine indexerEngine )
  72     {
  73         this.indexPacker = indexPacker;
  74         this.indexerEngine = indexerEngine;
  75         this.artifactContextProducer = new DefaultArtifactContextProducer();
  76     }
  77
  78    /* public NexusIndexerConsumer( IndexPacker indexPacker, IndexerEngine indexerEngine, IndexingContextMap indexingContextMap )
  79     {
  80         this.indexPacker = indexPacker;
  81         this.indexerEngine = indexerEngine;
  82         this.indexingContextMap = indexingContextMap;
  83         this.artifactContextProducer = new DefaultArtifactContextProducer();
  84     }*/
  85
  86     public String getDescription()
  87     {
  88         return "Indexes the repository to provide search and IDE integration features";
  89     }
  90
  91     public String getId()
  92     {
  93         return "index-content";
  94     }
  95
  96     public boolean isPermanent()
  97     {
  98         return false;
  99     }
 100
 101     public void beginScan( ManagedRepositoryConfiguration repository, Date whenGathered )
 102         throws ConsumerException
 103     {
 104         //synchronized( context )
 105         //{
 106             log.debug( "Begin indexing of repository '" + repository.getId() + "'..");
 107
 108             managedRepository = new File( repository.getLocation() );
 109             String indexDir = repository.getIndexDir();
 110
 111             File indexDirectory = null;
 112             if( indexDir != null && !"".equals( indexDir ) )
 113             {
 114                 indexDirectory = new File( repository.getIndexDir() );
 115             }
 116             else
 117             {
 118                 indexDirectory = new File( managedRepository, ".indexer" );
 119             }
 120
 121             repositoryContent = new ManagedDefaultRepositoryContent();
 122             repositoryContent.setRepository( repository );
 123
 124             try
 125             {
 126                 context =
 127                     new DefaultIndexingContext( repository.getId(), repository.getId(), managedRepository,
 128                                                 indexDirectory, null, null, NexusIndexer.FULL_INDEX, false );
 129
 130                 //context = indexingContextMap.addIndexingContext( repository.getId(), repository.getId(), managedRepository,
 131                 //                                indexDirectory, null, null, NexusIndexer.FULL_INDEX, false );
 132
 133                 context.setSearchable( repository.isScanned() );
 134
 135                 //indexerEngine.beginIndexing( context );
 136             }
 137             catch ( UnsupportedExistingLuceneIndexException e )
 138             {
 139                 throw new ConsumerException( "Could not create index at " + indexDirectory.getAbsoluteFile(), e );
 140             }
 141             catch ( IOException e )
 142             {
 143                 throw new ConsumerException( "Could not create index at " + indexDirectory.getAbsoluteFile(), e );
 144             }
 145         //}
 146     }
 147
 148     public void processFile( String path )
 149         throws ConsumerException
 150     {
 151         synchronized ( indexerEngine )
 152         {
 153             if ( context == null )
 154             {
 155                 // didn't start correctly, so skip
 156                 return;
 157             }
 158
 159             File artifactFile = new File( managedRepository, path );
 160             ArtifactContext artifactContext = artifactContextProducer.getArtifactContext( context, artifactFile );
 161
 162             if ( artifactContext != null )
 163             {
 164                 try
 165                 {
 166                     indexerEngine.index( context, artifactContext );
 167                 }
 168                 catch ( ZipException e )
 169                 {
 170                     // invalid JAR file
 171                     log.info( e.getMessage() );
 172                 }
 173                 catch ( IOException e )
 174                 {
 175                     throw new ConsumerException( e.getMessage(), e );
 176                 }
 177             }
 178         }
 179     }
 180
 181     public void completeScan()
 182     {
 183         //synchronized( context )
 184         //{
 185             log.debug( "End indexing of repository '" + context.getRepositoryId() + "'..");
 186
 187             final File indexLocation = new File( managedRepository, ".index" );
 188             try
 189             {
 190                 //indexerEngine.endIndexing( context );
 191
 192                 IndexPackingRequest request = new IndexPackingRequest( context, indexLocation );
 193                 indexPacker.packIndex( request );
 194
 195                 //indexingContextMap.removeIndexingContext( context.getId() );
 196
 197                 context.close( false );
 198             }
 199             catch ( IOException e )
 200             {
 201                 log.error( "Could not pack index" + indexLocation.getAbsolutePath(), e );
 202             }
 203         //}
 204     }
 205
 206     public List<String> getExcludes()
 207     {
 208         return new ArrayList<String>();
 209     }
 210
 211     public List<String> getIncludes()
 212     {
 213         return Arrays.asList( "**/*" );
 214     }
 215 }