src/main/java/org/apache/commons/net/ftp/parser/FTPTimestampParserImpl.java - commons-net - Git at Google

 /*
  * 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.
  */

 package org.apache.commons.net.ftp.parser;

 import java.text.DateFormatSymbols;
 import java.text.ParseException;
 import java.text.ParsePosition;
 import java.text.SimpleDateFormat;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.TimeZone;

 import org.apache.commons.net.ftp.Configurable;
 import org.apache.commons.net.ftp.FTPClientConfig;

 /**
  * Default implementation of the {@link  FTPTimestampParser  FTPTimestampParser}
  * interface also implements the {@link  org.apache.commons.net.ftp.Configurable  Configurable}
  * interface to allow the parsing to be configured from the outside.
  *
  * @see ConfigurableFTPFileEntryParserImpl
  * @since 1.4
  */
 public class FTPTimestampParserImpl implements
         FTPTimestampParser, Configurable
 {


     private SimpleDateFormat defaultDateFormat;
     private SimpleDateFormat recentDateFormat;
     private boolean lenientFutureDates = false;


     /**
      * The only constructor for this class.
      */
     public FTPTimestampParserImpl() {
         setDefaultDateFormat(DEFAULT_SDF);
         setRecentDateFormat(DEFAULT_RECENT_SDF);
     }

     /**
      * Implements the one {@link  FTPTimestampParser#parseTimestamp(String)  method}
      * in the {@link  FTPTimestampParser  FTPTimestampParser} interface
      * according to this algorithm:
      *
      * If the recentDateFormat member has been defined, try to parse the
      * supplied string with that.  If that parse fails, or if the recentDateFormat
      * member has not been defined, attempt to parse with the defaultDateFormat
      * member.  If that fails, throw a ParseException.
      *
      * This method allows a {@link Calendar} instance to be passed in which represents the
      * current (system) time.
      *
      * @see org.apache.commons.net.ftp.parser.FTPTimestampParser#parseTimestamp(java.lang.String)
      *
      * @param timestampStr The timestamp to be parsed
      */
     public Calendar parseTimestamp(String timestampStr) throws ParseException {
         Calendar now = Calendar.getInstance();
         return parseTimestamp(timestampStr, now);
     }

     /**
      * Implements the one {@link  FTPTimestampParser#parseTimestamp(String)  method}
      * in the {@link  FTPTimestampParser  FTPTimestampParser} interface
      * according to this algorithm:
      *
      * If the recentDateFormat member has been defined, try to parse the
      * supplied string with that.  If that parse fails, or if the recentDateFormat
      * member has not been defined, attempt to parse with the defaultDateFormat
      * member.  If that fails, throw a ParseException.
      *
      * @see org.apache.commons.net.ftp.parser.FTPTimestampParser#parseTimestamp(java.lang.String)
      * @param timestampStr The timestamp to be parsed
      * @param serverTime The current time for the server
      * @since 1.5
      */
     public Calendar parseTimestamp(String timestampStr, Calendar serverTime) throws ParseException {
         Calendar now = (Calendar) serverTime.clone();// Copy this, because we may change it
         now.setTimeZone(this.getServerTimeZone());
         Calendar working = (Calendar) now.clone();
         working.setTimeZone(getServerTimeZone());
         ParsePosition pp = new ParsePosition(0);

         Date parsed = null;
         if (recentDateFormat != null) {
             if (lenientFutureDates) {
                 // add a day to "now" so that "slop" doesn't cause a date
                 // slightly in the future to roll back a full year.  (Bug 35181)
                 now.add(Calendar.DATE, 1);
             }
             parsed = recentDateFormat.parse(timestampStr, pp);
         }
         if (parsed != null && pp.getIndex() == timestampStr.length())
         {
             working.setTime(parsed);
             working.set(Calendar.YEAR, now.get(Calendar.YEAR));

             if (working.after(now)) {
                 working.add(Calendar.YEAR, -1);
             }
         } else {
             // Temporarily add the current year to the short date time
             // to cope with short-date leap year strings.
             // e.g. Java's DateFormatter will assume that "Feb 29 12:00" refers to
             // Feb 29 1970 (an invalid date) rather than a potentially valid leap year date.
             // This is pretty bad hack to work around the deficiencies of the JDK date/time classes.
             if (recentDateFormat != null) {
                 pp = new ParsePosition(0);
                 int year = now.get(Calendar.YEAR);
                 String timeStampStrPlusYear = timestampStr + " " + year;
                 SimpleDateFormat hackFormatter = new SimpleDateFormat(recentDateFormat.toPattern() + " yyyy",
                         recentDateFormat.getDateFormatSymbols());
                 hackFormatter.setLenient(false);
                 hackFormatter.setTimeZone(recentDateFormat.getTimeZone());
                 parsed = hackFormatter.parse(timeStampStrPlusYear, pp);
             }
             if (parsed != null && pp.getIndex() == timestampStr.length() + 5) {
                 working.setTime(parsed);
             }
             else {
                 pp = new ParsePosition(0);
                 parsed = defaultDateFormat.parse(timestampStr, pp);
                 // note, length checks are mandatory for us since
                 // SimpleDateFormat methods will succeed if less than
                 // full string is matched.  They will also accept,
                 // despite "leniency" setting, a two-digit number as
                 // a valid year (e.g. 22:04 will parse as 22 A.D.)
                 // so could mistakenly confuse an hour with a year,
                 // if we don't insist on full length parsing.
                 if (parsed != null && pp.getIndex() == timestampStr.length()) {
                     working.setTime(parsed);
                 } else {
                     throw new ParseException(
                             "Timestamp could not be parsed with older or recent DateFormat",
                             pp.getIndex());
                 }
             }
         }
         return working;
     }

     /**
      * @return Returns the defaultDateFormat.
      */
     public SimpleDateFormat getDefaultDateFormat() {
         return defaultDateFormat;
     }
     /**
      * @return Returns the defaultDateFormat pattern string.
      */
     public String getDefaultDateFormatString() {
         return defaultDateFormat.toPattern();
     }
     /**
      * @param defaultDateFormat The defaultDateFormat to be set.
      */
     private void setDefaultDateFormat(String format) {
         if (format != null) {
             this.defaultDateFormat = new SimpleDateFormat(format);
             this.defaultDateFormat.setLenient(false);
         }
     }
     /**
      * @return Returns the recentDateFormat.
      */
     public SimpleDateFormat getRecentDateFormat() {
         return recentDateFormat;
     }
     /**
      * @return Returns the recentDateFormat.
      */
     public String getRecentDateFormatString() {
         return recentDateFormat.toPattern();
     }
     /**
      * @param recentDateFormat The recentDateFormat to set.
      */
     private void setRecentDateFormat(String format) {
         if (format != null) {
             this.recentDateFormat = new SimpleDateFormat(format);
             this.recentDateFormat.setLenient(false);
         }
     }

     /**
      * @return returns an array of 12 strings representing the short
      * month names used by this parse.
      */
     public String[] getShortMonths() {
         return defaultDateFormat.getDateFormatSymbols().getShortMonths();
     }


     /**
      * @return Returns the serverTimeZone used by this parser.
      */
     public TimeZone getServerTimeZone() {
         return this.defaultDateFormat.getTimeZone();
     }
     /**
      * sets a TimeZone represented by the supplied ID string into all
      * of the parsers used by this server.
      * @param serverTimeZone Time Id java.util.TimeZone id used by
      * the ftp server.  If null the client's local time zone is assumed.
      */
     private void setServerTimeZone(String serverTimeZoneId) {
         TimeZone serverTimeZone = TimeZone.getDefault();
         if (serverTimeZoneId != null) {
             serverTimeZone = TimeZone.getTimeZone(serverTimeZoneId);
         }
         this.defaultDateFormat.setTimeZone(serverTimeZone);
         if (this.recentDateFormat != null) {
             this.recentDateFormat.setTimeZone(serverTimeZone);
         }
     }

     /**
      * Implementation of the {@link  Configurable  Configurable}
      * interface. Configures this <code>FTPTimestampParser</code> according
      * to the following logic:
      * <p>
      * Set up the {@link  FTPClientConfig#setDefaultDateFormatStr(java.lang.String) defaultDateFormat}
      * and optionally the {@link  FTPClientConfig#setRecentDateFormatStr(String) recentDateFormat}
      * to values supplied in the config based on month names configured as follows:
      * </p><p><ul>
      * <li>If a {@link  FTPClientConfig#setShortMonthNames(String) shortMonthString}
      * has been supplied in the <code>config</code>, use that to parse  parse timestamps.</li>
      * <li>Otherwise, if a {@link  FTPClientConfig#setServerLanguageCode(String) serverLanguageCode}
      * has been supplied in the <code>config</code>, use the month names represented
      * by that {@link  FTPClientConfig#lookupDateFormatSymbols(String) language}
      * to parse timestamps.</li>
      * <li>otherwise use default English month names</li>
      * </ul></p><p>
      * Finally if a {@link  org.apache.commons.net.ftp.FTPClientConfig#setServerTimeZoneId(String) serverTimeZoneId}
      * has been supplied via the config, set that into all date formats that have
      * been configured.
      * </p>
      */
     public void configure(FTPClientConfig config) {
         DateFormatSymbols dfs = null;

         String languageCode = config.getServerLanguageCode();
         String shortmonths = config.getShortMonthNames();
         if (shortmonths != null) {
             dfs = FTPClientConfig.getDateFormatSymbols(shortmonths);
         } else if (languageCode != null) {
             dfs = FTPClientConfig.lookupDateFormatSymbols(languageCode);
         } else {
             dfs = FTPClientConfig.lookupDateFormatSymbols("en");
         }


         String recentFormatString = config.getRecentDateFormatStr();
         if (recentFormatString == null) {
             this.recentDateFormat = null;
         } else {
             this.recentDateFormat = new SimpleDateFormat(recentFormatString, dfs);
             this.recentDateFormat.setLenient(false);
         }

         String defaultFormatString = config.getDefaultDateFormatStr();
         if (defaultFormatString == null) {
             throw new IllegalArgumentException("defaultFormatString cannot be null");
         }
         this.defaultDateFormat = new SimpleDateFormat(defaultFormatString, dfs);
         this.defaultDateFormat.setLenient(false);

         setServerTimeZone(config.getServerTimeZoneId());

         this.lenientFutureDates = config.isLenientFutureDates();
     }
     /**
      * @return Returns the lenientFutureDates.
      */
     boolean isLenientFutureDates() {
         return lenientFutureDates;
     }
     /**
      * @param lenientFutureDates The lenientFutureDates to set.
      */
     void setLenientFutureDates(boolean lenientFutureDates) {
         this.lenientFutureDates = lenientFutureDates;
     }
 }
	/*
	* 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.
	*/

	package org.apache.commons.net.ftp.parser;

	import java.text.DateFormatSymbols;
	import java.text.ParseException;
	import java.text.ParsePosition;
	import java.text.SimpleDateFormat;
	import java.util.Calendar;
	import java.util.Date;
	import java.util.TimeZone;

	import org.apache.commons.net.ftp.Configurable;
	import org.apache.commons.net.ftp.FTPClientConfig;

	/**
	* Default implementation of the {@link FTPTimestampParser FTPTimestampParser}
	* interface also implements the {@link org.apache.commons.net.ftp.Configurable Configurable}
	* interface to allow the parsing to be configured from the outside.
	*
	* @see ConfigurableFTPFileEntryParserImpl
	* @since 1.4
	*/
	public class FTPTimestampParserImpl implements
	FTPTimestampParser, Configurable
	{


	private SimpleDateFormat defaultDateFormat;
	private SimpleDateFormat recentDateFormat;
	private boolean lenientFutureDates = false;


	/**
	* The only constructor for this class.
	*/
	public FTPTimestampParserImpl() {
	setDefaultDateFormat(DEFAULT_SDF);
	setRecentDateFormat(DEFAULT_RECENT_SDF);
	}

	/**
	* Implements the one {@link FTPTimestampParser#parseTimestamp(String) method}
	* in the {@link FTPTimestampParser FTPTimestampParser} interface
	* according to this algorithm:
	*
	* If the recentDateFormat member has been defined, try to parse the
	* supplied string with that. If that parse fails, or if the recentDateFormat
	* member has not been defined, attempt to parse with the defaultDateFormat
	* member. If that fails, throw a ParseException.
	*
	* This method allows a {@link Calendar} instance to be passed in which represents the
	* current (system) time.
	*
	* @see org.apache.commons.net.ftp.parser.FTPTimestampParser#parseTimestamp(java.lang.String)
	*
	* @param timestampStr The timestamp to be parsed
	*/
	public Calendar parseTimestamp(String timestampStr) throws ParseException {
	Calendar now = Calendar.getInstance();
	return parseTimestamp(timestampStr, now);
	}

	/**
	* Implements the one {@link FTPTimestampParser#parseTimestamp(String) method}
	* in the {@link FTPTimestampParser FTPTimestampParser} interface
	* according to this algorithm:
	*
	* If the recentDateFormat member has been defined, try to parse the
	* supplied string with that. If that parse fails, or if the recentDateFormat
	* member has not been defined, attempt to parse with the defaultDateFormat
	* member. If that fails, throw a ParseException.
	*
	* @see org.apache.commons.net.ftp.parser.FTPTimestampParser#parseTimestamp(java.lang.String)
	* @param timestampStr The timestamp to be parsed
	* @param serverTime The current time for the server
	* @since 1.5
	*/
	public Calendar parseTimestamp(String timestampStr, Calendar serverTime) throws ParseException {
	Calendar now = (Calendar) serverTime.clone();// Copy this, because we may change it
	now.setTimeZone(this.getServerTimeZone());
	Calendar working = (Calendar) now.clone();
	working.setTimeZone(getServerTimeZone());
	ParsePosition pp = new ParsePosition(0);

	Date parsed = null;
	if (recentDateFormat != null) {
	if (lenientFutureDates) {
	// add a day to "now" so that "slop" doesn't cause a date
	// slightly in the future to roll back a full year. (Bug 35181)
	now.add(Calendar.DATE, 1);
	}
	parsed = recentDateFormat.parse(timestampStr, pp);
	}
	if (parsed != null && pp.getIndex() == timestampStr.length())
	{
	working.setTime(parsed);
	working.set(Calendar.YEAR, now.get(Calendar.YEAR));

	if (working.after(now)) {
	working.add(Calendar.YEAR, -1);
	}
	} else {
	// Temporarily add the current year to the short date time
	// to cope with short-date leap year strings.
	// e.g. Java's DateFormatter will assume that "Feb 29 12:00" refers to
	// Feb 29 1970 (an invalid date) rather than a potentially valid leap year date.
	// This is pretty bad hack to work around the deficiencies of the JDK date/time classes.
	if (recentDateFormat != null) {
	pp = new ParsePosition(0);
	int year = now.get(Calendar.YEAR);
	String timeStampStrPlusYear = timestampStr + " " + year;
	SimpleDateFormat hackFormatter = new SimpleDateFormat(recentDateFormat.toPattern() + " yyyy",
	recentDateFormat.getDateFormatSymbols());
	hackFormatter.setLenient(false);
	hackFormatter.setTimeZone(recentDateFormat.getTimeZone());
	parsed = hackFormatter.parse(timeStampStrPlusYear, pp);
	}
	if (parsed != null && pp.getIndex() == timestampStr.length() + 5) {
	working.setTime(parsed);
	}
	else {
	pp = new ParsePosition(0);
	parsed = defaultDateFormat.parse(timestampStr, pp);
	// note, length checks are mandatory for us since
	// SimpleDateFormat methods will succeed if less than
	// full string is matched. They will also accept,
	// despite "leniency" setting, a two-digit number as
	// a valid year (e.g. 22:04 will parse as 22 A.D.)
	// so could mistakenly confuse an hour with a year,
	// if we don't insist on full length parsing.
	if (parsed != null && pp.getIndex() == timestampStr.length()) {
	working.setTime(parsed);
	} else {
	throw new ParseException(
	"Timestamp could not be parsed with older or recent DateFormat",
	pp.getIndex());
	}
	}
	}
	return working;
	}

	/**
	* @return Returns the defaultDateFormat.
	*/
	public SimpleDateFormat getDefaultDateFormat() {
	return defaultDateFormat;
	}
	/**
	* @return Returns the defaultDateFormat pattern string.
	*/
	public String getDefaultDateFormatString() {
	return defaultDateFormat.toPattern();
	}
	/**
	* @param defaultDateFormat The defaultDateFormat to be set.
	*/
	private void setDefaultDateFormat(String format) {
	if (format != null) {
	this.defaultDateFormat = new SimpleDateFormat(format);
	this.defaultDateFormat.setLenient(false);
	}
	}
	/**
	* @return Returns the recentDateFormat.
	*/
	public SimpleDateFormat getRecentDateFormat() {
	return recentDateFormat;
	}
	/**
	* @return Returns the recentDateFormat.
	*/
	public String getRecentDateFormatString() {
	return recentDateFormat.toPattern();
	}
	/**
	* @param recentDateFormat The recentDateFormat to set.
	*/
	private void setRecentDateFormat(String format) {
	if (format != null) {
	this.recentDateFormat = new SimpleDateFormat(format);
	this.recentDateFormat.setLenient(false);
	}
	}

	/**
	* @return returns an array of 12 strings representing the short
	* month names used by this parse.
	*/
	public String[] getShortMonths() {
	return defaultDateFormat.getDateFormatSymbols().getShortMonths();
	}


	/**
	* @return Returns the serverTimeZone used by this parser.
	*/
	public TimeZone getServerTimeZone() {
	return this.defaultDateFormat.getTimeZone();
	}
	/**
	* sets a TimeZone represented by the supplied ID string into all
	* of the parsers used by this server.
	* @param serverTimeZone Time Id java.util.TimeZone id used by
	* the ftp server. If null the client's local time zone is assumed.
	*/
	private void setServerTimeZone(String serverTimeZoneId) {
	TimeZone serverTimeZone = TimeZone.getDefault();
	if (serverTimeZoneId != null) {
	serverTimeZone = TimeZone.getTimeZone(serverTimeZoneId);
	}
	this.defaultDateFormat.setTimeZone(serverTimeZone);
	if (this.recentDateFormat != null) {
	this.recentDateFormat.setTimeZone(serverTimeZone);
	}
	}

	/**
	* Implementation of the {@link Configurable Configurable}
	* interface. Configures this <code>FTPTimestampParser</code> according
	* to the following logic:
	* <p>
	* Set up the {@link FTPClientConfig#setDefaultDateFormatStr(java.lang.String) defaultDateFormat}
	* and optionally the {@link FTPClientConfig#setRecentDateFormatStr(String) recentDateFormat}
	* to values supplied in the config based on month names configured as follows:
	* </p><p><ul>
	* <li>If a {@link FTPClientConfig#setShortMonthNames(String) shortMonthString}
	* has been supplied in the <code>config</code>, use that to parse parse timestamps.</li>
	* <li>Otherwise, if a {@link FTPClientConfig#setServerLanguageCode(String) serverLanguageCode}
	* has been supplied in the <code>config</code>, use the month names represented
	* by that {@link FTPClientConfig#lookupDateFormatSymbols(String) language}
	* to parse timestamps.</li>
	* <li>otherwise use default English month names</li>
	* </ul></p><p>
	* Finally if a {@link org.apache.commons.net.ftp.FTPClientConfig#setServerTimeZoneId(String) serverTimeZoneId}
	* has been supplied via the config, set that into all date formats that have
	* been configured.
	* </p>
	*/
	public void configure(FTPClientConfig config) {
	DateFormatSymbols dfs = null;

	String languageCode = config.getServerLanguageCode();
	String shortmonths = config.getShortMonthNames();
	if (shortmonths != null) {
	dfs = FTPClientConfig.getDateFormatSymbols(shortmonths);
	} else if (languageCode != null) {
	dfs = FTPClientConfig.lookupDateFormatSymbols(languageCode);
	} else {
	dfs = FTPClientConfig.lookupDateFormatSymbols("en");
	}


	String recentFormatString = config.getRecentDateFormatStr();
	if (recentFormatString == null) {
	this.recentDateFormat = null;
	} else {
	this.recentDateFormat = new SimpleDateFormat(recentFormatString, dfs);
	this.recentDateFormat.setLenient(false);
	}

	String defaultFormatString = config.getDefaultDateFormatStr();
	if (defaultFormatString == null) {
	throw new IllegalArgumentException("defaultFormatString cannot be null");
	}
	this.defaultDateFormat = new SimpleDateFormat(defaultFormatString, dfs);
	this.defaultDateFormat.setLenient(false);

	setServerTimeZone(config.getServerTimeZoneId());

	this.lenientFutureDates = config.isLenientFutureDates();
	}
	/**
	* @return Returns the lenientFutureDates.
	*/
	boolean isLenientFutureDates() {
	return lenientFutureDates;
	}
	/**
	* @param lenientFutureDates The lenientFutureDates to set.
	*/
	void setLenientFutureDates(boolean lenientFutureDates) {
	this.lenientFutureDates = lenientFutureDates;
	}
	}