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

   1 package org.apache.archiva.consumers.functors;
   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.utils.BaseFile;
  23 import org.apache.archiva.consumers.RepositoryContentConsumer;
  24 import org.apache.archiva.repository.ManagedRepository;
  25 import org.apache.archiva.repository.features.IndexCreationFeature;
  26 import org.apache.commons.collections.Predicate;
  27 import org.apache.commons.io.FilenameUtils;
  28 import org.apache.commons.lang.StringUtils;
  29 import org.apache.tools.ant.types.selectors.SelectorUtils;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 import java.nio.file.Paths;
  34 import java.util.List;
  35
  36 /**
  37  * ConsumerWantsFilePredicate
  38  */
  39 public class ConsumerWantsFilePredicate
  40     implements Predicate
  41 {
  42     private BaseFile basefile;
  43
  44     private boolean isCaseSensitive = true;
  45
  46     private int wantedFileCount = 0;
  47
  48     private long changesSince = 0;
  49
  50     private ManagedRepository managedRepository;
  51
  52     private Logger logger = LoggerFactory.getLogger( getClass() );
  53
  54     /**
  55      * @deprecated use constructor with ManagedRepository
  56      */
  57     public ConsumerWantsFilePredicate()
  58     {
  59         // no-op
  60     }
  61
  62     public ConsumerWantsFilePredicate( ManagedRepository managedRepository )
  63     {
  64         this.managedRepository = managedRepository;
  65     }
  66
  67     @Override
  68     public boolean evaluate( Object object )
  69     {
  70         boolean satisfies = false;
  71
  72         if ( object instanceof RepositoryContentConsumer )
  73         {
  74             RepositoryContentConsumer consumer = (RepositoryContentConsumer) object;
  75             if ( wantsFile( consumer, FilenameUtils.separatorsToUnix( basefile.getRelativePath() ) ) )
  76             {
  77                 satisfies = true;
  78
  79                 // regardless of the timestamp, we record that it was wanted so it doesn't get counted as invalid
  80                 wantedFileCount++;
  81
  82                 if ( !consumer.isProcessUnmodified() )
  83                 {
  84                     // Timestamp finished points to the last successful scan, not this current one.
  85                     if ( basefile.lastModified() < changesSince )
  86                     {
  87                         // Skip file as no change has occurred.
  88                         satisfies = false;
  89                     }
  90                 }
  91             }
  92         }
  93
  94         return satisfies;
  95     }
  96
  97     public BaseFile getBasefile()
  98     {
  99         return basefile;
 100     }
 101
 102     public int getWantedFileCount()
 103     {
 104         return wantedFileCount;
 105     }
 106
 107     public boolean isCaseSensitive()
 108     {
 109         return isCaseSensitive;
 110     }
 111
 112     public void setBasefile( BaseFile basefile )
 113     {
 114         this.basefile = basefile;
 115         this.wantedFileCount = 0;
 116     }
 117
 118     public void setCaseSensitive( boolean isCaseSensitive )
 119     {
 120         this.isCaseSensitive = isCaseSensitive;
 121     }
 122
 123     private boolean wantsFile( RepositoryContentConsumer consumer, String relativePath )
 124     {
 125         // Test excludes first.
 126         List<String> excludes = consumer.getExcludes();
 127         if ( excludes != null )
 128         {
 129             for ( String pattern : excludes )
 130             {
 131                 if ( SelectorUtils.matchPath( pattern, relativePath, isCaseSensitive ) )
 132                 {
 133                     // Definately does NOT WANT FILE.
 134                     return false;
 135                 }
 136             }
 137         }
 138
 139         if ( managedRepository != null )
 140         {
 141             String indexDirectory;
 142             if (managedRepository.supportsFeature( IndexCreationFeature.class )) {
 143                 IndexCreationFeature icf = managedRepository.getFeature( IndexCreationFeature.class ).get();
 144                 if (icf.getIndexPath()==null) {
 145                     indexDirectory=".index";
 146                 } else
 147                 {
 148                     indexDirectory = ( icf.getIndexPath( ).getScheme( ) == null ? Paths.get( icf.getIndexPath( ).getPath( ) ) : Paths.get( icf.getIndexPath( ) ) ).toString( );
 149                 }
 150             } else {
 151                 indexDirectory = ".index";
 152             }
 153             if (StringUtils.isEmpty( indexDirectory )) {
 154                 indexDirectory = ".index";
 155             }
 156             if ( StringUtils.startsWith( relativePath, indexDirectory ) )
 157             {
 158                 logger.debug( "ignore file {} part of the index directory {}", relativePath, indexDirectory );
 159                 return false;
 160             }
 161         }
 162
 163         // Now test includes.
 164         for ( String pattern : consumer.getIncludes() )
 165         {
 166             if ( SelectorUtils.matchPath( pattern, relativePath, isCaseSensitive ) )
 167             {
 168                 // Specifically WANTS FILE.
 169                 return true;
 170             }
 171         }
 172
 173         // Not included, and Not excluded?  Default to EXCLUDE.
 174         return false;
 175     }
 176
 177     public void setChangesSince( long changesSince )
 178     {
 179         this.changesSince = changesSince;
 180     }
 181 }