Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that handles scheduling tasks 

 *  Copyright: 2009 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Michael Daigle

 * 

 *   '$Author: daigle $'

 *     '$Date: 2009-03-25 13:41:15 -0800 (Wed, 25 Mar 2009) $'

 * '$Revision: 4861 $'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.scheduler;

import java.text.DateFormat;

import java.text.ParseException;

import java.util.Arrays;

import java.util.Calendar;

import java.util.Date;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Vector;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

import org.quartz.Job;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.SchedulerException;

import org.quartz.SchedulerFactory;

import org.quartz.Trigger;

import org.quartz.TriggerUtils;

import edu.ucsb.nceas.metacat.service.BaseService;

import edu.ucsb.nceas.metacat.service.ServiceException;

import edu.ucsb.nceas.shared.AccessException;

public class SchedulerService extends BaseService {

	private static SchedulerService schedulerService = null;

	private static Logger logMetacat = Logger.getLogger(SchedulerService.class);

	private static Scheduler sched = null;

	static Hashtable<String, String> jobClassNames = new Hashtable<String, String>();

	static {

		jobClassNames.put("workflow", "edu.ucsb.nceas.metacat.workflow.WorkflowJob");

	}

	/**

	 * private constructor since this is a singleton

	 */

	private SchedulerService() throws ServiceException {}

	/**

	 * Get the single instance of SchedulerService.

	 * 

	 * @return the single instance of SchedulerService

	 */

	public static SchedulerService getInstance() throws ServiceException {

		if (schedulerService == null) {

			schedulerService = new SchedulerService();

		}

		return schedulerService;

	}

	public boolean refreshable() {

		return true;

	}

	protected void doRefresh() throws ServiceException {

		stop();

	}

	protected void start() throws ServiceException {

		try {

			SchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory();

			sched = schedFact.getScheduler();

			// read jobs from db here.

			// then add jobs to sched.

			sched.start();

		} catch (SchedulerException se) {

			throw new ServiceException("Could not start scheduler: " + se.getMessage());

		}		

	}

	protected void stop() throws ServiceException {

		try {

			sched.shutdown(true);

			sched = null;

		} catch (SchedulerException se) {

			throw new ServiceException("Could not shut down scheduler: " + se.getMessage());

		}		

	}

	protected Vector<String> getStatus() throws ServiceException {

		return new Vector<String>();

	}

	public String scheduleHandler(Hashtable<String, String[]> params,

            HttpServletRequest request, HttpServletResponse response,

            String username, String[] groups) throws ServiceException {

		String returnString = "";

        String[] categories = params.get("category");

        if (categories == null || categories.length == 0) {

        	throw new ServiceException("SchedulerService.scheduleHandler - Category field " 

        			+ "must be populated in scheduler parameters");

        }

        String category = categories[0];

        if (category.equals("schedule")) {

    		Calendar startCal = null;

            Hashtable<String, String> jobParams = new Hashtable<String, String>();

    		String jobTypes[] = params.get("type");

            if (jobTypes == null || jobTypes.length == 0) {

            	throw new ServiceException("SchedulerService.scheduleJob - Type field must be populated " 

            			+ "in scheduler parameters when scheduling job.");

            }

            String delays[] = params.get("delay");

    		String startTimes[] = params.get("starttime");       

            try {

    			if (delays != null && delays.length > 0) {

    				startCal = getStartDateFromDelay(delays[0]);

    			} else if (startTimes != null && startTimes.length > 0) {

    				Date startDate = DateFormat.getInstance().parse(startTimes[0]);

    				startCal = Calendar.getInstance();

    				startCal.setTime(startDate);

    			} else {

    				throw new ServiceException("SchedulerService.scheduleJob -  Either delay or starttime  " 

    						+ "field must be populated in scheduler parameters when scheduling job.");

    			}

    		} catch (ParseException pe) {

    			throw new ServiceException("SchedulerService.scheduleJob - Could not parse start time " 

    					+ startTimes[0] + " : " + pe.getMessage());

    		}

            String intervals[] = params.get("interval"); 

            if (intervals == null || intervals.length == 0) {

            	throw new ServiceException("SchedulerService.scheduleJob - Interval field must be populated " 

            			+ "in scheduler parameters when scheduling job.");

            } 

            String interval = intervals[0];

            Enumeration<String> paramNames = params.keys();

            while (paramNames.hasMoreElements()) {

            	String paramName = paramNames.nextElement();

            	if (paramName.startsWith("jobparam_")) {

            		jobParams.put(paramName.substring(8), params.get(paramName)[0]);

            	}

            }

            String jobType = jobTypes[0];

            String jobName = jobType + Calendar.getInstance().getTimeInMillis();

        	returnString = scheduleJob(jobName, startCal, interval, jobType, jobParams);

        } else if (category.equals("unschedule")) {

        	String jobNames[] = params.get("jobName");

        	if (jobNames == null || jobNames.length == 0) {

        		throw new ServiceException("SchedulerService.scheduleJob - Job ID field must be populated " 

            			+ "in scheduler parameters when unscheduling job.");

        	}

        	unscheduleJob(jobNames[0]);

        } else if (category.equals("delete")) {

//        	deleteJob(params);

        }

        return returnString;

	}

