Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that handles scheduling workflow jobs

 *  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.workflowscheduler;

import java.io.IOException;

import java.io.PrintWriter;

import java.util.Hashtable;

import java.util.HashMap;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.xml.xpath.XPathFactory;

import org.apache.log4j.Logger;

import org.ecoinformatics.ecogrid.client.AuthenticationServiceClient;

import edu.ucsb.nceas.metacat.scheduler.ScheduledJobAccess;

import edu.ucsb.nceas.metacat.scheduler.ScheduledJobDAO;

import edu.ucsb.nceas.metacat.scheduler.SchedulerService;

import edu.ucsb.nceas.metacat.scheduler.MetacatSchedulerException;

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

import edu.ucsb.nceas.metacat.util.ErrorSendingErrorException;

import edu.ucsb.nceas.metacat.util.ResponseUtil;

import edu.ucsb.nceas.utilities.DateUtil;

/**

 * @author daigle

 *

 */

public class WorkflowScheduler extends BaseScheduler {

	private static WorkflowScheduler workflowScheduler = null;

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

	private static String WORKFLOW_JOB_GROUP = "workflow";

	private static String WORKFLOW_JOB_CLASS = "edu.ucsb.nceas.workflowscheduler.WorkflowJob";

	/**

	 * private constructor since this is a singleton

	 */

	private WorkflowScheduler()  {}

	/**

	 * Get the single instance of SchedulerService.

	 *

	 * @return the single instance of SchedulerService

	 */

	public static WorkflowScheduler getInstance() {

		if (workflowScheduler == null) {

			workflowScheduler = new WorkflowScheduler();

		}

		return workflowScheduler;

	}

	/**

	 * Scheduling a workflow

	 *

	 * @param request

	 *            the servlet request object

	 * @param response

	 *            the servlet response object

	 * @param params

	 *            the request parameters

	 * @param username

	 *            the user

	 * @param groups

	 *            the user's group

	 */

	public void scheduleJob(HttpServletRequest request, HttpServletResponse response,

		String sessionIds[] = params.get("sessionid");

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

		String endTimes[] = params.get("endtime");

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

		Calendar startCal = null;

		Calendar endCal = null;

		if (sessionIds == null) {

			throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - sessionid field must be populated "

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

		}

		String sessionStatus = validateRemoteSession(sessionIds[0]);

		logMetacat.debug("WorkflowScheduler.scheduleJob - session status: " + sessionStatus);

		if (!sessionStatus.equals("valid")) {

			throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - session "

			SchedulerService schedulerService = SchedulerService.getInstance();

			// get start time or delay.  Start time takes precedence if both exist.

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

				startCal = DateUtil.humanReadableToCalendar(startTimes[0], "MM/dd/yyyy HH:mm:ss");

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

				startCal = schedulerService.getStartDateFromDelay(delays[0]);

			} else {

				// if delay and starttime were not provided, set date to now.

				startCal = Calendar.getInstance();

			}

			// get end time.  null is fine.

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

				endCal = DateUtil.humanReadableToCalendar(endTimes[0], "MM/dd/yyyy HH:mm:ss");

			}

			// interval value must exist

			String intervalValues[] = params.get("intervalvalue");

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

				throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - intervalvalue field must be populated "

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

			}

			String intervalStrValue = intervalValues[0];

			int intervalValue = Integer.parseInt(intervalStrValue);

			// interval unit must exist

			String intervalUnits[] = params.get("intervalunit");

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

				throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - intervalunit field must be populated "

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

			}

			String intervalUnit = intervalUnits[0];

			// workflow id must exist.  Add to job params

			String workflowids[] = params.get("workflowid");

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

				throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - workflowid field must be populated "

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

			}

			jobParams.put("workflowid", workflowids[0]);

			if (!workflowAuthorizeStatus.equals("true")) {

				throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - session "

						+ request.getSession().getId() + " is not authorized to write workflow " + workflowids[0]  + ".");

			}

			String karids[] = params.get("karid");

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

				throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - karid field must be populated "

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

			}

			jobParams.put("karid", karids[0]);

			if (!karAuthorizeStatus.equals("true")) {

				throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - session "

						+ request.getSession().getId() + " is not authorized to read kar " + karids[0]  + ".");

			}

			// workflow name unit must exist.  Add to job params

			String workflownames[] = params.get("workflowname");

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

				throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - workflowname field must be populated "

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

			}

			jobParams.put("workflowname", workflownames[0]);

			String jobName = WORKFLOW_JOB_GROUP

					+ Calendar.getInstance().getTimeInMillis();

			// Schedule the job

			String xmlResult = schedulerService.scheduleJob(jobName, startCal, endCal, intervalValue, intervalUnit,

			ResponseUtil.sendSuccessXML(response, xmlResult);

		} catch (UtilException ue) {

			throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - "

					+ "Utility issue when scheduling job: " + ue.getMessage());

		} catch (ServiceException se) {

			throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - "

					+ "Service issue when scheduling job", se);

		} catch (ErrorSendingErrorException esee) {

			throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - "

					+ "Issue sending error when scheduling job: " + esee.getMessage());

		}

	}

	/**

	 * Unschedule a job

	 *

	 * @param request

	 *            the servlet request object

	 * @param response

	 *            the servlet response object

	 * @param params

	 *            the request parameters

	 * @param username

	 *            the user

	 * @param groups

	 *            the user's group

	 */

			throws MetacatSchedulerException {

		try {

			// interval value must exist

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

				throw new MetacatSchedulerException("WorkflowScheduler.unscheduleJob - sessionid field must be populated "

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

			}

			String sessionStatus = validateRemoteSession(sessionIds[0]);

			logMetacat.debug("WorkflowScheduler.unscheduleJob - session status: " + sessionStatus);

			if (!sessionStatus.equals("valid")) {

				throw new MetacatSchedulerException("WorkflowScheduler.unscheduleJob - session "

						+ sessionIds[0] + " is not valid.");

			}

			}

			String jobName = jobNames[0];

			// unschedule the job

			SchedulerService schedulerService = SchedulerService.getInstance();

			ResponseUtil.sendSuccessXML(response, xmlResult);

		} catch (ServiceException se) {

			throw new MetacatSchedulerException("WorkflowScheduler.unScheduleJob - "

					+ "Service issue unscheduling job", se);

		} catch (Exception e) {

			throw new MetacatSchedulerException("WorkflowScheduler.unScheduleJob - "

					+ "Generic issue unscheduling job: " + e.getMessage());

		}

	}

	/**

	 * reschedule job

	 *

	 * @param request

	 *            the servlet request object

	 * @param response

	 *            the servlet response object

	 * @param params

	 *            the request parameters

	 * @param username

	 *            the user

	 * @param groups

	 *            the user's group

	 */

			String[] groups) throws MetacatSchedulerException {

		try {

			// interval value must exist

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

				throw new MetacatSchedulerException("WorkflowScheduler.rescheduleJob - sessionid field must be populated "

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

			}

			String sessionStatus = validateRemoteSession(sessionIds[0]);

			logMetacat.debug("WorkflowScheduler.rescheduleJob - session status: " + sessionStatus);

			if (!sessionStatus.equals("valid")) {

				throw new MetacatSchedulerException("WorkflowScheduler.scheduleJob - session "

						+ sessionIds[0] + " is not valid.");

			}

			}

			String jobName = jobNames[0];

			ScheduledJobAccess jobAccess = new ScheduledJobAccess();

			ScheduledJobDAO jobDAO = jobAccess.getJobByName(jobName);

			// reschedule the job

			SchedulerService schedulerService = SchedulerService.getInstance();

			String result = schedulerService.rescheduleJob(jobDAO, username, groups);

			ResponseUtil.sendSuccessXML(response, result);

		} catch (AccessException ae) {

					+ "DB access issue when rescheduling job  : ", ae);

					+ "Service issue rescheduling job", se);

					+ "Issue sending erro when rescheduling job: " + esee.getMessage());

	}

	/**

	 * delete job - to be implemented

	 */

	public void deleteJob(HttpServletRequest request, HttpServletResponse response,

			Hashtable<String, String[]> params, String username, String[] groups) throws MetacatSchedulerException {

		 try {

			// interval value must exist

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

				throw new MetacatSchedulerException("WorkflowScheduler.deleteJob - sessionid field must be populated "

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

			}

			String sessionStatus = validateRemoteSession(sessionIds[0]);

			logMetacat.debug("WorkflowScheduler.rescheduleJob - session status: " + sessionStatus);

			if (!sessionStatus.equals("valid")) {

				throw new MetacatSchedulerException("WorkflowScheduler.deleteJob - session "

						+ sessionIds[0] + " is not valid.");

			}

				throw new MetacatSchedulerException(

						"WorkflowScheduler.deleteJob - workflowname field must be populated "

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

			}

			String jobName = jobNames[0];

			ScheduledJobAccess jobAccess = new ScheduledJobAccess();

			ScheduledJobDAO jobDAO = jobAccess.getJobByName(jobName);

			// delete the job

			SchedulerService schedulerService = SchedulerService.getInstance();

			ResponseUtil.sendSuccessXML(response, result);

		} catch (AccessException ae) {

			throw new MetacatSchedulerException("WorkflowScheduler.deleteJob - "

					+ "DB access issue when deleting job  : ", ae);

		} catch (ServiceException se) {

			throw new MetacatSchedulerException("WorkflowScheduler.deleteJob - "

					+ "Service issue deleting job", se);

		} catch (ErrorSendingErrorException esee) {

			throw new MetacatSchedulerException("WorkflowScheduler.deleteJob - "

					+ "Issue sending erro when deleting job: " + esee.getMessage());

		}

	}

	/**

	 * get job information for a given workflow in xml format

	 *

	 * @param request

	 *            the servlet request object

	 * @param response

	 *            the servlet response object

	 * @param params

	 *            the request parameters

	 * @param username

	 *            the user

	 * @param groups

	 *            the user's group

	 */

	public void getJobs(HttpServletRequest request, HttpServletResponse response,

			Hashtable<String, String[]> params, String username, String[] groups) throws MetacatSchedulerException {

		String workflowId = null;

		String workflowIds[] = params.get("workflowid");

		if (workflowIds != null && workflowIds.length != 0) {

			workflowId = workflowIds[0];

		}

		logMetacat.debug("WorkflowScheduler.getJobs - getting jobs for workflow:" + workflowId);

        PrintWriter out = null;

		try {

			// get the job info in xml format

			out = response.getWriter();

			SchedulerService.getInstance().getJobsInfoXML(WORKFLOW_JOB_GROUP,

					"workflowid", workflowId, out);

		} catch (ServiceException se) {

			throw new MetacatSchedulerException("WorkflowScheduler.getJobs - "

					+ "Service error when transforming XML for workflow id: "

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

		} catch (IOException ioe) {

			throw new MetacatSchedulerException("WorkflowScheduler.getJobs - "

					+ "I/O error when transforming XML for workflow id: "

					+ workflowId + " : " + ioe.getMessage());

		} finally {

			if (out != null) {

				out.close();

			}

		}

	}

	private String validateRemoteSession(String sessionId) throws MetacatSchedulerException {

		String sessionStatus = "unknown";

	    XPath xpath = XPathFactory.newInstance().newXPath();

		try {

			String ecogridUrl = PropertyService.getProperty("workflowScheduler.authServiceUrl");

			AuthenticationServiceClient authServiceClient =

					new AuthenticationServiceClient(ecogridUrl);

			String sessionStatusXML = authServiceClient.validate_session_action(sessionId);

			sessionStatus =

				xpath.evaluate("/validateSession/status",  new InputSource(new StringReader(sessionStatusXML)));

		} catch (PropertyNotFoundException pnfe) {

			throw new MetacatSchedulerException("WorkflowScheduler.validateSession - Could not "

					+ "find property: " + pnfe.getMessage());

		} catch (Exception e) {

			throw new MetacatSchedulerException("WorkflowScheduler.validateSession - "

					+ "general error when validating Session: " + e.getMessage());

		}

		return sessionStatus;

	}

	private String authorizeRemoteSession(String sessionId, String resourceLsid, String permission)

		throws MetacatSchedulerException {

		String authStatus = "unknown";

	    XPath xpath = XPathFactory.newInstance().newXPath();

		try {

			String ecogridUrl = PropertyService.getProperty("workflowScheduler.authorizationServiceUrl");

			AuthorizationServiceClient authorizationServiceClient =

					new AuthorizationServiceClient(ecogridUrl);

			String authStatusXML = authorizationServiceClient.is_authorized_action(sessionId, resourceLsid, permission);

			authStatus =

				xpath.evaluate("/resourceAuthorization/isAuthorized",  new InputSource(new StringReader(authStatusXML)));

		} catch (PropertyNotFoundException pnfe) {

			throw new MetacatSchedulerException("WorkflowScheduler.authorizeRemoteSession - Could not "

					+ "find property: " + pnfe.getMessage());

		} catch (Exception e) {

			throw new MetacatSchedulerException("WorkflowScheduler.authorizeRemoteSession - "

					+ "general error when authorizing Session: " + e.getMessage());

		}

		return authStatus;

	}