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

   1 package org.apache.archiva.policies;
   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.checksum.ChecksumAlgorithm;
  23 import org.apache.archiva.checksum.ChecksummedFile;
  24 import org.apache.commons.lang.StringUtils;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27 import org.springframework.stereotype.Service;
  28
  29 import java.io.IOException;
  30 import java.nio.file.Files;
  31 import java.nio.file.Path;
  32 import java.util.ArrayList;
  33 import java.util.List;
  34 import java.util.Properties;
  35
  36 /**
  37  * ChecksumPolicy - a policy applied after the download to see if the file has been downloaded
  38  * successfully and completely (or not).
  39  *
  40  *
  41  */
  42 @Service( "postDownloadPolicy#checksum" )
  43 public class ChecksumPolicy
  44     implements PostDownloadPolicy
  45 {
  46     private Logger log = LoggerFactory.getLogger( ChecksumPolicy.class );
  47
  48     /**
  49      * The IGNORE policy indicates that if the checksum policy is ignored, and
  50      * the state of, contents of, or validity of the checksum files are not
  51      * checked.
  52      */
  53     public static final String IGNORE = "ignore";
  54
  55     /**
  56      * The FAIL policy indicates that if the checksum does not match the
  57      * downloaded file, then remove the downloaded artifact, and checksum
  58      * files, and fail the transfer to the client side.
  59      */
  60     public static final String FAIL = "fail";
  61
  62     /**
  63      * The FIX policy indicates that if the checksum does not match the
  64      * downloaded file, then fix the checksum file locally, and return
  65      * to the client side the corrected checksum.
  66      */
  67     public static final String FIX = "fix";
  68
  69     private ChecksumAlgorithm[] algorithms = new ChecksumAlgorithm[]{ ChecksumAlgorithm.SHA1, ChecksumAlgorithm.MD5 };
  70
  71     private List<String> options = new ArrayList<>( 3 );
  72
  73     public ChecksumPolicy()
  74     {
  75         options.add( FAIL );
  76         options.add( FIX );
  77         options.add( IGNORE );
  78     }
  79
  80     @Override
  81     public void applyPolicy( String policySetting, Properties request, Path localFile )
  82         throws PolicyViolationException, PolicyConfigurationException
  83     {
  84         if ( "resource".equals( request.getProperty( "filetype" ) ) )
  85         {
  86             return;
  87         }
  88
  89         if ( !options.contains( policySetting ) )
  90         {
  91             // Not a valid code.
  92             throw new PolicyConfigurationException(
  93                 "Unknown checksum policy setting [" + policySetting + "], valid settings are [" + StringUtils.join(
  94                     options.iterator(), "," ) + "]" );
  95         }
  96
  97         if ( IGNORE.equals( policySetting ) )
  98         {
  99             // Ignore.
 100             log.debug( "Checksum policy set to IGNORE." );
 101             return;
 102         }
 103
 104         if ( !Files.exists(localFile) )
 105         {
 106             // Local File does not exist.
 107             throw new PolicyViolationException(
 108                 "Checksum policy failure, local file " + localFile.toAbsolutePath() + " does not exist to check." );
 109         }
 110
 111         if ( FAIL.equals( policySetting ) )
 112         {
 113             ChecksummedFile checksum = new ChecksummedFile( localFile );
 114             if ( checksum.isValidChecksums( algorithms ) )
 115             {
 116                 return;
 117             }
 118
 119             for ( ChecksumAlgorithm algorithm : algorithms )
 120             {
 121                 Path file = localFile.toAbsolutePath().resolveSibling( localFile.getFileName() + "." + algorithm.getExt() );
 122                 try
 123                 {
 124                     Files.deleteIfExists( file );
 125                 }
 126                 catch ( IOException e )
 127                 {
 128                     log.error("Could not delete file {}", file);
 129                 }
 130             }
 131
 132             try
 133             {
 134                 Files.deleteIfExists( localFile );
 135             }
 136             catch ( IOException e )
 137             {
 138                 log.error("Could not delete file {}", localFile);
 139             }
 140             throw new PolicyViolationException(
 141                 "Checksums do not match, policy set to FAIL, " + "deleting checksum files and local file "
 142                     + localFile.toAbsolutePath() + "." );
 143         }
 144
 145         if ( FIX.equals( policySetting ) )
 146         {
 147             ChecksummedFile checksum = new ChecksummedFile( localFile );
 148             if ( checksum.fixChecksums( algorithms ) )
 149             {
 150                 log.debug( "Checksum policy set to FIX, checksum files have been updated." );
 151                 return;
 152             }
 153             else
 154             {
 155                 throw new PolicyViolationException(
 156                     "Checksum policy set to FIX, " + "yet unable to update checksums for local file "
 157                         + localFile.toAbsolutePath() + "." );
 158             }
 159         }
 160
 161         throw new PolicyConfigurationException(
 162             "Unable to process checksum policy of [" + policySetting + "], please file a bug report." );
 163     }
 164
 165     @Override
 166     public String getDefaultOption()
 167     {
 168         return FIX;
 169     }
 170
 171     @Override
 172     public String getId()
 173     {
 174         return "checksum";
 175     }
 176
 177     @Override
 178     public String getName()
 179     {
 180         return "Checksum";
 181     }
 182
 183     @Override
 184     public List<String> getOptions()
 185     {
 186         return options;
 187     }
 188 }