/src/edu/ucsb/nceas/metacat/scheduler/SchedulerService.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/src/edu/ucsb/nceas/metacat/scheduler/SchedulerService.java @ 5015

-            daigle
+/**
  *  '$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.util.Calendar;
-            daigle
+import java.util.HashMap;
-            daigle
+import java.util.Vector;
 import org.apache.log4j.Logger;
 import org.quartz.Job;
-            daigle
+import org.quartz.JobDataMap;
-            daigle
+import org.quartz.JobDetail;
 import org.quartz.Scheduler;
 import org.quartz.SchedulerException;
 import org.quartz.SchedulerFactory;
 import org.quartz.Trigger;
 import org.quartz.TriggerUtils;
-            daigle
+import edu.ucsb.nceas.metacat.shared.AccessException;
 import edu.ucsb.nceas.metacat.shared.BaseService;
 import edu.ucsb.nceas.metacat.shared.ServiceException;
-            daigle
+import edu.ucsb.nceas.utilities.DateUtil;
-            daigle
+import edu.ucsb.nceas.utilities.StatusUtil;
-            daigle
+import edu.ucsb.nceas.utilities.UtilException;
             daigle
 public class SchedulerService extends BaseService {
 	private static SchedulerService schedulerService = null;
 	private static Logger logMetacat = Logger.getLogger(SchedulerService.class);
 	private static Scheduler sched = null;
 	/**
 	 * private constructor since this is a singleton
 	 */
-            daigle
+	private SchedulerService() throws ServiceException {
 		start();
+	}
             daigle
 	/**
 	 * 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;
+	}
-            daigle
+	// this is a refreshable class
-            daigle
+	public boolean refreshable() {
 		return true;
+	}
             daigle
 	// do the refresh
-            daigle
+	public void doRefresh() throws ServiceException {
-            daigle
+		stop();
-            daigle
+		start();
             daigle
-            daigle
+	// initialize the service
-            daigle
+	public void start() throws ServiceException {
-            daigle
+		try {
-            daigle
+			// get the Quartz scheduler factory
-            daigle
+			SchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory();
-            daigle
+			// get the scheduler
-            daigle
+			sched = schedFact.getScheduler();
 			sched.start();
             daigle
-            daigle
+			// get all existing jobs from the database
-            daigle
+			ScheduledJobAccess jobAccess = new ScheduledJobAccess();
 			HashMap<Long, ScheduledJobDAO> allJobsMap = jobAccess.getAllJobs(null);
-            daigle
+			// reschedule each job that is in a SCHEDULED state.
-            daigle
+			for (Long jobId : allJobsMap.keySet()) {
 				ScheduledJobDAO jobDAO = allJobsMap.get(jobId);
 				String[] groups = {"scheduler_group"};
 				if (jobDAO.getStatus().equals(StatusUtil.SCHEDULED)) {
-            daigle
+					// send false as the last param so the reschedule method will not
 					// complain that the job is already in a SCHEDULED state.
-            daigle
+					rescheduleJob(jobDAO, "scheduler_user", groups, false);
+				}
+			}
 		} catch (AccessException ae) {
-            daigle
+			throw new ServiceException("SchedulerService.start - DB Access issue when starting scheduler: ", ae);
-            daigle
+		} catch (SchedulerException se) {
-            daigle
+			throw new ServiceException("SchedulerService.start - Scheduler engine issue when starting scheduler: " + se.getMessage());
             daigle
+	}
-            daigle
+	// Stop the scheduler
-            daigle
+	public void stop() throws ServiceException {
-            daigle
+		try {
 			sched.shutdown(true);
 			sched = null;
 		} catch (SchedulerException se) {
-            daigle
+			throw new ServiceException("SchedulerService.stop - Could not shut down scheduler: " + se.getMessage());
             daigle
+	}
-            daigle
+	// this will eventually return the scheduler status
-            daigle
+	protected Vector<String> getStatus() throws ServiceException {
 		return new Vector<String>();
+	}
-            daigle
+	/**
 	 * Schedule a job
+	 *
 	 * @param jobDAO
 	 *            the job data object to schedule
 	 * @param username
 	 *            the user that we will use to schedule
 	 * @param groups
 	 *            the user group that we will use to schedule
 	 * @return a message saying that the job was scheduled
 	 */
