Category: Programming languages

All programming languages

Enable Browser Caching for Tomcat’s Deliveries

Post author By Ralph
Post date February 19, 2008
2 Comments on Enable Browser Caching for Tomcat’s Deliveries

Tomcat automatically adds “no-cache” directives to each response. This is not a good idea when you are not using Apache as the serving host for static content. I found a very easy way to get rid of that HTTP header. Just add a new file named “context.xml” to the WEB-INF directory of your application:

<context>
	<valve className="org.apache.catalina.authenticator.BasicAuthenticator"  
		disableProxyCaching="false" />
</context>

For finer control, please have a look at Symphonious’ article on that topic.

Tags caching, no-cache

Java

Handling Unix’ cron-like information in Java

Post author By Ralph
Post date February 1, 2008
1 Comment on Handling Unix’ cron-like information in Java

I recently had the requirement to write scheduled tasks within Java. I decided to use cron-like syntax in order to define when a task should run. A special class was created handling the scheduling information. Here it is:

package mypackage;
 
import java.util.Calendar;
import java.util.GregorianCalendar;
 
/**
 * Provides cron-like scheduling information.
 * This class implements cron-like definition of scheduling information.
 * Various methods can be used to check whether a timestamp matches the
 * schedule or not. However, there is a slight difference between cron and
 * this class. Cron describes a match when either the day of month and month
 * or the day of week are met. This class requires both to be met for a match.
 * Also note that Calendar defines Sunday through Saturday with 1 through 7 respectively
 * @author RalphSchuster
 *
 */
public class CronSchedule {
 
	/**
	 * Types being used.
	 * This array defines the types and their indices.
	 */
	protected static int TYPES[] = new int[] {
		Calendar.MINUTE, Calendar.HOUR_OF_DAY, 
		Calendar.DAY_OF_MONTH, Calendar.MONTH, 
		Calendar.DAY_OF_WEEK
	};
 
	private AbstractTimeValue timeValues[][] = new AbstractTimeValue[TYPES.length][];
 
	/**
	 * Default constructor
	 * Constructor with all terms set to "*".
	 */
	public CronSchedule() {
		this("*", "*", "*", "*", "*");
	}
 
	/**
	 * Constructor with cron-style string initialization.
	 * The cron style is: $minute $hour $dayOfMonth $month $dayOfWeek
	 * @param schedule
	 */
	public CronSchedule(String schedule) {
		set(schedule);
	}
 
	/**
	 * Constructor with separate initialization values.
	 * @param min - minute definition
	 * @param hour - hour definition
	 * @param dom - day of month definition
	 * @param mon - month definition
	 * @param dow - day of week definition
	 */
	public CronSchedule(String min, String hour, String dom, String mon, String dow) {
		set(Calendar.MINUTE, min);
		set(Calendar.HOUR_OF_DAY, hour);
		set(Calendar.DAY_OF_MONTH, dom);
		set(Calendar.MONTH, mon);
		set(Calendar.DAY_OF_WEEK, dow);
	}
 
	/**
	 * Sets the cron schedule.
	 * The cron style is: $minute $hour $dayOfMonth $month $dayOfWeek
	 * The function will return any characters that follow the cron definition
	 * @param schedule - cron-like schedule definition
	 * @return characters following the cron definition.
	 */
	public String set(String schedule) {
		String parts[] = schedule.split(" ", TYPES.length+1);
		if (parts.length < TYPES.length) throw new IllegalArgumentException("Invalid cron format: "+schedule);
		for (int i=0; i<TYPES.length; i++) set(getType(i), parts[i]);
		return parts.length > TYPES.length ? parts[TYPES.length] : null;
	}
 
	/**
	 * Sets the time values accordingly
	 * @param type - Calendar constant to define what values will be set
	 * @param values - comma-separated list of definitions for that type
	 */
	public void set(int type, String values) {
		// Split the values
		String parts[] = values.split(",");
		AbstractTimeValue result[] = new AbstractTimeValue[parts.length];
 
		// Iterate over entries
		for (int i=0; i<parts .length; i++) {
			// Decide what time value is set and create it
			if (parts[i].indexOf("/") > 0) result[i] = new TimeSteps(parts[i]);
			else if (parts[i].indexOf("-") > 0) result[i] = new TimeRange(parts[i]);
			else if (parts[i].equals("*")) result[i] = new TimeAll();
			else result[i] = new SingleTimeValue(parts[i]);
		}
 
		// Save the array
		set(type, result);
	}
 
