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