source.dussan.org Git - archiva.git/blob

   1 package org.apache.maven.archiva.repository.scanner;
   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.util.ArrayList;
  24 import java.util.Date;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import org.apache.archiva.repository.scanner.functors.TriggerScanCompletedClosure;
  30 import org.apache.commons.collections.Closure;
  31 import org.apache.commons.collections.CollectionUtils;
  32 import org.apache.commons.collections.functors.IfClosure;
  33 import org.apache.maven.archiva.common.utils.BaseFile;
  34 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  35 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  36 import org.apache.maven.archiva.configuration.RepositoryScanningConfiguration;
  37 import org.apache.maven.archiva.consumers.InvalidRepositoryContentConsumer;
  38 import org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer;
  39 import org.apache.maven.archiva.repository.scanner.functors.ConsumerProcessFileClosure;
  40 import org.apache.maven.archiva.repository.scanner.functors.ConsumerWantsFilePredicate;
  41 import org.apache.maven.archiva.repository.scanner.functors.TriggerBeginScanClosure;
  42 import org.springframework.beans.BeansException;
  43 import org.springframework.context.ApplicationContext;
  44 import org.springframework.context.ApplicationContextAware;
  45
  46 /**
  47  * RepositoryContentConsumerUtil
  48  *
  49  * @version $Id$
  50  */
  51 public class RepositoryContentConsumers
  52     implements ApplicationContextAware
  53 {
  54     private ApplicationContext applicationContext;
  55
  56     private ArchivaConfiguration archivaConfiguration;
  57
  58     private List<KnownRepositoryContentConsumer> selectedKnownConsumers;
  59
  60     private List<InvalidRepositoryContentConsumer> selectedInvalidConsumers;
  61
  62     public RepositoryContentConsumers( ArchivaConfiguration archivaConfiguration )
  63     {
  64         this.archivaConfiguration = archivaConfiguration;
  65     }
  66
  67     public void setApplicationContext( ApplicationContext applicationContext )
  68         throws BeansException
  69     {
  70         this.applicationContext = applicationContext;
  71     }
  72
  73     /**
  74      * <p>
  75      * Get the list of Ids associated with those {@link KnownRepositoryContentConsumer} that have been selected in the
  76      * configuration to execute.
  77      * </p>
  78      * <p>
  79      * NOTE: This list can be larger and contain entries that might not exist or be available in the classpath, or as a
  80      * component.
  81      * </p>
  82      *
  83      * @return the list of consumer ids that have been selected by the configuration.
  84      */
  85     public List<String> getSelectedKnownConsumerIds()
  86     {
  87         RepositoryScanningConfiguration scanning = archivaConfiguration.getConfiguration().getRepositoryScanning();
  88         return scanning.getKnownContentConsumers();
  89     }
  90
  91     /**
  92      * <p>
  93      * Get the list of Ids associated with those {@link InvalidRepositoryContentConsumer} that have been selected in the
  94      * configuration to execute.
  95      * </p>
  96      * <p>
  97      * NOTE: This list can be larger and contain entries that might not exist or be available in the classpath, or as a
  98      * component.
  99      * </p>
 100      *
 101      * @return the list of consumer ids that have been selected by the configuration.
 102      */
 103     public List<String> getSelectedInvalidConsumerIds()
 104     {
 105         RepositoryScanningConfiguration scanning = archivaConfiguration.getConfiguration().getRepositoryScanning();
 106         return scanning.getInvalidContentConsumers();
 107     }
 108
 109     /**
 110      * Get the map of {@link String} ids to {@link KnownRepositoryContentConsumer} implementations, for those consumers
 111      * that have been selected according to the active configuration.
 112      *
 113      * @return the map of String ids to {@link KnownRepositoryContentConsumer} objects.
 114      */
 115     public Map<String, KnownRepositoryContentConsumer> getSelectedKnownConsumersMap()
 116     {
 117         Map<String, KnownRepositoryContentConsumer> consumerMap = new HashMap<String, KnownRepositoryContentConsumer>();
 118
 119         for ( KnownRepositoryContentConsumer consumer : getSelectedKnownConsumers() )
 120         {
 121             consumerMap.put( consumer.getId(), consumer );
 122         }
 123
 124         return consumerMap;
 125     }
 126
 127     /**
 128      * Get the map of {@link String} ids to {@link InvalidRepositoryContentConsumer} implementations, for those
 129      * consumers that have been selected according to the active configuration.
 130      *
 131      * @return the map of String ids to {@link InvalidRepositoryContentConsumer} objects.
 132      */
 133     public Map<String, InvalidRepositoryContentConsumer> getSelectedInvalidConsumersMap()
 134     {
 135         Map<String, InvalidRepositoryContentConsumer> consumerMap =
 136             new HashMap<String, InvalidRepositoryContentConsumer>();
 137
 138         for ( InvalidRepositoryContentConsumer consumer : getSelectedInvalidConsumers() )
 139         {
 140             consumerMap.put( consumer.getId(), consumer );
 141         }
 142
 143         return consumerMap;
 144     }
 145
 146     /**
 147      * Get the list of {@link KnownRepositoryContentConsumer} objects that are selected according to the active
 148      * configuration.
 149      *
 150      * @return the list of {@link KnownRepositoryContentConsumer} that have been selected by the active configuration.
 151      */
 152     public synchronized List<KnownRepositoryContentConsumer> getSelectedKnownConsumers()
 153     {
 154         if ( selectedKnownConsumers == null )
 155         {
 156             List<KnownRepositoryContentConsumer> ret = new ArrayList<KnownRepositoryContentConsumer>();
 157
 158             List<String> knownSelected = getSelectedKnownConsumerIds();
 159
 160             for ( KnownRepositoryContentConsumer consumer : getAvailableKnownConsumers() )
 161             {
 162                 if ( knownSelected.contains( consumer.getId() ) || consumer.isPermanent() )
 163                 {
 164                     ret.add( consumer );
 165                 }
 166             }
 167             this.selectedKnownConsumers = ret;
 168         }
 169         return selectedKnownConsumers;
 170     }
 171
 172     /**
 173      * Get the list of {@link InvalidRepositoryContentConsumer} objects that are selected according to the active
 174      * configuration.
 175      *
 176      * @return the list of {@link InvalidRepositoryContentConsumer} that have been selected by the active configuration.
 177      */
 178     public synchronized List<InvalidRepositoryContentConsumer> getSelectedInvalidConsumers()
 179     {
 180         if ( selectedInvalidConsumers == null )
 181         {
 182             List<InvalidRepositoryContentConsumer> ret = new ArrayList<InvalidRepositoryContentConsumer>();
 183
 184             List<String> invalidSelected = getSelectedInvalidConsumerIds();
 185
 186             for ( InvalidRepositoryContentConsumer consumer : getAvailableInvalidConsumers() )
 187             {
 188                 if ( invalidSelected.contains( consumer.getId() ) || consumer.isPermanent() )
 189                 {
 190                     ret.add( consumer );
 191                 }
 192             }
 193             selectedInvalidConsumers = ret;
 194         }
 195         return selectedInvalidConsumers;
 196     }
 197
 198     /**
 199      * Get the list of {@link KnownRepositoryContentConsumer} objects that are available and present in the classpath
 200      * and as components in the IoC.
 201      *
 202      * @return the list of all available {@link KnownRepositoryContentConsumer} present in the classpath and as a
 203      *         component in the IoC.
 204      */
 205     @SuppressWarnings("unchecked")
 206     public List<KnownRepositoryContentConsumer> getAvailableKnownConsumers()
 207     {
 208         return new ArrayList<KnownRepositoryContentConsumer>( applicationContext.getBeansOfType( KnownRepositoryContentConsumer.class ).values() );
 209     }
 210
 211     /**
 212      * Get the list of {@link InvalidRepositoryContentConsumer} objects that are available and present in the classpath
 213      * and as components in the IoC.
 214      *
 215      * @return the list of all available {@link InvalidRepositoryContentConsumer} present in the classpath and as a
 216      *         component in the IoC.
 217      */
 218     @SuppressWarnings("unchecked")
 219     public List<InvalidRepositoryContentConsumer> getAvailableInvalidConsumers()
 220     {
 221         return new ArrayList<InvalidRepositoryContentConsumer>( applicationContext.getBeansOfType( InvalidRepositoryContentConsumer.class ).values() );
 222     }
 223
 224     /**
 225      * A convienence method to execute all of the active selected consumers for a particular arbitrary file.
 226      *
 227      * @param repository the repository configuration to use.
 228      * @param localFile the local file to execute the consumers against.
 229      */
 230     public void executeConsumers( ManagedRepositoryConfiguration repository, File localFile )
 231     {
 232         // Run the repository consumers
 233         try
 234         {
 235             Closure triggerBeginScan = new TriggerBeginScanClosure( repository, getStartTime() );
 236
 237             List<KnownRepositoryContentConsumer> selectedKnownConsumers = getSelectedKnownConsumers();
 238             List<InvalidRepositoryContentConsumer> selectedInvalidConsumers = getSelectedInvalidConsumers();
 239             CollectionUtils.forAllDo( selectedKnownConsumers, triggerBeginScan );
 240             CollectionUtils.forAllDo( selectedInvalidConsumers, triggerBeginScan );
 241
 242             // yuck. In case you can't read this, it says
 243             // "process the file if the consumer has it in the includes list, and not in the excludes list"
 244             BaseFile baseFile = new BaseFile( repository.getLocation(), localFile );
 245             ConsumerWantsFilePredicate predicate = new ConsumerWantsFilePredicate();
 246             predicate.setBasefile( baseFile );
 247             ConsumerProcessFileClosure closure = new ConsumerProcessFileClosure();
 248             closure.setBasefile( baseFile );
 249             predicate.setCaseSensitive( false );
 250             Closure processIfWanted = IfClosure.getInstance( predicate, closure );
 251
 252             CollectionUtils.forAllDo( selectedKnownConsumers, processIfWanted );
 253
 254             if ( predicate.getWantedFileCount() <= 0 )
 255             {
 256                 // Nothing known processed this file. It is invalid!
 257                 CollectionUtils.forAllDo( selectedInvalidConsumers, closure );
 258             }
 259
 260             TriggerScanCompletedClosure scanCompletedClosure = new TriggerScanCompletedClosure( repository );
 261
 262             CollectionUtils.forAllDo( selectedKnownConsumers, scanCompletedClosure );
 263         }
 264         finally
 265         {
 266             /*
 267              * TODO: This is never called by the repository scanner instance, so not calling here either - but it
 268              * probably should be? CollectionUtils.forAllDo( availableKnownConsumers, triggerCompleteScan );
 269              * CollectionUtils.forAllDo( availableInvalidConsumers, triggerCompleteScan );
 270              */
 271         }
 272     }
 273
 274     public void setSelectedKnownConsumers( List<KnownRepositoryContentConsumer> selectedKnownConsumers )
 275     {
 276         this.selectedKnownConsumers = selectedKnownConsumers;
 277     }
 278
 279     public void setSelectedInvalidConsumers( List<InvalidRepositoryContentConsumer> selectedInvalidConsumers )
 280     {
 281         this.selectedInvalidConsumers = selectedInvalidConsumers;
 282     }
 283
 284     protected Date getStartTime()
 285     {
 286         return new Date( System.currentTimeMillis() );
 287     }
 288
 289     public void setArchivaConfiguration( ArchivaConfiguration archivaConfiguration )
 290     {
 291         this.archivaConfiguration = archivaConfiguration;
 292     }
 293 }