Coverage Report

Coverage Report - org.apache.maven.archiva.policies.AbstractUpdatePolicy

Classes in this File

0/51

0/30

 package org.apache.maven.archiva.policies;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 
 import java.io.File;
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.List;
 import java.util.Properties;
 
 import org.apache.commons.lang.StringUtils;
 import org.apache.maven.archiva.common.utils.VersionUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
  * AbstractUpdatePolicy 
  *
  * @version $Id: AbstractUpdatePolicy.java 718864 2008-11-19 06:33:35Z brett $
  */
 public abstract class AbstractUpdatePolicy
     implements PreDownloadPolicy
 {
     private Logger log = LoggerFactory.getLogger( AbstractUpdatePolicy.class );
     
     /**
      * The ALWAYS policy setting means that the artifact is always uipdated from the remote repo.
      */
     public static final String ALWAYS = "always";
     
     /**
      * The NEVER policy setting means that the artifact is never updated from the remote repo.
      */
     public static final String NEVER = "never";
 
     /**
      * <p>
      * The DAILY policy means that the artifact retrieval occurs only if one of
      * the following conditions are met...
      * </p>
      * <ul>
      *   <li>The local artifact is not present.</li>
      *   <li>The local artifact has a last modified timestamp older than (now - 1 day).</li>
      * </ul>
      */
     public static final String DAILY = "daily";
 
     /**
      * <p>
      * The HOURLY policy means that the artifact retrieval occurs only if one of
      * the following conditions are met...
      * </p>
      * <ul>
      *   <li>The local artifact is not present.</li>
      *   <li>The local artifact has a last modified timestamp older than (now - 1 hour).</li>
      * </ul>
      */
     public static final String HOURLY = "hourly";
 
     /**
      * The ONCE policy means that the artifact retrieval occurs only if the
      * local artifact is not present.  This means that the retreival can only
      * occur once.
      */
     public static final String ONCE = "once";
 
     private List<String> options = new ArrayList<String>();
 
     public AbstractUpdatePolicy()
     {
         options.add( ALWAYS );
         options.add( HOURLY );
         options.add( DAILY );
         options.add( ONCE );
         options.add( NEVER );
     }
 
     protected abstract boolean isSnapshotPolicy();
     
     protected abstract String getUpdateMode();
     
     public List<String> getOptions()
     {
         return options;
     }
 
     public void applyPolicy( String policySetting, Properties request, File localFile )
         throws PolicyViolationException, PolicyConfigurationException
     {
         if ( !StringUtils.equals( request.getProperty( "filetype" ), "artifact" ) )
         {
             // Only process artifact file types.
             return;
         }
         
         String version = request.getProperty( "version", "" );
         boolean isSnapshotVersion = false;
 
         if ( StringUtils.isNotBlank( version ) )
         {
             isSnapshotVersion = VersionUtil.isSnapshot( version );
         }
 
         if ( !options.contains( policySetting ) )
         {
             // Not a valid code. 
             throw new PolicyConfigurationException( "Unknown " + getUpdateMode() + " policy setting [" + policySetting
                 + "], valid settings are [" + StringUtils.join( options.iterator(), "," ) + "]" );
         }
 
         if ( ALWAYS.equals( policySetting ) )
         {
             // Skip means ok to update.
             log.debug( "OK to update, " + getUpdateMode() + " policy set to ALWAYS." );
             return;
         }
 
         // Test for mismatches.
         if ( !isSnapshotVersion && isSnapshotPolicy() )
         {
             log.debug( "OK to update, snapshot policy does not apply for non-snapshot versions." );
             return;
         }
 
         if ( isSnapshotVersion && !isSnapshotPolicy() )
         {
             log.debug( "OK to update, release policy does not apply for snapshot versions." );
             return;
         }
 
         if ( NEVER.equals( policySetting ) )
         {
             // Reject means no.
             throw new PolicyViolationException( "NO to update, " + getUpdateMode() + " policy set to NEVER." );
         }
 
         if ( !localFile.exists() )
         {
             // No file means it's ok.
             log.debug( "OK to update " + getUpdateMode() + ", local file does not exist." );
             return;
         }
 
         if ( ONCE.equals( policySetting ) )
         {
             // File exists, but policy is once.
             throw new PolicyViolationException( "NO to update " + getUpdateMode() + ", policy is ONCE, and local file exist." );
         }
 
         if ( DAILY.equals( policySetting ) )
         {
             Calendar cal = Calendar.getInstance();
             cal.add( Calendar.DAY_OF_MONTH, -1 );
             Calendar fileCal = Calendar.getInstance();
             fileCal.setTimeInMillis( localFile.lastModified() );
 
             if( cal.after( fileCal ) )
             {
                 // Its ok.
                 return;
             }
             else
             {
                 throw new PolicyViolationException( "NO to update " + getUpdateMode()
                     + ", policy is DAILY, local file exist, and has been updated within the last day." );
             }
         }
 
         if ( HOURLY.equals( policySetting ) )
         {
             Calendar cal = Calendar.getInstance();
             cal.add( Calendar.HOUR, -1 );
             Calendar fileCal = Calendar.getInstance();
             fileCal.setTimeInMillis( localFile.lastModified() );
 
             if( cal.after( fileCal ) )
             {
                 // Its ok.
                 return;
             }
             else
             {
                 throw new PolicyViolationException( "NO to update " + getUpdateMode()
                     + ", policy is HOURLY, local file exist, and has been updated within the last hour." );
             }
         }
 
         throw new PolicyConfigurationException( "Unable to process " + getUpdateMode()
                                             + " policy of [" + policySetting + "], please file a bug report." );
     }
 }

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