	/**
	 * Sets the values for a specific type
	 * @param type - Calendar constant defining the time type
	 * @param values - values to be set
	 */
	protected void set(int type, AbstractTimeValue values[]) {
		timeValues[getIndex(type)] = values;
	}
 
	/**
	 * Returns the values for a specific time type
	 * @param type - Calendar constant defining the type
	 * @return time value definitions
	 */
	protected AbstractTimeValue[] getValues(int type) {
		return timeValues[getIndex(type)];
	}
 
	/**
	 * Returns the cron-like definition string for the given time value
	 * @param type - Calendar constant defining time type
	 * @return cron-like definition
	 */
	public String get(int type) {
		AbstractTimeValue values[] = getValues(type);
		String rc = "";
		for (int i=0; i<values .length; i++) rc += ","+values[i].toString();
		return rc.substring(1);
	}
 
	/**
	 * Returns the cron-like definition of the schedule.
	 */
	public String toString() {
		String rc = "";
		for (int i=0; i<TYPES.length; i++) {
			rc += " "+get(getType(i));
		}
		return rc.trim();
	}
 
	/**
	 * Checks whether given timestamp matches with defined schedule.
	 * This is default check method. All criteria must be met including seconds to be 0.
	 * @param timeStamp - time in ms since Epoch time
	 * @return true when schedule matches
	 */
	public boolean matches(long timeStamp) {
		return matches(getCalendar(timeStamp));
	}
 
	/**
	 * Checks whether given timestamp matches with defined schedule.
	 * This is default check method. All criteria must be met including seconds to be 0.
	 * @param cal - calendar date
	 * @return true when schedule matches
	 */
	public boolean matches(Calendar cal) {
		return isMinute(cal) && (cal.get(Calendar.SECOND) == 0);
	}
 
	/**
	 * Checks whether given timestamp matches with defined schedule.
	 * This method can be used when seconds are not relevant for matching.
	 * This is default check method.
	 * @param timeStamp - time in ms since Epoch time
	 * @return true when schedule matches
	 */
	public boolean isMinute(long timeStamp) {
		return isMinute(getCalendar(timeStamp));
	}
 
	/**
	 * Checks whether given calendar date matches with defined schedule.
	 * This method can be used when seconds are not relevant for matching.
	 * @param cal - calendar date
	 * @return true when schedule matches
	 */
	public boolean isMinute(Calendar cal) {
		return matches(Calendar.MINUTE, cal) && isHour(cal);
	}
 
	/**
	 * Checks whether given timestamp matches with defined hour schedule.
	 * This method can be used when minute definition is not relevant for matching.
	 * @param timestamp - time in ms since Epoch time
	 * @return true when schedule matches
	 */
	public boolean isHour(long timeStamp) {
		return isHour(getCalendar(timeStamp));
	}
 
	/**
	 * Checks whether given calendar date matches with defined hour schedule.
	 * This method can be used when minute definition is not relevant for matching.
	 * @param cal - calendar date
	 * @return true when schedule matches
	 */
	public boolean isHour(Calendar cal) {
		return matches(Calendar.HOUR_OF_DAY, cal) && isDay(cal);
	}
 
	/**
	 * Checks whether given timestamp matches with defined day schedule.
	 * This method can be used when minute and hour definitions are not relevant for matching.
	 * @param timestamp - time in ms since Epoch time
	 * @return true when schedule matches
	 */
	public boolean isDay(long timeStamp) {
		return isDay(getCalendar(timeStamp));
	}
 
	/**
	 * Checks whether given calendar date matches with defined day schedule.
	 * This method can be used when minute and hour definitions are not relevant for matching.
	 * @param cal - calendar date
	 * @return true when schedule matches
	 */
	public boolean isDay(Calendar cal) {
		return 
			matches(Calendar.DAY_OF_WEEK, cal) &&
			matches(Calendar.DAY_OF_MONTH, cal) &&
			matches(Calendar.MONTH, cal);
	}
 
	/**
	 * Checks whether specific schedule definition matches against the given calendar date.
	 * @param type - Calendar constant defining time type to check for
	 * @param calendar - calendar representing the date to check
	 * @return true when definition matches
	 */
	protected boolean matches(int type, Calendar calendar) {
		// get the definitions and the comparison value
		AbstractTimeValue defs[] = timeValues[getIndex(type)];
		int value = calendar.get(type);
 
		// Any of the criteria must be met
		for (int i=0; i<defs.length; i++) {
			if (defs[i].matches(value)) return true;
		}
		return false;
	}
 