	public String scheduleJob(String jobName, Calendar startCal, String interval,

			String jobType, Hashtable<String, String> jobParams) throws ServiceException {

        Class<Job> jobClass = null;

        String className = jobClassNames.get(jobType);

        if (className == null) {

        	throw new ServiceException("SchedulerService.scheduleJob - Type: " + jobType 

        			+ " is not registered as a valid job type");

        }

        logMetacat.info("Scheduling job -- name: " + jobName + ", class: " + className 

        		+ ", start time: " + startCal.toString() + ", interval: " + interval);

        try {        	

        	jobClass = (Class<Job>)Class.forName(jobType + "Job");     	

        } catch (ClassNotFoundException cnfe) {

        	throw new ServiceException("SchedulerService.scheduleJob - Could not find class with name: " 

        			+ jobType + "Job");

        }    

		char intervalUnit = interval.trim().charAt(interval.length());

		String intervalStrValue = interval.trim().substring(0, interval.length() - 1);

		int intervalValue;

		try {

			intervalValue = Integer.parseInt(intervalStrValue);

		} catch (NumberFormatException nfe) {

			throw new ServiceException("SchedulerService.scheduleJob - Could not parse interval value " 

					+ "into an integer: " + intervalStrValue);

		}

		switch (intervalUnit) {

		case 's':

		case 'S':

			scheduleSecondlyJob(jobName, jobClass, startCal, intervalValue, jobType);

			break;

		case 'm':

		case 'M':

			scheduleMinutelyJob(jobName, jobClass, startCal, intervalValue, jobType);

			break;

		case 'h':

		case 'H':

			scheduleHourlyJob(jobName, jobClass, startCal, intervalValue, jobType);

			break;

		case 'd':

		case 'D':

			scheduleDailyJob(jobName, jobClass, startCal, intervalValue, jobType);

			break;

		default:

			throw new ServiceException("SchedulerService.scheduleJob - Could not interpret interval unit: " 

					+ intervalUnit + ". Unit must be s, m, h or d");	

		}	

		try {

			ScheduledJobAccess jobAccess = new ScheduledJobAccess();

			jobAccess.createJob(jobName, jobClass, startCal, intervalValue, jobParams);

		} catch (AccessException ae) {

			try {

				deleteJob(jobName);

			} catch (ServiceException se) {

				// Not much we can do here but log this

				logMetacat.error("An access exception was thrown when writing job: " + jobName 

						+ "to the db, and another exception was thrown when trying to remove the " 

						+ "job from the scheduler.  The db and scheduler may be out of sync");

			}

			throw new ServiceException("SchedulerService.scheduleJob - Error accessing db: " 

					+ ae.getMessage());

		}

		return jobName;

	}

	public void unscheduleJob(String jobName) throws ServiceException {

		try {

			ScheduledJobAccess jobAccess = new ScheduledJobAccess();

			ScheduledJobDAO jobDAO = jobAccess.getJobByName(jobName);

			sched.unscheduleJob(jobDAO.getName(), jobDAO.getGroupName());

			jobDAO.setStatus(ScheduledJobInterface.STATE_UNSHCEDULED);

			jobAccess.updateJobStatus(jobDAO);

		} catch (SchedulerException se) {

			throw new ServiceException("SchedulerService.unscheduleJob - Could not create "

							+ "scheduled job because of service issue: " + se.getMessage());

		} catch (AccessException ae) {

			throw new ServiceException("SchedulerService.unscheduleJob - Could not create "

							+ "scheduled job because of db access issue: " + ae.getMessage());

		}

	}

	public void deleteJob(String jobName) throws ServiceException {

		String groupName = "";

		try {

			ScheduledJobAccess jobAccess = new ScheduledJobAccess();

			ScheduledJobDAO jobDAO = jobAccess.getJobByName(jobName);

			groupName = jobDAO.getGroupName();

			sched.deleteJob(jobName, groupName);

		} catch (SchedulerException se) {

			throw new ServiceException("SchedulerService.deleteJob - Could not delete job: " 

					+ jobName + " for group: " + groupName + " : " + se.getMessage());

		} catch (AccessException ae) {

			throw new ServiceException("SchedulerService.deleteJob - Could not delete "

					+ "scheduled job because of db access issue: " + ae.getMessage());

}

	}