-            daigle
+	public String scheduleJob(ScheduledJobDAO jobDAO, String username, String[] groups) throws ServiceException {
             daigle
-            daigle
+		// convert the start time to a calendar object
-            daigle
+		Calendar startTimeCal = Calendar.getInstance();
         startTimeCal.setTime(jobDAO.getStartTime());
-            daigle
+		// convert the start time to a calendar object
 		Calendar endTimeCal = Calendar.getInstance();
         endTimeCal.setTime(jobDAO.getEndTime());
-            daigle
+        // extract the job parameters from their data objects and put into a string map
-            daigle
+        HashMap<String, String> jobParams = new HashMap<String, String>();
         HashMap<String, ScheduledJobParamDAO> jobParamDAOs = jobDAO.getAllJobParams();
         for (String paramName : jobParamDAOs.keySet()) {
         	jobParams.put(paramName, jobParamDAOs.get(paramName).getValue());
+        }
-            daigle
+        // schedule the job
-            daigle
+		return scheduleJob(jobDAO.getName(), startTimeCal, endTimeCal, jobDAO.getIntervalValue(),
 				jobDAO.getIntervalUnit(), jobDAO.getClassName(), jobDAO.getGroupName(),
 				jobParams, username, groups);
             daigle
-            daigle
+	/**
 	 * schedule a job
+	 *
 	 * @param jobName
 	 *            the name of the job
 	 * @param startCal
 	 *            a calendar holding the start date of the job
 	 * @param intervalValue
 	 *            the run interval for the job
 	 * @param intervalUnit
 	 *            the unit of the run interval for the job
 	 * @param jobClassName
 	 *            the job class name
 	 * @param jobGroup
 	 *            the job group name
 	 * @param jobParams
 	 *            a map of additional job parameters
 	 * @param username
 	 *            the user name
 	 * @param groups
 	 *            the user's group name
 	 * @return a message saying that the job was scheduled
 	 */
-            daigle
+	public String scheduleJob(String jobName, Calendar startCal, Calendar endCal, int intervalValue,
 			String intervalUnit, String jobClassName, String jobGroup, HashMap<String, String> jobParams,
-            daigle
+			String username, String[] groups) throws ServiceException {
-            daigle
+        Class<Job> jobClass = null;
-            daigle
+        try {
 			jobClass = (Class<Job>) Class.forName(jobClassName);
-            daigle
+			String startTimeStr = DateUtil.getHumanReadable(startCal);
-            daigle
+			logMetacat.info("SchedulerService.scheduleJob - Scheduling job -- name: "
 					+ jobName + ", class: " + jobClassName + ", start time: "
 					+ startTimeStr + ", interval value: " + intervalValue
 					+ ", interval unit: " + intervalUnit);
 			// start the job in the job scheduler
-            daigle
+			startJob(jobName, startCal, endCal, intervalValue, intervalUnit, jobClass, jobGroup,
-            daigle
+					jobParams);
 			// get a database access object and create the job in the database
-            daigle
+			ScheduledJobAccess jobAccess = new ScheduledJobAccess();
-            daigle
+			jobAccess.createJob(jobName, jobName, jobGroup, jobClass, startCal, endCal,
-            daigle
+					intervalValue, intervalUnit, jobParams);
-            daigle
+		} catch (AccessException ae) {
 			try {
-            daigle
+				deleteJob(jobName, username, groups);
-            daigle
+			} catch (Exception e) {
-            daigle
+				// Not much we can do here but log this
-            daigle
+				logMetacat.error("SchedulerService.scheduleJob - An access exception was thrown when writing job: "
 						+ jobName + "to the db, and another exception was thrown when trying to remove the "
-            daigle
+						+ "job from the scheduler.  The db and scheduler may be out of sync: " + e.getMessage());
             daigle
-            daigle
+			throw new ServiceException("SchedulerService.scheduleJob - Error accessing db: ", ae);
-            daigle
+		} catch (ClassNotFoundException cnfe) {
 			throw new ServiceException("SchedulerService.scheduleJob - Could not find class with name: "
 							+ jobClassName + " : " + cnfe.getMessage());
 		} catch (UtilException ue) {
 			throw new ServiceException("SchedulerService.scheduleJob - Could not schedule "
 							+ "job due to a utility issue: " + ue.getMessage());
             daigle
-            daigle
+		return "Scheduled: " + jobName;
             daigle
-            daigle
+	/**
 	 * Unschedule a job. This removed it from the scheduler in memory and
 	 * changed it's status to unscheduled in the database.
+	 *
 	 * @param jobName
 	 *            the name of the job to unschedule
 	 * @param username
 	 *            the user name
 	 * @param groups
 	 *            the user's group name
 	 * @return a message saying the job was unscheduled
 	 */
-            daigle
+	public String unScheduleJob(String jobName, String username,
 			String[] groups) throws ServiceException {
             daigle
 		ScheduledJobDAO jobDAO = null;
-            daigle
+		try {
 			ScheduledJobAccess jobAccess = new ScheduledJobAccess();
-            daigle
+			jobDAO = jobAccess.getJobByName(jobName);
-            daigle
+			if (jobDAO == null) {
 				throw new ServiceException("SchedulerService.unscheduleJob - Could "
 						+ "not find job with name: " + jobName);
+			}
             daigle
-            daigle
+			// remove the job from the scheduler
-            daigle
+			sched.deleteJob(jobDAO.getName(), jobDAO.getGroupName());
             daigle
-            daigle
+			// change the status of the job to unscheduled in the database.
-            daigle
+			jobDAO.setStatus(StatusUtil.UNSCHEDULED);
-            daigle
+			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 "
-            daigle
+							+ "scheduled job : " + jobDAO.getName() + " because of db access issue: ", ae);
             daigle
             daigle
 		return "Unscheduled: " + jobName;
             daigle
-            daigle
+	/**
 	 * Reschedule a job. This call will always check to make sure the status is not SCHEDULED
 	 * @param jobDAO the job data object holding the information about the job to reschedule
 	 * @param username
 	 *            the user name
 	 * @param groups
 	 *            the user's group name
 	 * @return a message saying that the job was rescheduled
 	 */
-            daigle
+	public String rescheduleJob(ScheduledJobDAO jobDAO, String username, String[] groups) throws ServiceException {
 		return rescheduleJob(jobDAO, username, groups, true);
+	}
-            daigle
+	/**
 	 * Reschedule a job.
+	 *
 	 * @param jobDAO
 	 *            the job data object holding the information about the job to
 	 *            reschedule
 	 * @param username
 	 *            the user name
 	 * @param groups
 	 *            the user's group name
 	 * @param checkStatus
 	 *            if set to true, the method will check to make sure the status
 	 *            is UNSCHEDULED before restarting. Otherwise, the method will
 	 *            not check. This is so that we can restart a service at startup
 	 *            that was running when metacat was shut down.
 	 * @return a message saying that the job was rescheduled
 	 */
-            daigle
+	public String rescheduleJob(ScheduledJobDAO jobDAO, String username, String[] groups, boolean checkStatus) throws ServiceException {
 		try {
 			ScheduledJobAccess jobAccess = new ScheduledJobAccess();
 			if (jobDAO == null) {
 				throw new ServiceException("SchedulerService.reScheduleJob - Cannot reschedule nonexistant job.");
+			}
-            daigle
+			// if we are checking status, make sure the job is in an UNSCHEDULED state in the db
-            daigle
+			if (checkStatus && !jobDAO.getStatus().equals(StatusUtil.UNSCHEDULED)) {
 				throw new ServiceException("SchedulerService.reScheduleJob - Cannot reschedule a job with status: "
 						+ jobDAO.getStatus() + ". Status must be 'unscheduled'.");
+			}
 			Calendar startCal = Calendar.getInstance();
 	        startCal.setTime(jobDAO.getStartTime());
-            daigle
+			Calendar endCal = Calendar.getInstance();
 	        endCal.setTime(jobDAO.getEndTime());
-            daigle
+	        HashMap<String, String> jobParams = new HashMap<String, String>();
 	        HashMap<String, ScheduledJobParamDAO> jobParamDAOs = jobDAO.getAllJobParams();
 	        for (String paramName : jobParamDAOs.keySet()) {
 	        	jobParams.put(paramName, jobParamDAOs.get(paramName).getValue());
+	        }
 	        Class<Job> jobClass = null;
 	        String jobClassName = jobDAO.getClassName();
 	        try {
 	        	jobClass = (Class<Job>)Class.forName(jobClassName);
 	        } catch (ClassNotFoundException cnfe) {
 	        	throw new ServiceException("SchedulerService.scheduleJob - Could not find class with name: "
 	        			+ jobDAO.getClassName() + " : " + cnfe.getMessage());
+	        }
-            daigle
+	        String startTimeStr = DateUtil.getHumanReadable(startCal);
-            daigle
+	        logMetacat.info("SchedulerService.rescheduleJob - name: " + jobDAO.getName() + ", class: " + jobClassName
-            daigle
+	        		+ ", start time: " + startTimeStr + ", interval value: " + jobDAO.getIntervalValue()
-            daigle
+	        		+ ", interval unit: " + jobDAO.getIntervalUnit());
-            daigle
+	        // start the job in the scheduler
-            daigle
+			startJob(jobDAO.getName(), startCal, endCal, jobDAO.getIntervalValue(), jobDAO.getIntervalUnit(), jobClass, jobDAO.getGroupName(), jobParams);
             daigle
-            daigle
+			// update the status in the database
-            daigle
+			jobDAO.setStatus(StatusUtil.SCHEDULED);
 			jobAccess.updateJobStatus(jobDAO);
 		} catch (AccessException ae) {
 			throw new ServiceException("SchedulerService.reScheduleJob - Could not reschedule "
-            daigle
+					+ "job : " + jobDAO.getName() + " because of db access issue: ", ae);
-            daigle
+		} catch (UtilException ue) {
 			throw new ServiceException("SchedulerService.reScheduleJob - Could not reschedule "
-            daigle
+					+ "job : " + jobDAO.getName() + " due to a utility issue: " + ue.getMessage());
             daigle
 		return "Resheduled: " + jobDAO.getName();
+	}
             daigle
 	/**
 	 * Remove the job from the scheduler and set the job status to deleted in the database
 	 * @param jobName
 	 *            the string holding the name of the job to delete
 	 * @param username
 	 *            the user name
 	 * @param groups
 	 *            the user's group name
 	 * @return a message saying that the job was deleted
 	 */
 	public String deleteJob(String jobName, String username,
 			String[] groups) throws ServiceException {
 		ScheduledJobDAO jobDAO = null;
 		try {
 			ScheduledJobAccess jobAccess = new ScheduledJobAccess();
 			jobDAO = jobAccess.getJobByName(jobName);
 		} catch (AccessException ae) {
 			throw new ServiceException("SchedulerService.deleteJob - Could not delete "
 					+ "scheduled job : " + jobDAO.getName() + " because of db access issue: ", ae);
+		}
 		return deleteJob(jobDAO, username, groups);
+	}
             daigle
-            daigle
+	/**
 	 * Remove the job from the scheduler and set the job status to deleted in the database
 	 * @param jobDAO
-            daigle
+	 *            the job data object holding the information about the job to delete
-            daigle
+	 * @param username
 	 *            the user name
 	 * @param groups
 	 *            the user's group name
 	 * @return a message saying that the job was deleted
 	 */
-            daigle
+	public String deleteJob(ScheduledJobDAO jobDAO, String username,
-            daigle
+			String[] groups) throws ServiceException {
-            daigle
+		String groupName = "";
 		try {
             daigle
-            daigle
+			sched.deleteJob(jobDAO.getName(), groupName);
             daigle
 			jobDAO.setStatus(StatusUtil.DELETED);
-            daigle
+			ScheduledJobAccess jobAccess = new ScheduledJobAccess();
-            daigle
+			jobAccess.updateJobStatus(jobDAO);
-            daigle
+		} catch (SchedulerException se) {
-            daigle
+			throw new ServiceException("SchedulerService.deleteJob - Could not delete job: " + jobDAO.getName()
-            daigle
+							+ " for group: " + groupName + " : " + se.getMessage());
-            daigle
+		} catch (AccessException ae) {
 			throw new ServiceException("SchedulerService.deleteJob - Could not delete "
-            daigle
+					+ "scheduled job: " + jobDAO.getName() + " because of db access issue: ", ae);
             daigle
             daigle
-            daigle
+		return "Deleted: " + jobDAO.getName();
             daigle
-            daigle
+	/**
 	 * Get information about the job in XML format
+	 *
 	 * @param jobId
 	 *            the job for which we want the information
 	 * @return an XML representation of the job
 	 */
-            daigle
+	public String getJobInfoXML(Long jobId) throws ServiceException {
 		String jobInfoXML = "";
 		try {
 			ScheduledJobAccess jobAccess = new ScheduledJobAccess();
 			ScheduledJobDAO scheduledJobDAO = jobAccess.getJob(jobId);
 			jobInfoXML +=
 				"<scheduledJobs>" + jobToXML(scheduledJobDAO) + "</scheduledJobs>";
 		} catch (AccessException ae) {
 			throw new ServiceException("SchedulerService.getJobInfoXML - Could not get job info for job: "
 					+ jobId, ae);
+		}
 		return jobInfoXML;
+	}
-            daigle
+	/**
 	 * Get the information for jobs in a group in an xml format. A parameter
 	 * key/value pair can be provided as well to limit the jobs returned.
+	 *
 	 * @param groupName
 	 *            the job group that we are searching for
 	 * @param paramName
 	 *            the parameter name that we are looking for. this is ignored if
 	 *            null
 	 * @param paramValue
 	 *            the parameter value that we are looking for. this is ignored
 	 *            if null
 	 * @return an XML representation of the jobs.
 	 */
-            daigle
+	public String getJobsInfoXML(String groupName, String paramName, String paramValue) throws ServiceException {
-            daigle
+		String jobInfoXML = "";
 		try {
 			ScheduledJobAccess jobAccess = new ScheduledJobAccess();
-            daigle
+			HashMap<Long, ScheduledJobDAO> JobDAOMap = jobAccess.getJobsWithParameter(groupName, paramName, paramValue);
             daigle
-            daigle
+			jobInfoXML += "<scheduledWorkflowResultset>";
-            daigle
+			for (Long jobDAOId : JobDAOMap.keySet()) {
-            daigle
+				ScheduledJobDAO jobDAO = JobDAOMap.get(jobDAOId);
 				if (paramValue != null && paramName != null) {
 					ScheduledJobParamDAO jobParamDAO = jobDAO.getJobParam(paramName);
 					if(jobParamDAO != null && jobParamDAO.getValue().equals(paramValue)) {
 						jobInfoXML +=  jobToXML(JobDAOMap.get(jobDAOId));
+					}
+				}
             daigle
-            daigle
+			jobInfoXML += "</scheduledWorkflowResultset>";
             daigle
 		} catch (AccessException ae) {
 			throw new ServiceException("SchedulerService.getJobInfoXML - Could not get jobs info for group: "
 					+ groupName, ae);
+		}
 		return jobInfoXML;
+	}
-            daigle
+	/**
 	 * Convert a single job to XML
 	 * @param scheduledJobDAO the job we want to convert
 	 * @return an XML representation of the job
 	 */
-            daigle
+	public String jobToXML(ScheduledJobDAO scheduledJobDAO) throws ServiceException {
-            daigle
+		String jobXML = "";
             daigle
-            daigle
+		if (scheduledJobDAO != null) {
 			jobXML += "<scheduledJob>";
 			jobXML += "<id>" + scheduledJobDAO.getId() + "</id>";
 			jobXML += "<createTime>" + scheduledJobDAO.getCreateTime() + "</createTime>";
 			jobXML += "<modTime>" + scheduledJobDAO.getModTime() + "</modTime>";
 			jobXML += "<status>" + scheduledJobDAO.getStatus() + "</status>";
 			jobXML += "<name>" + scheduledJobDAO.getName() + "</name>";
 			jobXML += "<triggerName>" + scheduledJobDAO.getName() + "</triggerName>";
 			jobXML += "<groupName>" + scheduledJobDAO.getGroupName() + "</groupName>";
-            daigle
+			jobXML += "<className>" + scheduledJobDAO.getClassName() + "</className>";
-            daigle
+			String startTimeString = null;
 			try {
 				startTimeString =
-            daigle
+					DateUtil.getHumanReadable(scheduledJobDAO.getStartTime());
-            daigle
+			} catch (UtilException ue) {
 				throw new ServiceException("SchedulerService.jobToXML - error getting human readable date for job: "
 						+ scheduledJobDAO.getId() + " ; " + ue.getMessage());
+			}
-            daigle
+			jobXML += "<startTime>" + startTimeString + "</startTime>";
 			String endTimeString = null;
 			try {
 				if (scheduledJobDAO.getEndTime() != null) {
 					endTimeString = DateUtil.getHumanReadable(scheduledJobDAO.getEndTime());
+				}
 			} catch (UtilException ue) {
 				throw new ServiceException("SchedulerService.jobToXML - error getting human readable date for job: "
 						+ scheduledJobDAO.getId() + " ; " + ue.getMessage());
+			}
 			jobXML += "<endTime>" + endTimeString + "</endTime>";
 			jobXML += "<intervalValue>" + scheduledJobDAO.getIntervalValue() + "</intervalValue>";
 			jobXML += "<intervalUnit>" + scheduledJobDAO.getIntervalUnit() + "</intervalUnit>";
             daigle
 			HashMap<String, ScheduledJobParamDAO> jobParams = scheduledJobDAO
 					.getAllJobParams();
 			for (String jobParamKey : jobParams.keySet()) {
-            daigle
+				jobXML += "<jobParam name='" + jobParams.get(jobParamKey).getKey() + "'>";
-            daigle
+				jobXML += "<id>" + jobParams.get(jobParamKey).getId() + "</id>";
 				jobXML += "<createTime>" + jobParams.get(jobParamKey).getCreateTime()
 						+ "</createTime>";
 				jobXML += "<modTime>" + jobParams.get(jobParamKey).getModTime()
 						+ "</modTime>";
 				jobXML += "<status>" + jobParams.get(jobParamKey).getStatus()
 						+ "</status>";
 				jobXML += "<jobId>" + jobParams.get(jobParamKey).getJobId() + "</jobId>";
 				jobXML += "<key>" + jobParams.get(jobParamKey).getKey() + "</key>";
 				jobXML += "<value>" + jobParams.get(jobParamKey).getValue() + "</value>";
 				jobXML += "</jobParam>";
+			}
 			jobXML += "</scheduledJob>";
+		}
 		return jobXML;
+	}
-            daigle
+	/**
 	 * Start a job in the scheduler
+	 *
 	 * @param jobName
 	 *            the name of the job
 	 * @param startCal
 	 *            a calendar holding the start date of the job
 	 * @param intervalValue
 	 *            the run interval for the job
 	 * @param intervalUnit
 	 *            the unit of the run interval for the job
 	 * @param jobClassName
 	 *            the job class name
 	 * @param jobGroup
 	 *            the job group name
 	 * @param jobParams
 	 *            a map of additional job parameters
 	 * @param username
 	 *            the user name
 	 * @param groups
 	 *            the user's group name
 	 */
-            daigle
+	private void startJob(String jobName, Calendar startCal, Calendar endCal, int intervalValue, String intervalUnit,
-            daigle
+			Class<Job> jobClass, String jobGroup, HashMap<String, String> jobParams) throws ServiceException {
 		JobDetail jobDetail = new JobDetail(jobName, jobGroup, jobClass);
 		jobDetail.setJobDataMap(new JobDataMap(jobParams));
-            daigle
+		char intervalChar = intervalUnit.charAt(0);
-            daigle
+		// call the appropriate scheduling method depending on the schedule interval unit
-            daigle
+		switch (intervalChar) {
-            daigle
+		case 's':
 		case 'S':
-            daigle
+			scheduleSecondlyJob(jobName, jobClass, startCal, endCal, intervalValue, jobGroup, jobDetail);
-            daigle
+			break;
 		case 'm':
 		case 'M':
-            daigle
+			scheduleMinutelyJob(jobName, jobClass, startCal, endCal, intervalValue, jobGroup, jobDetail);
-            daigle
+			break;
 		case 'h':
 		case 'H':
-            daigle
+			scheduleHourlyJob(jobName, jobClass, startCal, endCal, intervalValue, jobGroup, jobDetail);
-            daigle
+			break;
 		case 'd':
 		case 'D':
-            daigle
+			scheduleDailyJob(jobName, jobClass, startCal, endCal, intervalValue, jobGroup, jobDetail);
-            daigle
+			break;
 		default:
 			throw new ServiceException("SchedulerService.scheduleJob - Could not interpret interval unit: "
 					+ intervalUnit + ". Unit must be s, m, h or d");
+		}
+	}
-            daigle
+	/**
 	 * Schedule a job in the scheduler that has an interval based in seconds
+	 *
 	 * @param jobName
 	 *            the name of the job
 	 * @param jobClass
 	 *            the job class object
 	 * @param startTime
 	 *            the time of the first run
 	 * @param interval
 	 *            the interval in seconds between runs
 	 * @param jobGroup
 	 *            the group of this job
 	 * @param jobDetail
 	 *            the job detail object
 	 */
-            daigle
+	private void scheduleSecondlyJob(String jobName, Class<Job> jobClass, Calendar startTime, Calendar endTime, int interval, String jobGroup, JobDetail jobDetail) throws ServiceException {
             daigle
-            daigle
+		Trigger trigger = TriggerUtils.makeSecondlyTrigger(interval);
-            daigle
+		trigger.setName(jobName);
-            daigle
+		trigger.setStartTime(startTime.getTime());
-            daigle
+		if (endTime != null) {
 			trigger.setEndTime(endTime.getTime());
+		}
             daigle
 		try {
 			sched.scheduleJob(jobDetail, trigger);
 		} catch (SchedulerException se) {
 			throw new ServiceException("SchedulerService.scheduleSecondlyJob - Could not create "
 					+ "scheduler: " + se.getMessage());
+		}
+	}
-            daigle
+	/**
 	 * Schedule a job in the scheduler that has an interval based in minutes
+	 *
 	 * @param jobName
 	 *            the name of the job
 	 * @param jobClass
 	 *            the job class object
 	 * @param startTime
 	 *            the time of the first run
 	 * @param interval
 	 *            the interval in minutes between runs
 	 * @param jobGroup
 	 *            the group of this job
 	 * @param jobDetail
 	 *            the job detail object
 	 */
-            daigle
+	private void scheduleMinutelyJob(String jobName, Class<Job> jobClass, Calendar startTime, Calendar endTime, int interval, String jobGroup, JobDetail jobDetail) throws ServiceException {
             daigle
 		Trigger trigger = TriggerUtils.makeMinutelyTrigger(interval);
-            daigle
+		trigger.setName(jobName);
-            daigle
+		trigger.setStartTime(startTime.getTime());
-            daigle
+		if (endTime != null) {
 			trigger.setEndTime(endTime.getTime());
+		}
             daigle
 		try {
 			sched.scheduleJob(jobDetail, trigger);
 		} catch (SchedulerException se) {
 			throw new ServiceException("SchedulerService.scheduleMinutelyJob - Could not create "
 					+ "scheduler: " + se.getMessage());
+		}
+	}
-            daigle
+	/**
 	 * Schedule a job in the scheduler that has an interval based in hours
+	 *
 	 * @param jobName
 	 *            the name of the job
 	 * @param jobClass
 	 *            the job class object
 	 * @param startTime
 	 *            the time of the first run
 	 * @param interval
 	 *            the interval in hours between runs
 	 * @param jobGroup
 	 *            the group of this job
 	 * @param jobDetail
 	 *            the job detail object
 	 */
-            daigle
+	private void scheduleHourlyJob(String jobName, Class<Job> jobClass, Calendar startTime, Calendar endTime, int interval, String jobGroup, JobDetail jobDetail) throws ServiceException {
             daigle
 		Trigger trigger = TriggerUtils.makeHourlyTrigger(interval);
-            daigle
+		trigger.setName(jobName);
-            daigle
+		trigger.setStartTime(startTime.getTime());
-            daigle
+		if (endTime != null) {
 			trigger.setEndTime(endTime.getTime());
+		}
             daigle
 		try {
 			sched.scheduleJob(jobDetail, trigger);
 		} catch (SchedulerException se) {
 			throw new ServiceException("SchedulerService.scheduleHourlyJob - Could not create "
 					+  "scheduler: " + se.getMessage());
+		}
+	}
-            daigle
+	/**
 	 * Schedule a job in the scheduler that has an interval based in days
+	 *
 	 * @param jobName
 	 *            the name of the job
 	 * @param jobClass
 	 *            the job class object
 	 * @param startTime
 	 *            the time of the first run
 	 * @param interval
 	 *            the interval in days between runs
 	 * @param jobGroup
 	 *            the group of this job
 	 * @param jobDetail
 	 *            the job detail object
 	 */
-            daigle
+	private void scheduleDailyJob(String jobName, Class<Job> jobClass, Calendar startTime, Calendar endTime, int interval, String jobGroup, JobDetail jobDetail) throws ServiceException {
             daigle
 		Trigger trigger = TriggerUtils.makeHourlyTrigger(interval * 24);
-            daigle
+		trigger.setName(jobName);
-            daigle
+		trigger.setStartTime(startTime.getTime());
-            daigle
+		if (endTime != null) {
 			trigger.setEndTime(endTime.getTime());
+		}
             daigle
 		try {
 			sched.scheduleJob(jobDetail, trigger);
 		} catch (SchedulerException se) {
 			throw new ServiceException("SchedulerService.scheduleHourlyJob - Could not create "
 					+ "scheduler: " + se.getMessage());
+		}
+	}
-            daigle
+	/**
 	 * Extract the start date from the delay value
+	 *
 	 * @param delay
 	 *            a string representing the start delay in <value><unit>
 	 *            notation where value is an integer and unit is one of s,m,h or
 	 *            d
 	 * @return the calendar object holding the start date
 	 */
-            daigle
+	public Calendar getStartDateFromDelay(String delay) throws ServiceException {
-            daigle
+		Calendar cal = Calendar.getInstance();
-            daigle
+		char delayUnit = delay.trim().charAt(delay.length() - 1);
-            daigle
+		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 "
-            daigle
+					+ "parse delay value into an integer: " + delayStrValue + " : " + nfe.getMessage());
             daigle
 		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;
             daigle
             daigle

Project

General

Profile

Metacat