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.admin.model.RepositoryAdminException;
  23 import org.apache.archiva.admin.model.beans.ManagedRepository;
  24 import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
  25 import org.apache.archiva.configuration.ArchivaConfiguration;
  26 import org.apache.archiva.configuration.ConfigurationNames;
  27 import org.apache.archiva.configuration.FileTypes;
  28 import org.apache.archiva.consumers.AbstractMonitoredConsumer;
  29 import org.apache.archiva.consumers.ConsumerException;
  30 import org.apache.archiva.consumers.KnownRepositoryContentConsumer;
  31 import org.apache.archiva.redback.components.registry.Registry;
  32 import org.apache.archiva.redback.components.registry.RegistryListener;
  33 import org.apache.archiva.redback.components.taskqueue.TaskQueueException;
  34 import org.apache.archiva.scheduler.ArchivaTaskScheduler;
  35 import org.apache.archiva.scheduler.indexing.ArtifactIndexingTask;
  36 import org.apache.maven.index.NexusIndexer;
  37 import org.apache.maven.index.context.IndexCreator;
  38 import org.apache.maven.index.context.IndexingContext;
  39 import org.slf4j.Logger;
  40 import org.slf4j.LoggerFactory;
  41 import org.springframework.context.annotation.Scope;
  42 import org.springframework.stereotype.Service;
  43
  44 import javax.annotation.PostConstruct;
  45 import javax.inject.Inject;
  46 import javax.inject.Named;
  47 import java.io.File;
  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 @Service( "knownRepositoryContentConsumer#index-content" )
  57 @Scope( "prototype" )
  58 public class NexusIndexerConsumer
  59     extends AbstractMonitoredConsumer
  60     implements KnownRepositoryContentConsumer, RegistryListener
  61 {
  62     private Logger log = LoggerFactory.getLogger( getClass() );
  63
  64     private ArchivaConfiguration configuration;
  65
  66     private FileTypes filetypes;
  67
  68     private File managedRepository;
  69
  70     private ArchivaTaskScheduler<ArtifactIndexingTask> scheduler;
  71
  72     private IndexingContext indexingContext;
  73
  74     private NexusIndexer nexusIndexer;
  75
  76     private List<String> includes = new ArrayList<>( 0 );
  77
  78     private ManagedRepository repository;
  79
  80     private List<? extends IndexCreator> allIndexCreators;
  81
  82     private ManagedRepositoryAdmin managedRepositoryAdmin;
  83
  84     @Inject
  85     public NexusIndexerConsumer(
  86         @Named( value = "archivaTaskScheduler#indexing" ) ArchivaTaskScheduler<ArtifactIndexingTask> scheduler,
  87         @Named( value = "archivaConfiguration" ) ArchivaConfiguration configuration, FileTypes filetypes,
  88         List<IndexCreator> indexCreators, ManagedRepositoryAdmin managedRepositoryAdmin, NexusIndexer nexusIndexer )
  89     {
  90         this.configuration = configuration;
  91         this.filetypes = filetypes;
  92         this.scheduler = scheduler;
  93         this.nexusIndexer = nexusIndexer;
  94         this.allIndexCreators = indexCreators;
  95         this.managedRepositoryAdmin = managedRepositoryAdmin;
  96     }
  97
  98     @Override
  99     public String getDescription()
 100     {
 101         return "Indexes the repository to provide search and IDE integration features";
 102     }
 103
 104     @Override
 105     public String getId()
 106     {
 107         return "index-content";
 108     }
 109
 110     @Override
 111     public void beginScan( ManagedRepository repository, Date whenGathered )
 112         throws ConsumerException
 113     {
 114         this.repository = repository;
 115         managedRepository = new File( repository.getLocation() );
 116
 117         try
 118         {
 119             log.info( "Creating indexing context for repo : {}", repository.getId() );
 120             indexingContext = managedRepositoryAdmin.createIndexContext( repository );
 121         }
 122         catch ( RepositoryAdminException e )
 123         {
 124             throw new ConsumerException( e.getMessage(), e );
 125         }
 126     }
 127
 128     @Override
 129     public void beginScan( ManagedRepository repository, Date whenGathered, boolean executeOnEntireRepo )
 130         throws ConsumerException
 131     {
 132         if ( executeOnEntireRepo )
 133         {
 134             beginScan( repository, whenGathered );
 135         }
 136         else
 137         {
 138             this.repository = repository;
 139             managedRepository = new File( repository.getLocation() );
 140         }
 141     }
 142
 143     @Override
 144     public void processFile( String path )
 145         throws ConsumerException
 146     {
 147         File artifactFile = new File( managedRepository, path );
 148
 149         ArtifactIndexingTask task =
 150             new ArtifactIndexingTask( repository, artifactFile, ArtifactIndexingTask.Action.ADD, getIndexingContext() );
 151         try
 152         {
 153             log.debug( "Queueing indexing task '{}' to add or update the artifact in the index.", task );
 154             scheduler.queueTask( task );
 155         }
 156         catch ( TaskQueueException e )
 157         {
 158             throw new ConsumerException( e.getMessage(), e );
 159         }
 160     }
 161
 162     @Override
 163     public void processFile( String path, boolean executeOnEntireRepo )
 164         throws Exception
 165     {
 166         if ( executeOnEntireRepo )
 167         {
 168             processFile( path );
 169         }
 170         else
 171         {
 172             File artifactFile = new File( managedRepository, path );
 173
 174             // specify in indexing task that this is not a repo scan request!
 175             ArtifactIndexingTask task =
 176                 new ArtifactIndexingTask( repository, artifactFile, ArtifactIndexingTask.Action.ADD,
 177                                           getIndexingContext(), false );
 178             // only update index we don't need to scan the full repo here
 179             task.setOnlyUpdate( true );
 180             try
 181             {
 182                 log.debug( "Queueing indexing task '{}' to add or update the artifact in the index.", task );
 183                 scheduler.queueTask( task );
 184             }
 185             catch ( TaskQueueException e )
 186             {
 187                 throw new ConsumerException( e.getMessage(), e );
 188             }
 189         }
 190     }
 191
 192     @Override
 193     public void completeScan()
 194     {
 195         IndexingContext context = this.indexingContext;
 196         if ( context == null )
 197         {
 198             try
 199             {
 200                 context = getIndexingContext();
 201             }
 202             catch ( ConsumerException e )
 203             {
 204                 log.warn( "failed to get an IndexingContext:{}", e.getMessage() );
 205                 return;
 206             }
 207         }
 208         ArtifactIndexingTask task =
 209             new ArtifactIndexingTask( repository, null, ArtifactIndexingTask.Action.FINISH, context );
 210         try
 211         {
 212             log.debug( "Queueing indexing task '{}' to finish indexing.", task );
 213             scheduler.queueTask( task );
 214         }
 215         catch ( TaskQueueException e )
 216         {
 217             log.error( "Error queueing task: {}: {}", task, e.getMessage(), e );
 218         }
 219     }
 220
 221     @Override
 222     public void completeScan( boolean executeOnEntireRepo )
 223     {
 224         if ( executeOnEntireRepo )
 225         {
 226             completeScan();
 227         }
 228
 229         // else, do nothing as the context will be closed when indexing task is executed if not a repo scan request!
 230     }
 231
 232     @Override
 233     public List<String> getExcludes()
 234     {
 235         return Collections.emptyList();
 236     }
 237
 238     @Override
 239     public void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 240     {
 241         if ( ConfigurationNames.isRepositoryScanning( propertyName ) )
 242         {
 243             initIncludes();
 244         }
 245     }
 246
 247     @Override
 248     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
 249     {
 250         /* do nothing */
 251     }
 252
 253     private void initIncludes()
 254     {
 255         List<String> indexable = filetypes.getFileTypePatterns( FileTypes.INDEXABLE_CONTENT );
 256         List<String> artifacts = filetypes.getFileTypePatterns( FileTypes.ARTIFACTS );
 257
 258         includes = new ArrayList<>( indexable.size() + artifacts.size() );
 259
 260         includes.addAll( indexable );
 261
 262         includes.addAll( artifacts );
 263     }
 264
 265     @PostConstruct
 266     public void initialize()
 267     {
 268         configuration.addChangeListener( this );
 269
 270         initIncludes();
 271     }
 272
 273     @Override
 274     public List<String> getIncludes()
 275     {
 276         return includes;
 277     }
 278
 279
 280     private IndexingContext getIndexingContext()
 281         throws ConsumerException
 282     {
 283
 284         if ( this.indexingContext == null )
 285         {
 286             try
 287             {
 288                 indexingContext = managedRepositoryAdmin.createIndexContext( repository );
 289             }
 290             catch ( RepositoryAdminException e )
 291             {
 292                 throw new ConsumerException( e.getMessage(), e );
 293             }
 294         }
 295         return indexingContext;
 296     }
 297 }