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     public List<KnownRepositoryContentConsumer> getAvailableKnownConsumers()
 206     {
 207         return new ArrayList( applicationContext.getBeansOfType( KnownRepositoryContentConsumer.class ).values() );
 208     }
 209
 210     /**
 211      * Get the list of {@link InvalidRepositoryContentConsumer} objects that are available and present in the classpath
 212      * and as components in the IoC.
 213      *
 214      * @return the list of all available {@link InvalidRepositoryContentConsumer} present in the classpath and as a
 215      *         component in the IoC.
 216      */
 217     public List<InvalidRepositoryContentConsumer> getAvailableInvalidConsumers()
 218     {
 219         return new ArrayList( applicationContext.getBeansOfType( InvalidRepositoryContentConsumer.class ).values() );
 220     }
 221
 222     /**
 223      * A convienence method to execute all of the active selected consumers for a particular arbitrary file.
 224      *
 225      * @param repository the repository configuration to use.
 226      * @param localFile the local file to execute the consumers against.
 227      */
 228     public void executeConsumers( ManagedRepositoryConfiguration repository, File localFile )
 229     {
 230         // Run the repository consumers
 231         try
 232         {
 233             Closure triggerBeginScan = new TriggerBeginScanClosure( repository, getStartTime() );
 234
 235             List<KnownRepositoryContentConsumer> selectedKnownConsumers = getSelectedKnownConsumers();
 236             List<InvalidRepositoryContentConsumer> selectedInvalidConsumers = getSelectedInvalidConsumers();
 237             CollectionUtils.forAllDo( selectedKnownConsumers, triggerBeginScan );
 238             CollectionUtils.forAllDo( selectedInvalidConsumers, triggerBeginScan );
 239
 240             // yuck. In case you can't read this, it says
 241             // "process the file if the consumer has it in the includes list, and not in the excludes list"
 242             BaseFile baseFile = new BaseFile( repository.getLocation(), localFile );
 243             ConsumerWantsFilePredicate predicate = new ConsumerWantsFilePredicate();
 244             predicate.setBasefile( baseFile );
 245             ConsumerProcessFileClosure closure = new ConsumerProcessFileClosure();
 246             closure.setBasefile( baseFile );
 247             predicate.setCaseSensitive( false );
 248             Closure processIfWanted = IfClosure.getInstance( predicate, closure );
 249
 250             CollectionUtils.forAllDo( selectedKnownConsumers, processIfWanted );
 251
 252             if ( predicate.getWantedFileCount() <= 0 )
 253             {
 254                 // Nothing known processed this file. It is invalid!
 255                 CollectionUtils.forAllDo( selectedInvalidConsumers, closure );
 256             }
 257
 258             TriggerScanCompletedClosure scanCompletedClosure = new TriggerScanCompletedClosure( repository );
 259
 260             CollectionUtils.forAllDo( selectedKnownConsumers, scanCompletedClosure );
 261         }
 262         finally
 263         {
 264             /*
 265              * TODO: This is never called by the repository scanner instance, so not calling here either - but it
 266              * probably should be? CollectionUtils.forAllDo( availableKnownConsumers, triggerCompleteScan );
 267              * CollectionUtils.forAllDo( availableInvalidConsumers, triggerCompleteScan );
 268              */
 269         }
 270     }
 271
 272     public void setSelectedKnownConsumers( List<KnownRepositoryContentConsumer> selectedKnownConsumers )
 273     {
 274         this.selectedKnownConsumers = selectedKnownConsumers;
 275     }
 276
 277     public void setSelectedInvalidConsumers( List<InvalidRepositoryContentConsumer> selectedInvalidConsumers )
 278     {
 279         this.selectedInvalidConsumers = selectedInvalidConsumers;
 280     }
 281
 282     protected Date getStartTime()
 283     {
 284         return new Date( System.currentTimeMillis() );
 285     }
 286
 287     public void setArchivaConfiguration( ArchivaConfiguration archivaConfiguration )
 288     {
 289         this.archivaConfiguration = archivaConfiguration;
 290     }
 291 }