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 org.apache.archiva.common.plexusbridge.MavenIndexerUtils;
  23 import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
  24 import org.apache.archiva.common.plexusbridge.PlexusSisuBridgeException;
  25 import org.apache.archiva.scheduler.ArchivaTaskScheduler;
  26 import org.apache.archiva.scheduler.indexing.ArtifactIndexingTask;
  27 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  28 import org.apache.maven.archiva.configuration.ConfigurationNames;
  29 import org.apache.maven.archiva.configuration.FileTypes;
  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.index.NexusIndexer;
  35 import org.apache.maven.index.context.IndexCreator;
  36 import org.apache.maven.index.context.IndexingContext;
  37 import org.apache.maven.index.context.UnsupportedExistingLuceneIndexException;
  38 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  39 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  40 import org.codehaus.plexus.registry.Registry;
  41 import org.codehaus.plexus.registry.RegistryListener;
  42 import org.codehaus.plexus.taskqueue.TaskQueueException;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45
  46 import java.io.File;
  47 import java.io.IOException;
  48 import java.util.ArrayList;
  49 import java.util.Collections;
  50 import java.util.Date;
  51 import java.util.List;
  52
  53 /**
  54  * Consumer for indexing the repository to provide search and IDE integration features.
  55  */
  56 public class NexusIndexerConsumer
  57     extends AbstractMonitoredConsumer
  58     implements KnownRepositoryContentConsumer, RegistryListener, Initializable
  59 {
  60     private Logger log = LoggerFactory.getLogger( NexusIndexerConsumer.class );
  61
  62     private ArchivaConfiguration configuration;
  63
  64     private FileTypes filetypes;
  65
  66     private File managedRepository;
  67
  68     private ArchivaTaskScheduler<ArtifactIndexingTask> scheduler;
  69
  70     private IndexingContext context;
  71
  72     private NexusIndexer nexusIndexer;
  73
  74     private List<String> includes = new ArrayList<String>();
  75
  76     private ManagedRepositoryConfiguration repository;
  77
  78     private List<? extends IndexCreator> allIndexCreators;
  79
  80     public NexusIndexerConsumer( ArchivaTaskScheduler<ArtifactIndexingTask> scheduler,
  81                                  ArchivaConfiguration configuration, FileTypes filetypes,
  82                                  PlexusSisuBridge plexusSisuBridge, MavenIndexerUtils mavenIndexerUtils )
  83         throws PlexusSisuBridgeException
  84     {
  85         this.configuration = configuration;
  86         this.filetypes = filetypes;
  87         this.scheduler = scheduler;
  88         this.nexusIndexer = plexusSisuBridge.lookup( NexusIndexer.class );
  89         this.allIndexCreators = mavenIndexerUtils.getAllIndexCreators();
  90     }
  91
  92     public String getDescription()
  93     {
  94         return "Indexes the repository to provide search and IDE integration features";
  95     }
  96
  97     public String getId()
  98     {
  99         return "index-content";
 100     }
 101
 102     public boolean isPermanent()
 103     {
 104         return false;
 105     }
 106
 107     public void beginScan( ManagedRepositoryConfiguration repository, Date whenGathered )
 108         throws ConsumerException
 109     {
 110         this.repository = repository;
 111         managedRepository = new File( repository.getLocation() );
 112
 113         try
 114         {
 115             log.info( "Creating indexing context for repo : {}", repository.getId() );
 116             context = ArtifactIndexingTask.createContext( repository, nexusIndexer, allIndexCreators );
 117         }
 118         catch ( IOException e )
 119         {
 120             throw new ConsumerException( e.getMessage(), e );
 121         }
 122         catch ( UnsupportedExistingLuceneIndexException e )
 123         {
 124             throw new ConsumerException( e.getMessage(), e );
 125         }
 126     }
 127
 128     public void beginScan( ManagedRepositoryConfiguration repository, Date whenGathered, boolean executeOnEntireRepo )
 129         throws ConsumerException
 130     {
 131         if ( executeOnEntireRepo )
 132         {
 133             beginScan( repository, whenGathered );
 134         }
 135         else
 136         {
 137             this.repository = repository;
 138             managedRepository = new File( repository.getLocation() );
 139         }
 140     }
 141
 142     public void processFile( String path )
 143         throws ConsumerException
 144     {
 145         File artifactFile = new File( managedRepository, path );
 146
 147         ArtifactIndexingTask task =
 148             new ArtifactIndexingTask( repository, artifactFile, ArtifactIndexingTask.Action.ADD, context );
 149         try
 150         {
 151             log.debug( "Queueing indexing task '{}' to add or update the artifact in the index.", task );
 152             scheduler.queueTask( task );
 153         }
 154         catch ( TaskQueueException e )
 155         {
 156             throw new ConsumerException( e.getMessage(), e );
 157         }
 158     }
 159
 160     public void processFile( String path, boolean executeOnEntireRepo )
 161         throws Exception
 162     {
 163         if ( executeOnEntireRepo )
 164         {
 165             processFile( path );
 166         }
 167         else
 168         {
 169             File artifactFile = new File( managedRepository, path );
 170
 171             // specify in indexing task that this is not a repo scan request!
 172             ArtifactIndexingTask task =
 173                 new ArtifactIndexingTask( repository, artifactFile, ArtifactIndexingTask.Action.ADD, context, false );
 174             // only update index we don't need to scan the full repo here
 175             task.setOnlyUpdate( true );
 176             try
 177             {
 178                 log.debug( "Queueing indexing task '{}' to add or update the artifact in the index.", task );
 179                 scheduler.queueTask( task );
 180             }
 181             catch ( TaskQueueException e )
 182             {
 183                 throw new ConsumerException( e.getMessage(), e );
 184             }
 185         }
 186     }
 187
 188     public void completeScan()
 189     {
 190         ArtifactIndexingTask task =
 191             new ArtifactIndexingTask( repository, null, ArtifactIndexingTask.Action.FINISH, context );
 192         try
 193         {
 194             log.debug( "Queueing indexing task '{}' to finish indexing.", task );
 195             scheduler.queueTask( task );
 196         }
 197         catch ( TaskQueueException e )
 198         {
 199             log.error( "Error queueing task: " + task + ": " + e.getMessage(), e );
 200         }
 201         context = null;
 202     }
 203
 204     public void completeScan( boolean executeOnEntireRepo )
 205     {
 206         if ( executeOnEntireRepo )
 207         {
 208             completeScan();
 209         }
 210
 211         // else, do nothing as the context will be closed when indexing task is executed if not a repo scan request!
 212     }
 213
 214     public List<String> getExcludes()
 215     {
 216         return Collections.emptyList();
 217     }
 218
 219     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 220     {
 221         if ( ConfigurationNames.isRepositoryScanning( propertyName ) )
 222         {
 223             initIncludes();
 224         }
 225     }
 226
 227     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 228     {
 229         /* do nothing */
 230     }
 231
 232     private void initIncludes()
 233     {
 234         includes.clear();
 235
 236         includes.addAll( filetypes.getFileTypePatterns( FileTypes.INDEXABLE_CONTENT ) );
 237
 238         includes.addAll( filetypes.getFileTypePatterns( FileTypes.ARTIFACTS ) );
 239     }
 240
 241     public void initialize()
 242         throws InitializationException
 243     {
 244         configuration.addChangeListener( this );
 245
 246         initIncludes();
 247     }
 248
 249     public List<String> getIncludes()
 250     {
 251         return includes;
 252     }
 253 }