	/**
	 * Creates the calendar for a timestamp.
	 * @param timeStamp - timestamp
	 * @return calendar
	 */
	protected Calendar getCalendar(long timeStamp) {
		Calendar rc = new GregorianCalendar();
		rc.setTimeInMillis(timeStamp);
		return rc;
	}
 
	/**
	 * Returns the type at the specified index
	 * @param index - index
	 * @return Calendar constant of type
	 */
	protected static int getType(int index) {
		return TYPES[index];
	}
 
	/**
	 * Returns the index for the specified Calendar type.
	 * @param type - Calendar constant for type
	 * @return internal index
	 */
	protected static int getIndex(int type) {
		for (int i=0; i<TYPES.length; i++) {
			if (TYPES[i] == type) return i;
		}
		throw new IllegalArgumentException("No such time type: "+type);
	}
 
	/**
	 * Base class for timing values.
	 * @author RalphSchuster
	 */
	public static abstract class AbstractTimeValue {
 
		/**
		 * Returns true when given time value matches defined time.
		 * @param timeValue - time value to evaluate
		 * @return true when time matches
		 */
		public abstract boolean matches(int timeValue);
	}
 
	/**
	 * Represents a single time value, e.g. 9
	 * @author RalphSchuster
	 */
	public static class SingleTimeValue extends AbstractTimeValue {
 
		private int value;
 
		public SingleTimeValue(int value) {
			setValue(value);
		}
 
		public SingleTimeValue(String value) {
			setValue(Integer.parseInt(value));
		}
 
		/**
		 * @return the value
		 */
		public int getValue() {
			return value;
		}
 
		/**
		 * @param value the value to set
		 */
		public void setValue(int value) {
			this.value = value;
		}
 
		/**
		 * Returns true when given time value matches defined value.
		 * @param timeValue - time value to evaluate
		 * @return true when time matches
		 */
		public boolean matches(int timeValue) {
			return timeValue == getValue();
		}
 
		/**
		 * Returns cron-like string of this definition.
		 */
		public String toString() {
			return ""+getValue();
		}
	}
 
	/**
	 * Represents a time range, e.g. 5-9
	 * @author RalphSchuster
	 */
	public static class TimeRange extends AbstractTimeValue {
 
		private int startValue;
		private int endValue;
 
		public TimeRange(int startValue, int endValue) {
			setStartValue(startValue);
			setEndValue(endValue);
		}
 
		public TimeRange(String range) {
			int dashPos = range.indexOf("-");
			setStartValue(Integer.parseInt(range.substring(0, dashPos)));
			setEndValue(Integer.parseInt(range.substring(dashPos+1)));
		}
 
		/**
		 * @return the endValue
		 */
		public int getEndValue() {
			return endValue;
		}
 
		/**
		 * @param endValue the endValue to set
		 */
		public void setEndValue(int endValue) {
			this.endValue = endValue;
		}
 
		/**
		 * @return the startValue
		 */
		public int getStartValue() {
			return startValue;
		}
 
		/**
		 * @param startValue the startValue to set
		 */
		public void setStartValue(int startValue) {
			this.startValue = startValue;
		}
 
		/**
		 * Returns true when given time value falls in range.
		 * @param timeValue - time value to evaluate
		 * @return true when time falls in range
		 */
		public boolean matches(int timeValue) {
			return (getStartValue() <= timeValue) && (timeValue <= getEndValue());
		}
 
		/**
		 * Returns cron-like string of this definition.
		 */
		public String toString() {
			return getStartValue()+"-"+getEndValue();
		}
	}
 
	/**
	 * Represents a time interval, e.g. 0-4/10
	 * @author RalphSchuster
	 */
	public static class TimeSteps extends AbstractTimeValue {
 
		private AbstractTimeValue range;
		private int steps;
 
		public TimeSteps(AbstractTimeValue range, int steps) {
			setRange(range);
			setSteps(steps);
		}
 
		public TimeSteps(String def) {
			int divPos = def.indexOf("/");
			String r = def.substring(0, divPos);
			if (r.equals("*")) setRange(new TimeAll());
			else if (r.indexOf("-") > 0) setRange(new TimeRange(r));
			else throw new IllegalArgumentException("Invalid range: "+def);
			setSteps(Integer.parseInt(def.substring(divPos+1)));
		}
 
		/**
		 * Returns true when given time value matches the interval.
		 * @param timeValue - time value to evaluate
		 * @return true when time matches the interval
		 */
		public boolean matches(int timeValue) {
			boolean rc = getRange().matches(timeValue);
			if (rc) rc = timeValue % getSteps() == 0;
			return rc;
		}
 