	public Vector<String> getJobInfo(String groupName) throws ServiceException {

		Vector<String> returnVector = new Vector<String>();

		try {

			if (groupName.equalsIgnoreCase("All")) {

				String[] groupNames = sched.getJobGroupNames();

				for (int i = 0; i < groupNames.length; i++) {

					returnVector.addAll(Arrays.asList(sched.getJobNames(groupNames[i])));

				}

			} else {

				returnVector.addAll(Arrays.asList(sched.getJobNames(groupName)));

			}

		} catch (SchedulerException se) {

			throw new ServiceException("SchedulerService.getJobNames - Could not get job names for group: " 

					+ groupName + " : " + se.getMessage());

		}

		return returnVector;

	}

	private void scheduleSecondlyJob(String name, Class<Job> jobClass, Calendar startTime, int interval, String jobGroup) throws ServiceException {

		JobDetail jobDetail = new JobDetail(name, jobGroup, jobClass);

		Trigger trigger = TriggerUtils.makeSecondlyTrigger(interval);

		trigger.setName(name);

		trigger.setStartTime(startTime.getTime());

		try {

			sched.scheduleJob(jobDetail, trigger);

		} catch (SchedulerException se) {

			throw new ServiceException("SchedulerService.scheduleSecondlyJob - Could not create " 

					+ "scheduler: " + se.getMessage());

		}

	}

	private void scheduleMinutelyJob(String name, Class<Job> jobClass, Calendar startTime, int interval, String jobGroup) throws ServiceException {

		JobDetail jobDetail = new JobDetail(name, jobGroup, jobClass);

		Trigger trigger = TriggerUtils.makeMinutelyTrigger(interval);

		trigger.setName(name);

		trigger.setStartTime(startTime.getTime());

		try {

			sched.scheduleJob(jobDetail, trigger);

		} catch (SchedulerException se) {

			throw new ServiceException("SchedulerService.scheduleMinutelyJob - Could not create " 

					+ "scheduler: " + se.getMessage());

		}

	}

	private void scheduleHourlyJob(String name, Class<Job> jobClass, Calendar startTime, int interval, String jobGroup) throws ServiceException {

		JobDetail jobDetail = new JobDetail(name, jobGroup, jobClass);

		Trigger trigger = TriggerUtils.makeHourlyTrigger(interval);

		trigger.setName(name);

		trigger.setStartTime(startTime.getTime());

		try {

			sched.scheduleJob(jobDetail, trigger);

		} catch (SchedulerException se) {

			throw new ServiceException("SchedulerService.scheduleHourlyJob - Could not create " 

					+  "scheduler: " + se.getMessage());

		}

	}

	private void scheduleDailyJob(String name, Class<Job> jobClass, Calendar startTime, int interval, String jobGroup) throws ServiceException {

		JobDetail jobDetail = new JobDetail(name, jobGroup, jobClass);

		Trigger trigger = TriggerUtils.makeHourlyTrigger(interval * 24);

		trigger.setName(name);

		trigger.setStartTime(startTime.getTime());

		try {

			sched.scheduleJob(jobDetail, trigger);

		} catch (SchedulerException se) {

			throw new ServiceException("SchedulerService.scheduleHourlyJob - Could not create " 

					+ "scheduler: " + se.getMessage());

		}

	}

	private Calendar getStartDateFromDelay(String delay) throws ServiceException {

		Calendar cal = Calendar.getInstance();

		char delayUnit = delay.trim().charAt(delay.length());

		String delayStrValue = delay.trim().substring(0, delay.length() - 1);

		int delayValue;

		try {

			delayValue = Integer.parseInt(delayStrValue);

		} catch (NumberFormatException nfe) {

			throw new ServiceException("SchedulerService.getStartDateFromDelay - Could not " 

					+ "parse delay value into an integer: " + delayStrValue);

		}

		switch (delayUnit) {

		case 's':

		case 'S':

			cal.add(Calendar.SECOND, delayValue);

			break;

		case 'm':

		case 'M':

			cal.add(Calendar.MINUTE, delayValue);

			break;

		case 'h':

		case 'H':

			cal.add(Calendar.HOUR, delayValue);

			break;

		case 'd':

		case 'D':

			cal.add(Calendar.DAY_OF_YEAR, delayValue);

			break;

		default:

			throw new ServiceException("SchedulerService.getStartDateFromDelay - Could not " 

					+ "interpret delay unit: " + delayUnit + ". Unit must be s, m, h or d");	

		}

		return cal;

	}

}