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.common.utils.VersionUtil;
  23 import org.apache.archiva.repository.content.StorageAsset;
  24 import org.apache.commons.lang.StringUtils;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27
  28 import java.io.IOException;
  29 import java.nio.file.Files;
  30 import java.util.ArrayList;
  31 import java.util.Calendar;
  32 import java.util.Date;
  33 import java.util.List;
  34 import java.util.Properties;
  35
  36 /**
  37  * AbstractUpdatePolicy
  38  *
  39  *
  40  */
  41 public abstract class AbstractUpdatePolicy
  42     implements PreDownloadPolicy
  43 {
  44     private Logger log = LoggerFactory.getLogger( AbstractUpdatePolicy.class );
  45
  46     /**
  47      * The ALWAYS policy setting means that the artifact is always uipdated from the remote repo.
  48      */
  49     public static final String ALWAYS = "always";
  50
  51     /**
  52      * The NEVER policy setting means that the artifact is never updated from the remote repo.
  53      */
  54     public static final String NEVER = "never";
  55
  56     /**
  57      * <p>
  58      * The DAILY policy means that the artifact retrieval occurs only if one of
  59      * the following conditions are met...
  60      * </p>
  61      * <ul>
  62      * <li>The local artifact is not present.</li>
  63      * <li>The local artifact has a last modified timestamp older than (now - 1 day).</li>
  64      * </ul>
  65      */
  66     public static final String DAILY = "daily";
  67
  68     /**
  69      * <p>
  70      * The HOURLY policy means that the artifact retrieval occurs only if one of
  71      * the following conditions are met...
  72      * </p>
  73      * <ul>
  74      * <li>The local artifact is not present.</li>
  75      * <li>The local artifact has a last modified timestamp older than (now - 1 hour).</li>
  76      * </ul>
  77      */
  78     public static final String HOURLY = "hourly";
  79
  80     /**
  81      * The ONCE policy means that the artifact retrieval occurs only if the
  82      * local artifact is not present.  This means that the retreival can only
  83      * occur once.
  84      */
  85     public static final String ONCE = "once";
  86
  87     private List<String> options = new ArrayList<>( 5 );
  88
  89     public AbstractUpdatePolicy()
  90     {
  91         options.add( ALWAYS );
  92         options.add( HOURLY );
  93         options.add( DAILY );
  94         options.add( ONCE );
  95         options.add( NEVER );
  96     }
  97
  98     protected abstract boolean isSnapshotPolicy();
  99
 100     protected abstract String getUpdateMode();
 101
 102     @Override
 103     public List<String> getOptions()
 104     {
 105         return options;
 106     }
 107
 108     @Override
 109     public void applyPolicy( String policySetting, Properties request, StorageAsset localFile )
 110         throws PolicyViolationException, PolicyConfigurationException
 111     {
 112         if ( !StringUtils.equals( request.getProperty( "filetype" ), "artifact" ) )
 113         {
 114             // Only process artifact file types.
 115             return;
 116         }
 117
 118         String version = request.getProperty( "version", "" );
 119         boolean isSnapshotVersion = false;
 120
 121         if ( StringUtils.isNotBlank( version ) )
 122         {
 123             isSnapshotVersion = VersionUtil.isSnapshot( version );
 124         }
 125
 126         if ( !options.contains( policySetting ) )
 127         {
 128             // Not a valid code.
 129             throw new PolicyConfigurationException(
 130                 "Unknown " + getUpdateMode() + " policy setting [" + policySetting + "], valid settings are ["
 131                     + StringUtils.join( options.iterator(), "," ) + "]" );
 132         }
 133
 134         if ( ALWAYS.equals( policySetting ) )
 135         {
 136             // Skip means ok to update.
 137             log.debug( "OK to update, {} policy set to ALWAYS.", getUpdateMode() );
 138             return;
 139         }
 140
 141         // Test for mismatches.
 142         if ( !isSnapshotVersion && isSnapshotPolicy() )
 143         {
 144             log.debug( "OK to update, snapshot policy does not apply for non-snapshot versions." );
 145             return;
 146         }
 147
 148         if ( isSnapshotVersion && !isSnapshotPolicy() )
 149         {
 150             log.debug( "OK to update, release policy does not apply for snapshot versions." );
 151             return;
 152         }
 153
 154         if ( NEVER.equals( policySetting ) )
 155         {
 156             // Reject means no.
 157             throw new PolicyViolationException( "NO to update, " + getUpdateMode() + " policy set to NEVER." );
 158         }
 159
 160         if ( !localFile.exists() )
 161         {
 162             // No file means it's ok.
 163             log.debug( "OK to update {}, local file does not exist.", getUpdateMode() );
 164             return;
 165         }
 166
 167         if ( ONCE.equals( policySetting ) )
 168         {
 169             // File exists, but policy is once.
 170             throw new PolicyViolationException(
 171                 "NO to update " + getUpdateMode() + ", policy is ONCE, and local file exist." );
 172         }
 173
 174         if ( DAILY.equals( policySetting ) )
 175         {
 176             Calendar cal = Calendar.getInstance();
 177             cal.add( Calendar.DAY_OF_MONTH, -1 );
 178             Calendar fileCal = Calendar.getInstance();
 179             fileCal.setTimeInMillis( localFile.getModificationTime().toEpochMilli() );
 180
 181             if ( cal.after( fileCal ) )
 182             {
 183                 // Its ok.
 184                 return;
 185             }
 186             else
 187             {
 188                 throw new PolicyViolationException( "NO to update " + getUpdateMode()
 189                                                         + ", policy is DAILY, local file exist, and has been updated within the last day." );
 190             }
 191         }
 192
 193         if ( HOURLY.equals( policySetting ) )
 194         {
 195             Calendar cal = Calendar.getInstance();
 196             cal.add( Calendar.HOUR, -1 );
 197             Calendar fileCal = Calendar.getInstance();
 198             fileCal.setTimeInMillis( localFile.getModificationTime().toEpochMilli());
 199
 200             if ( cal.after( fileCal ) )
 201             {
 202                 // Its ok.
 203                 return;
 204             }
 205             else
 206             {
 207                 throw new PolicyViolationException( "NO to update " + getUpdateMode()
 208                                                         + ", policy is HOURLY, local file exist, and has been updated within the last hour." );
 209             }
 210         }
 211
 212         throw new PolicyConfigurationException(
 213             "Unable to process " + getUpdateMode() + " policy of [" + policySetting + "], please file a bug report." );
 214     }
 215 }