| package org.apache.archiva.redback.components.scheduler; |
| |
| /* |
| * 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 org.apache.commons.lang.StringUtils; |
| import org.quartz.CronScheduleBuilder; |
| import org.quartz.CronTrigger; |
| import org.quartz.TriggerBuilder; |
| import org.springframework.stereotype.Service; |
| |
| import java.text.ParseException; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.StringTokenizer; |
| |
| /** |
| * @author <a href="mailto:evenisse@codehaus.org">Emmanuel Venisse</a> |
| * |
| */ |
| @Service |
| public final class CronExpressionValidator |
| { |
| |
| /** |
| * Validates a cron expression. |
| * |
| * @param cronExpression The expression to validate |
| * @return True is expression is valid |
| */ |
| public boolean validate( String cronExpression ) |
| { |
| try |
| { |
| String[] cronParams = StringUtils.split( cronExpression ); |
| |
| if ( cronParams.length < 6 || cronParams.length > 7 ) |
| { |
| return false; |
| } |
| |
| CronTrigger cronTrigger = TriggerBuilder.newTrigger() |
| .withSchedule( CronScheduleBuilder.cronSchedule( cronExpression ) ) |
| .build(); |
| |
| |
| |
| if ( cronParams[3].equals( "?" ) || cronParams[5].equals( "?" ) ) |
| { |
| //Check seconds param |
| if ( !checkSecondsField( cronParams[0] ) ) |
| { |
| return false; |
| } |
| |
| //Check minutes param |
| if ( !checkMinutesField( cronParams[1] ) ) |
| { |
| return false; |
| } |
| |
| //Check hours param |
| if ( !checkHoursField( cronParams[2] ) ) |
| { |
| return false; |
| } |
| |
| //Check day-of-month param |
| if ( !checkDayOfMonthField( cronParams[3] ) ) |
| { |
| return false; |
| } |
| |
| //Check months param |
| if ( !checkMonthsField( cronParams[4] ) ) |
| { |
| return false; |
| } |
| |
| //Check day-of-week param |
| if ( !checkDayOfWeekField( cronParams[5] ) ) |
| { |
| return false; |
| } |
| |
| //Check year param |
| if ( cronParams.length == 7 ) |
| { |
| if ( !checkYearField( cronParams[6] ) ) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| catch ( RuntimeException e ) |
| { |
| return false; |
| } |
| } |
| |
| private boolean checkSecondsField( String secondsField ) |
| { |
| return checkField( secondsField, 0, 59 ); |
| } |
| |
| private boolean checkMinutesField( String minutesField ) |
| { |
| return checkField( minutesField, 0, 59 ); |
| } |
| |
| private boolean checkHoursField( String hoursField ) |
| { |
| return checkField( hoursField, 0, 23 ); |
| } |
| |
| private boolean checkDayOfMonthField( String dayOfMonthField ) |
| { |
| if ( "?".equals( dayOfMonthField ) ) |
| { |
| return true; |
| } |
| |
| if ( dayOfMonthField.indexOf( 'L' ) >= 0 ) |
| { |
| return checkFieldWithLetter( dayOfMonthField, "L", 1, 7, -1, -1 ); |
| } |
| else if ( dayOfMonthField.indexOf( 'W' ) >= 0 ) |
| { |
| return checkFieldWithLetter( dayOfMonthField, "W", 1, 31, -1, -1 ); |
| } |
| else if ( dayOfMonthField.indexOf( 'C' ) >= 0 ) |
| { |
| return checkFieldWithLetter( dayOfMonthField, "C", 1, 31, -1, -1 ); |
| } |
| else |
| { |
| return checkField( dayOfMonthField, 1, 31 ); |
| } |
| } |
| |
| private boolean checkMonthsField( String monthsField ) |
| { |
| monthsField = StringUtils.replace( monthsField, "JAN", "1" ); |
| monthsField = StringUtils.replace( monthsField, "FEB", "2" ); |
| monthsField = StringUtils.replace( monthsField, "MAR", "3" ); |
| monthsField = StringUtils.replace( monthsField, "APR", "4" ); |
| monthsField = StringUtils.replace( monthsField, "MAY", "5" ); |
| monthsField = StringUtils.replace( monthsField, "JUN", "6" ); |
| monthsField = StringUtils.replace( monthsField, "JUL", "7" ); |
| monthsField = StringUtils.replace( monthsField, "AUG", "8" ); |
| monthsField = StringUtils.replace( monthsField, "SEP", "9" ); |
| monthsField = StringUtils.replace( monthsField, "OCT", "10" ); |
| monthsField = StringUtils.replace( monthsField, "NOV", "11" ); |
| monthsField = StringUtils.replace( monthsField, "DEC", "12" ); |
| |
| return checkField( monthsField, 1, 31 ); |
| } |
| |
| private boolean checkDayOfWeekField( String dayOfWeekField ) |
| { |
| dayOfWeekField = StringUtils.replace( dayOfWeekField, "SUN", "1" ); |
| dayOfWeekField = StringUtils.replace( dayOfWeekField, "MON", "2" ); |
| dayOfWeekField = StringUtils.replace( dayOfWeekField, "TUE", "3" ); |
| dayOfWeekField = StringUtils.replace( dayOfWeekField, "WED", "4" ); |
| dayOfWeekField = StringUtils.replace( dayOfWeekField, "THU", "5" ); |
| dayOfWeekField = StringUtils.replace( dayOfWeekField, "FRI", "6" ); |
| dayOfWeekField = StringUtils.replace( dayOfWeekField, "SAT", "7" ); |
| |
| if ( "?".equals( dayOfWeekField ) ) |
| { |
| return true; |
| } |
| |
| if ( dayOfWeekField.indexOf( 'L' ) >= 0 ) |
| { |
| return checkFieldWithLetter( dayOfWeekField, "L", 1, 7, -1, -1 ); |
| } |
| else if ( dayOfWeekField.indexOf( 'C' ) >= 0 ) |
| { |
| return checkFieldWithLetter( dayOfWeekField, "C", 1, 7, -1, -1 ); |
| } |
| else if ( dayOfWeekField.indexOf( '#' ) >= 0 ) |
| { |
| return checkFieldWithLetter( dayOfWeekField, "#", 1, 7, 1, 5 ); |
| } |
| else |
| { |
| return checkField( dayOfWeekField, 1, 7 ); |
| } |
| } |
| |
| private boolean checkYearField( String yearField ) |
| { |
| return checkField( yearField, 1970, 2099 ); |
| } |
| |
| private boolean checkField( String secondsField, int minimal, int maximal ) |
| { |
| if ( secondsField.indexOf( '-' ) > -1 ) |
| { |
| String startValue = secondsField.substring( 0, secondsField.indexOf( "-" ) ); |
| String endValue = secondsField.substring( secondsField.indexOf( "-" ) + 1 ); |
| |
| if ( !( checkIntValue( startValue, minimal, maximal ) && checkIntValue( endValue, minimal, maximal ) ) ) |
| { |
| return false; |
| } |
| try |
| { |
| int startVal = Integer.parseInt( startValue ); |
| int endVal = Integer.parseInt( endValue ); |
| |
| return endVal > startVal; |
| |
| } |
| catch ( NumberFormatException e ) |
| { |
| return false; |
| } |
| } |
| else if ( secondsField.indexOf( ',' ) > -1 ) |
| { |
| return checkListField( secondsField, minimal, maximal ); |
| } |
| else if ( secondsField.indexOf( '/' ) > -1 ) |
| { |
| return checkIncrementField( secondsField, minimal, maximal ); |
| } |
| else if ( secondsField.indexOf( '*' ) != -1 ) |
| { |
| return true; |
| } |
| else |
| { |
| return checkIntValue( secondsField, minimal, maximal ); |
| } |
| } |
| |
| private boolean checkFieldWithLetter( String value, String letter, int minimalBefore, int maximalBefore, |
| int minimalAfter, int maximalAfter ) |
| { |
| boolean canBeAlone = false; |
| boolean canHaveIntBefore = false; |
| boolean canHaveIntAfter = false; |
| boolean mustHaveIntBefore = false; |
| boolean mustHaveIntAfter = false; |
| |
| if ( "L".equals( letter ) ) |
| { |
| canBeAlone = true; |
| canHaveIntBefore = true; |
| canHaveIntAfter = false; |
| mustHaveIntBefore = false; |
| mustHaveIntAfter = false; |
| } |
| if ( "W".equals( letter ) || "C".equals( letter ) ) |
| { |
| canBeAlone = false; |
| canHaveIntBefore = true; |
| canHaveIntAfter = false; |
| mustHaveIntBefore = true; |
| mustHaveIntAfter = false; |
| } |
| if ( "#".equals( letter ) ) |
| { |
| canBeAlone = false; |
| canHaveIntBefore = true; |
| canHaveIntAfter = true; |
| mustHaveIntBefore = true; |
| mustHaveIntAfter = true; |
| } |
| |
| String beforeLetter = ""; |
| String afterLetter = ""; |
| |
| if ( value.indexOf( letter ) >= 0 ) |
| { |
| beforeLetter = value.substring( 0, value.indexOf( letter ) ); |
| } |
| |
| if ( !value.endsWith( letter ) ) |
| { |
| afterLetter = value.substring( value.indexOf( letter ) + 1 ); |
| } |
| |
| if ( value.indexOf( letter ) >= 0 ) |
| { |
| if ( letter.equals( value ) ) |
| { |
| return canBeAlone; |
| } |
| |
| if ( canHaveIntBefore ) |
| { |
| if ( mustHaveIntBefore && beforeLetter.length() == 0 ) |
| { |
| return false; |
| } |
| |
| if ( !checkIntValue( beforeLetter, minimalBefore, maximalBefore, true ) ) |
| { |
| return false; |
| } |
| } |
| else |
| { |
| if ( beforeLetter.length() > 0 ) |
| { |
| return false; |
| } |
| } |
| |
| if ( canHaveIntAfter ) |
| { |
| if ( mustHaveIntAfter && afterLetter.length() == 0 ) |
| { |
| return false; |
| } |
| |
| if ( !checkIntValue( afterLetter, minimalAfter, maximalAfter, true ) ) |
| { |
| return false; |
| } |
| } |
| else |
| { |
| if ( afterLetter.length() > 0 ) |
| { |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| private boolean checkIncrementField( String value, int minimal, int maximal ) |
| { |
| String start = value.substring( 0, value.indexOf( '/' ) ); |
| |
| String increment = value.substring( value.indexOf( '/' ) + 1 ); |
| |
| if ( !"*".equals( start ) ) |
| { |
| return checkIntValue( start, minimal, maximal ) && checkIntValue( increment, minimal, maximal, false ); |
| } |
| else |
| { |
| return checkIntValue( increment, minimal, maximal ); |
| } |
| } |
| |
| private boolean checkListField( String value, int minimal, int maximal ) |
| { |
| StringTokenizer st = new StringTokenizer( value, "," ); |
| |
| List<String> values = new ArrayList<>(); |
| |
| while ( st.hasMoreTokens() ) |
| { |
| values.add( st.nextToken() ); |
| } |
| |
| int previousValue = -1; |
| |
| for ( Iterator<String> i = values.iterator(); i.hasNext(); ) |
| { |
| String currentValue = i.next(); |
| |
| if ( !checkIntValue( currentValue, minimal, maximal ) ) |
| { |
| return false; |
| } |
| |
| try |
| { |
| int val = Integer.parseInt( currentValue ); |
| |
| if ( val <= previousValue ) |
| { |
| return false; |
| } |
| else |
| { |
| previousValue = val; |
| } |
| } |
| catch ( NumberFormatException e ) |
| { |
| // we have always an int |
| } |
| } |
| |
| return true; |
| } |
| |
| private boolean checkIntValue( String value, int minimal, int maximal ) |
| { |
| return checkIntValue( value, minimal, maximal, true ); |
| } |
| |
| private static boolean checkIntValue( String value, int minimal, int maximal, boolean checkExtremity ) |
| { |
| try |
| { |
| int val = Integer.parseInt( value ); |
| |
| if ( checkExtremity ) |
| { |
| if ( val < minimal || val > maximal ) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| catch ( NumberFormatException e ) |
| { |
| return false; |
| } |
| } |
| } |