		/**
		 * @return the range
		 */
		public AbstractTimeValue getRange() {
			return range;
		}
 
		/**
		 * @param range the range to set
		 */
		public void setRange(AbstractTimeValue range) {
			this.range = range;
		}
 
		/**
		 * @return the steps
		 */
		public int getSteps() {
			return steps;
		}
 
		/**
		 * @param steps the steps to set
		 */
		public void setSteps(int steps) {
			this.steps = steps;
		}
 
		/**
		 * Returns cron-like string of this definition.
		 */
		public String toString() {
			return getRange()+"/"+getSteps();
		}
 
	}
 
	/**
	 * Represents the ALL time, *.
	 * @author RalphSchuster
	 */
	public static class TimeAll extends AbstractTimeValue {
 
		public TimeAll() {
 
		}
 
		/**
		 * Returns always true.
		 * @param timeValue - time value to evaluate
		 * @return true 
		 */
		public boolean matches(int timeValue) {
			return true;
		}
 
		/**
		 * Returns cron-like string of this definition.
		 */
		public String toString() {
			return "*";
		}
	}
}

package mypackage; import java.util.Calendar; import java.util.GregorianCalendar; /** * Provides cron-like scheduling information. * This class implements cron-like definition of scheduling information. * Various methods can be used to check whether a timestamp matches the * schedule or not. However, there is a slight difference between cron and * this class. Cron describes a match when either the day of month and month * or the day of week are met. This class requires both to be met for a match. * Also note that Calendar defines Sunday through Saturday with 1 through 7 respectively * @author RalphSchuster * */ public class CronSchedule { /** * Types being used. * This array defines the types and their indices. */ protected static int TYPES[] = new int[] { Calendar.MINUTE, Calendar.HOUR_OF_DAY, Calendar.DAY_OF_MONTH, Calendar.MONTH, Calendar.DAY_OF_WEEK }; private AbstractTimeValue timeValues[][] = new AbstractTimeValue[TYPES.length][]; /** * Default constructor * Constructor with all terms set to "*". */ public CronSchedule() { this("*", "*", "*", "*", "*"); } /** * Constructor with cron-style string initialization. * The cron style is: $minute $hour $dayOfMonth $month $dayOfWeek * @param schedule */ public CronSchedule(String schedule) { set(schedule); } /** * Constructor with separate initialization values. * @param min - minute definition * @param hour - hour definition * @param dom - day of month definition * @param mon - month definition * @param dow - day of week definition */ public CronSchedule(String min, String hour, String dom, String mon, String dow) { set(Calendar.MINUTE, min); set(Calendar.HOUR_OF_DAY, hour); set(Calendar.DAY_OF_MONTH, dom); set(Calendar.MONTH, mon); set(Calendar.DAY_OF_WEEK, dow); } /** * Sets the cron schedule. * The cron style is: $minute $hour $dayOfMonth $month $dayOfWeek * The function will return any characters that follow the cron definition * @param schedule - cron-like schedule definition * @return characters following the cron definition. */ public String set(String schedule) { String parts[] = schedule.split(" ", TYPES.length+1); if (parts.length < TYPES.length) throw new IllegalArgumentException("Invalid cron format: "+schedule); for (int i=0; i<TYPES.length; i++) set(getType(i), parts[i]); return parts.length > TYPES.length ? parts[TYPES.length] : null; } /** * Sets the time values accordingly * @param type - Calendar constant to define what values will be set * @param values - comma-separated list of definitions for that type */ public void set(int type, String values) { // Split the values String parts[] = values.split(","); AbstractTimeValue result[] = new AbstractTimeValue[parts.length]; // Iterate over entries for (int i=0; i<parts .length; i++) { // Decide what time value is set and create it if (parts[i].indexOf("/") > 0) result[i] = new TimeSteps(parts[i]); else if (parts[i].indexOf("-") > 0) result[i] = new TimeRange(parts[i]); else if (parts[i].equals("*")) result[i] = new TimeAll(); else result[i] = new SingleTimeValue(parts[i]); } // Save the array set(type, result); } /** * Sets the values for a specific type * @param type - Calendar constant defining the time type * @param values - values to be set */ protected void set(int type, AbstractTimeValue values[]) { timeValues[getIndex(type)] = values; } /** * Returns the values for a specific time type * @param type - Calendar constant defining the type * @return time value definitions */ protected AbstractTimeValue[] getValues(int type) { return timeValues[getIndex(type)]; } /** * Returns the cron-like definition string for the given time value * @param type - Calendar constant defining time type * @return cron-like definition */ public String get(int type) { AbstractTimeValue values[] = getValues(type); String rc = ""; for (int i=0; i<values .length; i++) rc += ","+values[i].toString(); return rc.substring(1); } /** * Returns the cron-like definition of the schedule. */ public String toString() { String rc = ""; for (int i=0; i<TYPES.length; i++) { rc += " "+get(getType(i)); } return rc.trim(); } /** * Checks whether given timestamp matches with defined schedule. * This is default check method. All criteria must be met including seconds to be 0. * @param timeStamp - time in ms since Epoch time * @return true when schedule matches */ public boolean matches(long timeStamp) { return matches(getCalendar(timeStamp)); } /** * Checks whether given timestamp matches with defined schedule. * This is default check method. All criteria must be met including seconds to be 0. * @param cal - calendar date * @return true when schedule matches */ public boolean matches(Calendar cal) { return isMinute(cal) && (cal.get(Calendar.SECOND) == 0); } /** * Checks whether given timestamp matches with defined schedule. * This method can be used when seconds are not relevant for matching. * This is default check method. * @param timeStamp - time in ms since Epoch time * @return true when schedule matches */ public boolean isMinute(long timeStamp) { return isMinute(getCalendar(timeStamp)); } /** * Checks whether given calendar date matches with defined schedule. * This method can be used when seconds are not relevant for matching. * @param cal - calendar date * @return true when schedule matches */ public boolean isMinute(Calendar cal) { return matches(Calendar.MINUTE, cal) && isHour(cal); } /** * Checks whether given timestamp matches with defined hour schedule. * This method can be used when minute definition is not relevant for matching. * @param timestamp - time in ms since Epoch time * @return true when schedule matches */ public boolean isHour(long timeStamp) { return isHour(getCalendar(timeStamp)); } /** * Checks whether given calendar date matches with defined hour schedule. * This method can be used when minute definition is not relevant for matching. * @param cal - calendar date * @return true when schedule matches */ public boolean isHour(Calendar cal) { return matches(Calendar.HOUR_OF_DAY, cal) && isDay(cal); } /** * Checks whether given timestamp matches with defined day schedule. * This method can be used when minute and hour definitions are not relevant for matching. * @param timestamp - time in ms since Epoch time * @return true when schedule matches */ public boolean isDay(long timeStamp) { return isDay(getCalendar(timeStamp)); } /** * Checks whether given calendar date matches with defined day schedule. * This method can be used when minute and hour definitions are not relevant for matching. * @param cal - calendar date * @return true when schedule matches */ public boolean isDay(Calendar cal) { return matches(Calendar.DAY_OF_WEEK, cal) && matches(Calendar.DAY_OF_MONTH, cal) && matches(Calendar.MONTH, cal); } /** * Checks whether specific schedule definition matches against the given calendar date. * @param type - Calendar constant defining time type to check for * @param calendar - calendar representing the date to check * @return true when definition matches */ protected boolean matches(int type, Calendar calendar) { // get the definitions and the comparison value AbstractTimeValue defs[] = timeValues[getIndex(type)]; int value = calendar.get(type); // Any of the criteria must be met for (int i=0; i<defs.length; i++) { if (defs[i].matches(value)) return true; } return false; } /** * Creates the calendar for a timestamp. * @param timeStamp - timestamp * @return calendar */ protected Calendar getCalendar(long timeStamp) { Calendar rc = new GregorianCalendar(); rc.setTimeInMillis(timeStamp); return rc; } /** * Returns the type at the specified index * @param index - index * @return Calendar constant of type */ protected static int getType(int index) { return TYPES[index]; } /** * Returns the index for the specified Calendar type. * @param type - Calendar constant for type * @return internal index */ protected static int getIndex(int type) { for (int i=0; i<TYPES.length; i++) { if (TYPES[i] == type) return i; } throw new IllegalArgumentException("No such time type: "+type); } /** * Base class for timing values. * @author RalphSchuster */ public static abstract class AbstractTimeValue { /** * Returns true when given time value matches defined time. * @param timeValue - time value to evaluate * @return true when time matches */ public abstract boolean matches(int timeValue); } /** * Represents a single time value, e.g. 9 * @author RalphSchuster */ public static class SingleTimeValue extends AbstractTimeValue { private int value; public SingleTimeValue(int value) { setValue(value); } public SingleTimeValue(String value) { setValue(Integer.parseInt(value)); } /** * @return the value */ public int getValue() { return value; } /** * @param value the value to set */ public void setValue(int value) { this.value = value; } /** * Returns true when given time value matches defined value. * @param timeValue - time value to evaluate * @return true when time matches */ public boolean matches(int timeValue) { return timeValue == getValue(); } /** * Returns cron-like string of this definition. */ public String toString() { return ""+getValue(); } } /** * Represents a time range, e.g. 5-9 * @author RalphSchuster */ public static class TimeRange extends AbstractTimeValue { private int startValue; private int endValue; public TimeRange(int startValue, int endValue) { setStartValue(startValue); setEndValue(endValue); } public TimeRange(String range) { int dashPos = range.indexOf("-"); setStartValue(Integer.parseInt(range.substring(0, dashPos))); setEndValue(Integer.parseInt(range.substring(dashPos+1))); } /** * @return the endValue */ public int getEndValue() { return endValue; } /** * @param endValue the endValue to set */ public void setEndValue(int endValue) { this.endValue = endValue; } /** * @return the startValue */ public int getStartValue() { return startValue; } /** * @param startValue the startValue to set */ public void setStartValue(int startValue) { this.startValue = startValue; } /** * Returns true when given time value falls in range. * @param timeValue - time value to evaluate * @return true when time falls in range */ public boolean matches(int timeValue) { return (getStartValue() <= timeValue) && (timeValue <= getEndValue()); } /** * Returns cron-like string of this definition. */ public String toString() { return getStartValue()+"-"+getEndValue(); } } /** * Represents a time interval, e.g. 0-4/10 * @author RalphSchuster */ public static class TimeSteps extends AbstractTimeValue { private AbstractTimeValue range; private int steps; public TimeSteps(AbstractTimeValue range, int steps) { setRange(range); setSteps(steps); } public TimeSteps(String def) { int divPos = def.indexOf("/"); String r = def.substring(0, divPos); if (r.equals("*")) setRange(new TimeAll()); else if (r.indexOf("-") > 0) setRange(new TimeRange(r)); else throw new IllegalArgumentException("Invalid range: "+def); setSteps(Integer.parseInt(def.substring(divPos+1))); } /** * Returns true when given time value matches the interval. * @param timeValue - time value to evaluate * @return true when time matches the interval */ public boolean matches(int timeValue) { boolean rc = getRange().matches(timeValue); if (rc) rc = timeValue % getSteps() == 0; return rc; } /** * @return the range */ public AbstractTimeValue getRange() { return range; } /** * @param range the range to set */ public void setRange(AbstractTimeValue range) { this.range = range; } /** * @return the steps */ public int getSteps() { return steps; } /** * @param steps the steps to set */ public void setSteps(int steps) { this.steps = steps; } /** * Returns cron-like string of this definition. */ public String toString() { return getRange()+"/"+getSteps(); } } /** * Represents the ALL time, *. * @author RalphSchuster */ public static class TimeAll extends AbstractTimeValue { public TimeAll() { } /** * Returns always true. * @param timeValue - time value to evaluate * @return true */ public boolean matches(int timeValue) { return true; } /** * Returns cron-like string of this definition. */ public String toString() { return "*"; } } }

Some explanations how you can use this class:

Create the schedule by just passing in the cron-like definition to the constructor method.
You can also create a schedule by using the default constructor and then setting the schedule with set(String). The advantage of this method is that it will return you any additional information that follows the schedule definition, e.g. as you can find it in /etc/crontab.
Beware that Java defines Sunday as 1, Saturday as 7. The real crontab ranges from 0-6 (7 as sunday, too)
matches(long) (line 149) is the default method to check whether a timestamp fulfills the requirements of the schedule definition. This method always checks whether the second of the timestamp is 0 (no millisecond check!).
isMinute(long), isHour(long), isDay(long) check the given timestamp only if the respective time requirement is met. That mean isMinute() will ignore seconds, isHour() will ignore minutes and seconds, isDay() will ignore time of the day.
Override getCalendar(long) (line 251) when you don’t wanna use the Gregorian Calendar or need a different timezone than your current default timezone.
You can easily add more time value checks (e.g. week of the year) by simply enhancing the TYPES array (line 23)

Tags cron, crontab, scheduling

Shell

Transforming string to uppercase in a shell

Post author By Ralph
Post date January 7, 2008
No Comments on Transforming string to uppercase in a shell

Simple and easy, use tr function:

$(echo $DATUM | tr '[a-z]' '[A-Z]')

Java

Hashing Passwords

Here is some code that you can use to hash passwords or other secrets in Java. I usually prefer to have such methods in a separate utility class:

protected static MessageDigest getDigest() throws NoSuchAlgorithmException {
	if (digest == null) {
		digest = MessageDigest.getInstance(&qout;MD5&qout;);
	}
	return digest;
}
 
public static byte[] digestString(String s) {
	if (s == null) return null;
	try {
		MessageDigest digest = getDigest();
		digest.update(s.getBytes());
		return digest.digest();
	} catch (Exception e) {
		log.error(&qout;Digesting problem:&qout;, e);
	}
	return null;
}
 
public static String encodePassword(String s) {
	byte b[] = digestString(s);
	if (b == null) return null;
	String rc = new String(Base64.encodeBase64(b));
	if (rc.length() &gt; 50) rc = rc.substring(0, 50);
	return rc;
}

Use the function encodePassword() to hash your string. Please note that the hash value is limited to a length of 50 characters.

Tags digest, hash, md5, password

Java

Configuring logging in a Java web application

Post author By Ralph Schuster
Post date December 4, 2007
No Comments on Configuring logging in a Java web application

Here is a short HOWTO for making some initial configuring when using Commons logging or log4j. Additionally this post will describe how to set the default locale in a servlet environment.

First you will need to create a new class derived from HttpServlet.

package mypackage;
 
import java.util.Locale;
 
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.apache.commons.logging.LogFactory;
import org.apache.log4j.PropertyConfigurator;
 
/**
 * Initializes log4j so it reads its configuration from WEB-INF directory and sets default locale.
 * @author Ralph Schuster
 *
 */
public class LogConfiguratorServlet extends HttpServlet {
 
   /**
    * Serial ID.
    */
   private static final long serialVersionUID = -5756062055681369027L;
 
   private static final String DEFAULT_FILE = "WEB-INF/log4j.properties";
 
   private static final String DEFAULT_LOCALE = "en_US"; // You can use "en", too.
 
   /**
    * Initializes log4j and sets default locale.
    */
   public void init() {
      // Do the log4j configuration
      String prefix =  getServletContext().getRealPath("/");
      String file = getInitParameter("config-file");
      // if the config-file is not set, then no point in trying
      String s = null;
      if (file != null) {
         s = prefix+file;
      } else {
         s = prefix+DEFAULT_FILE;
      }
      PropertyConfigurator.configure(s);
      LogFactory.getLog(getClass()).debug("log4j configuration file: "+s);
 
      // Do the locale configuration
      s = getInitParameter("locale");
      if (s == null) s = DEFAULT_LOCALE;
      Locale available[] = Locale.getAvailableLocales();
      for (int i=0; i&lt;available.length; i++) {
         if (available[i].toString().equals(s)) {
            Locale.setDefault(available[i]);
         }
      }
      LogFactory.getLog(getClass()).debug("Default locale set to: "+Locale.getDefault());
   }
 
   /**
    * Does nothing.
    */
   public void doGet(HttpServletRequest req, HttpServletResponse res) {
   }
 
}

You then need to deploy the class in your servlet container and adjust the web.xml file:

   &lt;servlet&gt;
      &lt;/servlet-name&gt;log4j-init&lt;/servlet-name&gt;
      &lt;servlet-class&gt;mypackage.LogConfiguratorServlet&lt;/servlet-class&gt;
 
      &lt;init-param&gt;
         &lt;param-name&gt;config-file&lt;/param-name&gt;
         &lt;param-value&gt;WEB-INF/log4j.properties&lt;/param-value&gt;
      &lt;/init-param&gt;
      &lt;init-param&gt;
         &lt;param-name&gt;locale&lt;/param-name&gt;
         &lt;param-value&gt;de_DE&lt;/param-value&gt;
      &lt;/init-param&gt;
 
      &lt;load-on-startup&gt;1&lt;/load-on-startup&gt;
   &lt;/servlet&gt;

Tags Commons Logging, JSP, Locale, Servlet

Perl

Scanning directories with Perl

Post author By Ralph Schuster
Post date November 27, 2007
No Comments on Scanning directories with Perl

I often come across a task to do specific processing for each file at a subdirectory tree. Here is a skeleton code for what you need to get it started.

#!/usr/bin/perl
 
my $ROOTDIR = shift;
processDir($ROOTDIR);
 
exit 0;
 
# This is the main routine. Do not change it unless you know what you do!
sub processDir {
   my $dir = shift;
   my (@FILES, $entry, $path);
 
   if (opendir(DIRIN, $dir)) {
      @FILES = readdir(DIRIN);
      closedir(DIRIN);
 
      # iterate over dir entries
      foreach $entry (@FILES) {
         next if $entry eq '..';
         next if $entry eq '.';
         $path = "$dir/$entry";
 
         if (-f $path) {
            if (fileCheck($path)) {
               processFile($path);
            }
         } elsif (-d $path) {
            if (dirCheck($path)) {
               # recurse into subdir
               processDir($path);
            }
         }
      }
   }
}
 
# Do your file processing in this function only
# $file will have the complete path
sub processFile {
   my $file = shift;
}
 
# This function decides whether a file should be processed or not
# Return 1 when you want a file to be processed
# $file will have the complete path
sub fileCheck {
   my $file = shift;
   return 1;
}
 
# This function decides whether a directory should be searched recursively.
# Return 1 when you want the algorithm to steep into the directory.
# $dir will have the complete path
sub dirCheck {
   my $dir = shift;
   return 1;
}

You only will need to override lines 39-41. In case you don’t want to handle all files and directories, just make appropriate implementations in functions checkFile() and checkDir() respectively. This code works on all platforms.

Tags directories, scanning

Java

SimpleCaptcha for Servers

Currently there is a bug in SimpleCaptcha library that prevents it running in non-graphics environments. It will throw a java.awt.HeadlessException. Although the code does not rely on various graphics classes, they were left causing this problem.

I fixed the code and recompiled it. You can download the fixed JAR file here. Do not forget to set the system property java.awt.headless to true, e.g. by specifying Djava.awt.headless=true at command line.

Tags Captcha, bugfix

Java Typo3

TYPO3-like templating with Java

Post author By Ralph Schuster
Post date November 20, 2007
1 Comment on TYPO3-like templating with Java

Here is a class I wrote to apply TYPO3-like templating mechanism within Java. I am quite familiar with that kind of templates, so I decided to use it within one of my projects, too. The implementation requires Java 5.

Java Templating class

You need to adopt the class’ package though 😉

Tags Templates

Perl

Perl Message Logging

The following code is a quick and dirty, but nevertheless usefull snippet to add logging facility to any perl script. You might want to add additional severities at lines 2-6, change the timestamp format at line 14, or enable logging into a file at lines 42-54.

# Defines severities of messages to log
my %TYPES = (
   ERROR => 1,
   DEBUG => 1,
   INFO  => 1
);
 
# Creates the time string for log messages
# Usage: getTimestring($unixTimeValue)
sub getTimestring {
   my $t = shift;
   $t = time if !$t;
   my @T = localtime($t);
   my $time = sprintf("%02d/%02d/%04d %02d:%02d:%02d",
              $T[3], $T[4]+1, $T[5]+1900, $T[2], $T[1], $T[0]);
   return $time;
}
 
# logs an error message
# Usage: logError($message);
sub logError {
   my $s = shift;
   logEntry($s, 'ERROR');
}
 
# logs an information message
# Usage: logInfo($message);
sub logInfo {
   my $s = shift;
   logEntry($s, 'INFO');
}
 
# logs a debug message
# Usage: logDebug($message);
sub logDebug {
   my $s = shift;
   logEntry($s, 'DEBUG');
}
 
# logs a single entry with given message severity
# Usage: logEntry($message, $severity);
sub logEntry {
   my $s = shift;
   my $type = shift;
   return if !$TYPES{$type};
 
   # build timestamp and string
   $type = rpad($type, 5);
   my $time = getTimestring();
   $s =~ s/\n/\n$time $type - /g;
 
   # print to STDOUT if required
   print "$time $type - $s\n";
}
 
# Right pads a string
# Usage: rpad($string, $maxlen[, $padchar]);
sub rpad {
   my $s = shift;
   my $len = shift;
   my $char = shift;
 
   $char = ' ' if !$char;
   $s .= $char while (length($s) &lt; $len);
   return $s;
}

Tags logging

Java PHP Perl

URL Parameter Transforming

Post author By Ralph Schuster
Post date November 16, 2007
No Comments on URL Parameter Transforming

Need to transform URL parameters and decode values such as “Hello%20World!”? Here is how:

Perl:

$s =~ s/%([\da-f][\da-f])/chr( hex($1) )/egi;

Java:

s = java.net.URLEncoder.encode(s, "UTF-8");

PHP:

$s = urldecode($s);

Tags Decoding, HTTP, Parameters, URL